[wxWidgets.git] / src / stc / stc.cpp.in

////////////////////////////////////////////////////////////////////////////
// Name:        stc.cpp
// Purpose:     A wxWindows implementation of Scintilla.  This class is the
//              one meant to be used directly by wx applications.  It does not
//              derive directly from the Scintilla classes, but instead
//              delegates most things to the real Scintilla class.
//              This allows the use of Scintilla without polluting the
//              namespace with all the classes and identifiers from Scintilla.
//
// Author:      Robin Dunn
//
// Created:     13-Jan-2000
// RCS-ID:      $Id$
// Copyright:   (c) 2000 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#include <ctype.h>

#include "wx/stc/stc.h"
#include "ScintillaWX.h"

#include <wx/tokenzr.h>

// The following code forces a reference to all of the Scintilla lexers.
// If we don't do something like this, then the linker tends to "optimize"
// them away. (eric@sourcegear.com)

int wxForceScintillaLexers(void)
{
  extern LexerModule lmAda;
  extern LexerModule lmAVE;
  extern LexerModule lmConf;
  extern LexerModule lmCPP;
  extern LexerModule lmNncrontab;
  extern LexerModule lmEiffel;
  extern LexerModule lmHTML;
  extern LexerModule lmLISP;
  extern LexerModule lmLua;
  extern LexerModule lmBatch;  // In LexOthers.cxx
  extern LexerModule lmPascal;
  extern LexerModule lmPerl;
  extern LexerModule lmPython;
  extern LexerModule lmRuby;
  extern LexerModule lmSQL;
  extern LexerModule lmVB;

  if (  &lmAda
     && &lmAVE
     && &lmConf
     && &lmCPP
     && &lmNncrontab
     && &lmEiffel
     && &lmHTML
     && &lmLISP
     && &lmLua
     && &lmBatch
     && &lmPascal
     && &lmPerl
     && &lmPython
     && &lmRuby
     && &lmSQL
     && &lmVB )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

//----------------------------------------------------------------------

const wxChar* wxSTCNameStr = "stcwindow";

DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )
DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
DEFINE_EVENT_TYPE( wxEVT_STC_DWELLSTART )
DEFINE_EVENT_TYPE( wxEVT_STC_DWELLEND )
DEFINE_EVENT_TYPE( wxEVT_STC_START_DRAG )
DEFINE_EVENT_TYPE( wxEVT_STC_DRAG_OVER )
DEFINE_EVENT_TYPE( wxEVT_STC_DO_DROP )


BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
    EVT_PAINT                   (wxStyledTextCtrl::OnPaint)
    EVT_SCROLLWIN               (wxStyledTextCtrl::OnScrollWin)
    EVT_SCROLL                  (wxStyledTextCtrl::OnScroll)
    EVT_SIZE                    (wxStyledTextCtrl::OnSize)
    EVT_LEFT_DOWN               (wxStyledTextCtrl::OnMouseLeftDown)
#ifdef __WXMSW__
    // Let Scintilla see the double click as a second click
    EVT_LEFT_DCLICK             (wxStyledTextCtrl::OnMouseLeftDown)
#endif
    EVT_MOTION                  (wxStyledTextCtrl::OnMouseMove)
    EVT_LEFT_UP                 (wxStyledTextCtrl::OnMouseLeftUp)
#ifdef __WXGTK__
    EVT_RIGHT_UP                (wxStyledTextCtrl::OnMouseRightUp)
#else
    EVT_CONTEXT_MENU            (wxStyledTextCtrl::OnContextMenu)
#endif
    EVT_MOUSEWHEEL              (wxStyledTextCtrl::OnMouseWheel)
    EVT_CHAR                    (wxStyledTextCtrl::OnChar)
    EVT_KEY_DOWN                (wxStyledTextCtrl::OnKeyDown)
    EVT_KILL_FOCUS              (wxStyledTextCtrl::OnLoseFocus)
    EVT_SET_FOCUS               (wxStyledTextCtrl::OnGainFocus)
    EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
    EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
    EVT_MENU_RANGE              (-1, -1, wxStyledTextCtrl::OnMenu)
    EVT_LISTBOX_DCLICK          (-1, wxStyledTextCtrl::OnListBox)
END_EVENT_TABLE()


IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)

//----------------------------------------------------------------------
// Constructor and Destructor

wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
                                   wxWindowID id,
                                   const wxPoint& pos,
                                   const wxSize& size,
                                   long style,
                                   const wxString& name) :
    wxControl(parent, id, pos, size,
              style | wxVSCROLL | wxHSCROLL | wxWANTS_CHARS | wxCLIP_CHILDREN,
              wxDefaultValidator, name)
{
    wxForceScintillaLexers();
    m_swx = new ScintillaWX(this);
    m_stopWatch.Start();
    m_lastKeyDownConsumed = FALSE;
    m_vScrollBar = NULL;
    m_hScrollBar = NULL;
}


wxStyledTextCtrl::~wxStyledTextCtrl() {
    delete m_swx;
}


//----------------------------------------------------------------------

long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {

    return m_swx->WndProc(msg, wp, lp);
}


#ifdef MAKELONG
#undef MAKELONG
#endif

#define MAKELONG(a, b) ((a) | ((b) << 16))


static long wxColourAsLong(const wxColour& co) {
    return (((long)co.Blue()  << 16) |
            ((long)co.Green() <<  8) |
            ((long)co.Red()));
}

static wxColour wxColourFromLong(long c) {
    wxColour clr;
    clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
    return clr;
}


static wxColour wxColourFromSpec(const wxString& spec) {
    // spec should be #RRGGBB
    char* junk;
    int red   = strtol(spec.Mid(1,2), &junk, 16);
    int green = strtol(spec.Mid(3,2), &junk, 16);
    int blue  = strtol(spec.Mid(5,2), &junk, 16);
    return wxColour(red, green, blue);
}


//----------------------------------------------------------------------
// BEGIN generated section.  The following code is automatically generated
//       by gen_iface.py from the contents of Scintilla.iface.  Do not edit
//       this file.  Edit stc.cpp.in or gen_iface.py instead and regenerate.

%(METHOD_IMPS)s

// END of generated section
//----------------------------------------------------------------------


// Returns the line number of the line with the caret.
int wxStyledTextCtrl::GetCurrentLine() {
    int line = LineFromPosition(GetCurrentPos());
    return line;
}


// Extract style settings from a spec-string which is composed of one or
// more of the following comma separated elements:
//
//      bold                    turns on bold
//      italic                  turns on italics
//      fore:#RRGGBB            sets the foreground colour
//      back:#RRGGBB            sets the background colour
//      face:[facename]         sets the font face name to use
//      size:[num]              sets the font size in points
//      eol                     turns on eol filling
//      underline               turns on underlining
//
void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {

    wxStringTokenizer tkz(spec, ",");
    while (tkz.HasMoreTokens()) {
        wxString token = tkz.GetNextToken();

        wxString option = token.BeforeFirst(':');
        wxString val = token.AfterFirst(':');

        if (option == "bold")
            StyleSetBold(styleNum, true);

        else if (option == "italic")
            StyleSetItalic(styleNum, true);

        else if (option == "underline")
            StyleSetUnderline(styleNum, true);

        else if (option == "eol")
            StyleSetEOLFilled(styleNum, true);

        else if (option == "size") {
            long points;
            if (val.ToLong(&points))
                StyleSetSize(styleNum, points);
        }

        else if (option == "face")
            StyleSetFaceName(styleNum, val);

        else if (option == "fore")
            StyleSetForeground(styleNum, wxColourFromSpec(val));

        else if (option == "back")
            StyleSetBackground(styleNum, wxColourFromSpec(val));
    }
}


// Set style size, face, bold, italic, and underline attributes from
// a wxFont's attributes.
void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
    int      size     = font.GetPointSize();
    wxString faceName = font.GetFaceName();
    bool     bold     = font.GetWeight() == wxBOLD;
    bool     italic   = font.GetStyle() != wxNORMAL;
    bool     under    = font.GetUnderlined();

    // TODO: add encoding/charset mapping
    StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
}

// Set all font style attributes at once.
void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
                                        const wxString& faceName,
                                        bool bold, bool italic,
                                        bool underline) {
    StyleSetSize(styleNum, size);
    StyleSetFaceName(styleNum, faceName);
    StyleSetBold(styleNum, bold);
    StyleSetItalic(styleNum, italic);
    StyleSetUnderline(styleNum, underline);

    // TODO: add encoding/charset mapping
}


// Perform one of the operations defined by the wxSTC_CMD_* constants.
void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
    SendMsg(cmd);
}


// Set the left and right margin in the edit area, measured in pixels.
void wxStyledTextCtrl::SetMargins(int left, int right) {
    SetMarginLeft(left);
    SetMarginRight(right);
}


// Retrieve the start and end positions of the current selection.
void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
    if (startPos != NULL)
        *startPos = SendMsg(SCI_GETSELECTIONSTART);
    if (endPos != NULL)
        *endPos = SendMsg(SCI_GETSELECTIONEND);
}


// Retrieve the point in the window where a position is displayed.
wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
    int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
    int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
    return wxPoint(x, y);
}

// Scroll enough to make the given line visible
void wxStyledTextCtrl::ScrollToLine(int line) {
    m_swx->DoScrollToLine(line);
}


// Scroll enough to make the given column visible
void wxStyledTextCtrl::ScrollToColumn(int column) {
    m_swx->DoScrollToColumn(column);
}


//----------------------------------------------------------------------
// Event handlers

void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
    wxPaintDC dc(this);
    wxRegion  region = GetUpdateRegion();

    m_swx->DoPaint(&dc, region.GetBox());
}

void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
    if (evt.GetOrientation() == wxHORIZONTAL)
        m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
    else
        m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
}

void wxStyledTextCtrl::OnScroll(wxScrollEvent& evt) {
    wxScrollBar* sb = wxDynamicCast(evt.GetEventObject(), wxScrollBar);
    if (sb) {
        if (sb->IsVertical())
            m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
        else
            m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
    }
}

void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
    wxSize sz = GetClientSize();
    m_swx->DoSize(sz.x, sz.y);
}

void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
    wxPoint pt = evt.GetPosition();
    m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
                      evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
}

void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
    wxPoint pt = evt.GetPosition();
    m_swx->DoButtonMove(Point(pt.x, pt.y));
}

void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
    wxPoint pt = evt.GetPosition();
    m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
                      evt.ControlDown());
}


void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
    wxPoint pt = evt.GetPosition();
    m_swx->DoContextMenu(Point(pt.x, pt.y));
}


void wxStyledTextCtrl::OnContextMenu(wxContextMenuEvent& evt) {
    wxPoint pt = evt.GetPosition();
    ScreenToClient(&pt.x, &pt.y);
    m_swx->DoContextMenu(Point(pt.x, pt.y));
}


void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
    m_swx->DoMouseWheel(evt.GetWheelRotation(),
                        evt.GetWheelDelta(),
                        evt.GetLinesPerAction(),
                        evt.ControlDown());
}


void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
    long key = evt.KeyCode();

//      printf("OnChar  key:%%d  consumed:%%d  ctrl:%%d  alt:%%d\n",
//             key, m_lastKeyDownConsumed, evt.ControlDown(), evt.AltDown());

    // AltGr keys???
Commit	Line	Data
f97d84a6 RD	1	////////////////////////////////////////////////////////////////////////////
	2	// Name: stc.cpp
	3	// Purpose: A wxWindows implementation of Scintilla. This class is the
	4	// one meant to be used directly by wx applications. It does not
	5	// derive directly from the Scintilla classes, but instead
	6	// delegates most things to the real Scintilla class.
	7	// This allows the use of Scintilla without polluting the
	8	// namespace with all the classes and identifiers from Scintilla.
	9	//
	10	// Author: Robin Dunn
	11	//
	12	// Created: 13-Jan-2000
	13	// RCS-ID: $Id$
	14	// Copyright: (c) 2000 by Total Control Software
	15	// Licence: wxWindows license
	16	/////////////////////////////////////////////////////////////////////////////
	17
	18	#include <ctype.h>
	19
	20	#include "wx/stc/stc.h"
	21	#include "ScintillaWX.h"
	22
	23	#include <wx/tokenzr.h>
	24
	25	// The following code forces a reference to all of the Scintilla lexers.
	26	// If we don't do something like this, then the linker tends to "optimize"
	27	// them away. (eric@sourcegear.com)
	28
	29	int wxForceScintillaLexers(void)
	30	{
65ec6247 RD	31	extern LexerModule lmAda;
	32	extern LexerModule lmAVE;
	33	extern LexerModule lmConf;
f97d84a6	34	extern LexerModule lmCPP;
b8b0e402	35	extern LexerModule lmNncrontab;
65ec6247	36	extern LexerModule lmEiffel;
f97d84a6	37	extern LexerModule lmHTML;
65ec6247 RD	38	extern LexerModule lmLISP;
	39	extern LexerModule lmLua;
	40	extern LexerModule lmBatch; // In LexOthers.cxx
	41	extern LexerModule lmPascal;
f97d84a6 RD	42	extern LexerModule lmPerl;
f97d84a6 RD	43	extern LexerModule lmPython;
65ec6247	44	extern LexerModule lmRuby;
f97d84a6 RD	45	extern LexerModule lmSQL;
	46	extern LexerModule lmVB;
	47
65ec6247 RD	48	if ( &lmAda
	49	&& &lmAVE
	50	&& &lmConf
	51	&& &lmCPP
b8b0e402	52	&& &lmNncrontab
65ec6247 RD	53	&& &lmEiffel
	54	&& &lmHTML
	55	&& &lmLISP
	56	&& &lmLua
	57	&& &lmBatch
	58	&& &lmPascal
	59	&& &lmPerl
	60	&& &lmPython
	61	&& &lmRuby
	62	&& &lmSQL
	63	&& &lmVB )
f97d84a6 RD	64	{
	65	return 1;
	66	}
	67	else
	68	{
	69	return 0;
	70	}
	71	}
	72
	73	//----------------------------------------------------------------------
	74
	75	const wxChar* wxSTCNameStr = "stcwindow";
	76
d25f5fbb RD	77	DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
	78	DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
	79	DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
d25f5fbb RD	80	DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
	81	DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
	82	DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
65ec6247	83	DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
d25f5fbb	84	DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
65ec6247	85	DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
d25f5fbb	86	DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
d25f5fbb RD	87	DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
	88	DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
	89	DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
	90	DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )
65ec6247 RD	91	DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
	92	DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
	93	DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
	94	DEFINE_EVENT_TYPE( wxEVT_STC_DWELLSTART )
	95	DEFINE_EVENT_TYPE( wxEVT_STC_DWELLEND )
a29a241f RD	96	DEFINE_EVENT_TYPE( wxEVT_STC_START_DRAG )
	97	DEFINE_EVENT_TYPE( wxEVT_STC_DRAG_OVER )
	98	DEFINE_EVENT_TYPE( wxEVT_STC_DO_DROP )
d25f5fbb RD	99
d25f5fbb RD	100
f97d84a6 RD	101	BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
	102	EVT_PAINT (wxStyledTextCtrl::OnPaint)
	103	EVT_SCROLLWIN (wxStyledTextCtrl::OnScrollWin)
5fa4613c	104	EVT_SCROLL (wxStyledTextCtrl::OnScroll)
f97d84a6 RD	105	EVT_SIZE (wxStyledTextCtrl::OnSize)
f97d84a6 RD	106	EVT_LEFT_DOWN (wxStyledTextCtrl::OnMouseLeftDown)
4ceb1196 RD	107	#ifdef __WXMSW__
	108	// Let Scintilla see the double click as a second click
	109	EVT_LEFT_DCLICK (wxStyledTextCtrl::OnMouseLeftDown)
	110	#endif
f97d84a6 RD	111	EVT_MOTION (wxStyledTextCtrl::OnMouseMove)
f97d84a6 RD	112	EVT_LEFT_UP (wxStyledTextCtrl::OnMouseLeftUp)
ddf2da08 RD	113	#ifdef __WXGTK__
	114	EVT_RIGHT_UP (wxStyledTextCtrl::OnMouseRightUp)
	115	#else
65ec6247	116	EVT_CONTEXT_MENU (wxStyledTextCtrl::OnContextMenu)
ddf2da08	117	#endif
37d62433	118	EVT_MOUSEWHEEL (wxStyledTextCtrl::OnMouseWheel)
f97d84a6 RD	119	EVT_CHAR (wxStyledTextCtrl::OnChar)
	120	EVT_KEY_DOWN (wxStyledTextCtrl::OnKeyDown)
	121	EVT_KILL_FOCUS (wxStyledTextCtrl::OnLoseFocus)
	122	EVT_SET_FOCUS (wxStyledTextCtrl::OnGainFocus)
	123	EVT_SYS_COLOUR_CHANGED (wxStyledTextCtrl::OnSysColourChanged)
	124	EVT_ERASE_BACKGROUND (wxStyledTextCtrl::OnEraseBackground)
	125	EVT_MENU_RANGE (-1, -1, wxStyledTextCtrl::OnMenu)
	126	EVT_LISTBOX_DCLICK (-1, wxStyledTextCtrl::OnListBox)
	127	END_EVENT_TABLE()
	128
	129
	130	IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
	131	IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
	132
	133	//----------------------------------------------------------------------
	134	// Constructor and Destructor
	135
	136	wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
	137	wxWindowID id,
	138	const wxPoint& pos,
	139	const wxSize& size,
	140	long style,
	141	const wxString& name) :
	142	wxControl(parent, id, pos, size,
	143	style \| wxVSCROLL \| wxHSCROLL \| wxWANTS_CHARS \| wxCLIP_CHILDREN,
	144	wxDefaultValidator, name)
	145	{
32083aa0	146	wxForceScintillaLexers();
f97d84a6 RD	147	m_swx = new ScintillaWX(this);
f97d84a6 RD	148	m_stopWatch.Start();
d6582821	149	m_lastKeyDownConsumed = FALSE;
5fa4613c RD	150	m_vScrollBar = NULL;
5fa4613c RD	151	m_hScrollBar = NULL;
f97d84a6 RD	152	}
	153
	154
	155	wxStyledTextCtrl::~wxStyledTextCtrl() {
	156	delete m_swx;
	157	}
	158
	159
	160	//----------------------------------------------------------------------
	161
	162	long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
	163
	164	return m_swx->WndProc(msg, wp, lp);
	165	}
	166
	167
	168	#ifdef MAKELONG
	169	#undef MAKELONG
	170	#endif
	171
	172	#define MAKELONG(a, b) ((a) \| ((b) << 16))
	173
	174
	175	static long wxColourAsLong(const wxColour& co) {
	176	return (((long)co.Blue() << 16) \|
	177	((long)co.Green() << 8) \|
	178	((long)co.Red()));
	179	}
	180
	181	static wxColour wxColourFromLong(long c) {
	182	wxColour clr;
	183	clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
	184	return clr;
	185	}
	186
	187
	188	static wxColour wxColourFromSpec(const wxString& spec) {
	189	// spec should be #RRGGBB
	190	char* junk;
	191	int red = strtol(spec.Mid(1,2), &junk, 16);
	192	int green = strtol(spec.Mid(3,2), &junk, 16);
	193	int blue = strtol(spec.Mid(5,2), &junk, 16);
	194	return wxColour(red, green, blue);
	195	}
	196
	197
	198	//----------------------------------------------------------------------
	199	// BEGIN generated section. The following code is automatically generated
	200	// by gen_iface.py from the contents of Scintilla.iface. Do not edit
	201	// this file. Edit stc.cpp.in or gen_iface.py instead and regenerate.
	202
	203	%(METHOD_IMPS)s
	204
	205	// END of generated section
	206	//----------------------------------------------------------------------
	207
	208
	209	// Returns the line number of the line with the caret.
	210	int wxStyledTextCtrl::GetCurrentLine() {
	211	int line = LineFromPosition(GetCurrentPos());
	212	return line;
	213	}
	214
	215
216	// Extract style settings from a spec-string which is composed of one or
217	// more of the following comma separated elements:
218	//
219	// bold turns on bold
220	// italic turns on italics
221	// fore:#RRGGBB sets the foreground colour
222	// back:#RRGGBB sets the background colour
223	// face:[facename] sets the font face name to use
224	// size:[num] sets the font size in points
225	// eol turns on eol filling
226	// underline turns on underlining
227	//
228	void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
229
230	wxStringTokenizer tkz(spec, ",");
231	while (tkz.HasMoreTokens()) {
232	wxString token = tkz.GetNextToken();
233
234	wxString option = token.BeforeFirst(':');
235	wxString val = token.AfterFirst(':');
236
237	if (option == "bold")
238	StyleSetBold(styleNum, true);
239
240	else if (option == "italic")
241	StyleSetItalic(styleNum, true);
242
243	else if (option == "underline")
244	StyleSetUnderline(styleNum, true);
245
246	else if (option == "eol")
247	StyleSetEOLFilled(styleNum, true);
248
249	else if (option == "size") {
250	long points;
251	if (val.ToLong(&points))
252	StyleSetSize(styleNum, points);
253	}
254
255	else if (option == "face")
256	StyleSetFaceName(styleNum, val);
257
258	else if (option == "fore")
259	StyleSetForeground(styleNum, wxColourFromSpec(val));
260
261	else if (option == "back")
262	StyleSetBackground(styleNum, wxColourFromSpec(val));
263	}
264	}
265
266
267	// Set style size, face, bold, italic, and underline attributes from
268	// a wxFont's attributes.
269	void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
270	int size = font.GetPointSize();
271	wxString faceName = font.GetFaceName();
272	bool bold = font.GetWeight() == wxBOLD;
273	bool italic = font.GetStyle() != wxNORMAL;
274	bool under = font.GetUnderlined();
275
276	// TODO: add encoding/charset mapping
277	StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
278	}
279
280	// Set all font style attributes at once.
281	void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
282	const wxString& faceName,
283	bool bold, bool italic,
284	bool underline) {
285	StyleSetSize(styleNum, size);
286	StyleSetFaceName(styleNum, faceName);
287	StyleSetBold(styleNum, bold);
288	StyleSetItalic(styleNum, italic);
289	StyleSetUnderline(styleNum, underline);
290
291	// TODO: add encoding/charset mapping
292	}
293
294
295	// Perform one of the operations defined by the wxSTC_CMD_* constants.
296	void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
297	SendMsg(cmd);
298	}
299
300
301	// Set the left and right margin in the edit area, measured in pixels.
302	void wxStyledTextCtrl::SetMargins(int left, int right) {
303	SetMarginLeft(left);
304	SetMarginRight(right);
305	}
306
307
308	// Retrieve the start and end positions of the current selection.
309	void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
310	if (startPos != NULL)
311	*startPos = SendMsg(SCI_GETSELECTIONSTART);
312	if (endPos != NULL)
313	*endPos = SendMsg(SCI_GETSELECTIONEND);
314	}
315
316
317	// Retrieve the point in the window where a position is displayed.
318	wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
319	int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
320	int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
321	return wxPoint(x, y);
322	}
323
324	// Scroll enough to make the given line visible
325	void wxStyledTextCtrl::ScrollToLine(int line) {
326	m_swx->DoScrollToLine(line);
327	}
328
329
330	// Scroll enough to make the given column visible
331	void wxStyledTextCtrl::ScrollToColumn(int column) {
332	m_swx->DoScrollToColumn(column);
333	}
334
335
336
337	//----------------------------------------------------------------------
338	// Event handlers
339
340	void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
341	wxPaintDC dc(this);
342	wxRegion region = GetUpdateRegion();
343
344	m_swx->DoPaint(&dc, region.GetBox());
345	}
346
347	void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
348	if (evt.GetOrientation() == wxHORIZONTAL)
349	m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
350	else
351	m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
352	}
353
5fa4613c RD	354	void wxStyledTextCtrl::OnScroll(wxScrollEvent& evt) {
	355	wxScrollBar* sb = wxDynamicCast(evt.GetEventObject(), wxScrollBar);
	356	if (sb) {
	357	if (sb->IsVertical())
	358	m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
	359	else
	360	m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
	361	}
	362	}
	363
f97d84a6 RD	364	void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
	365	wxSize sz = GetClientSize();
	366	m_swx->DoSize(sz.x, sz.y);
	367	}
	368
	369	void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
	370	wxPoint pt = evt.GetPosition();
	371	m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
	372	evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
	373	}
	374
	375	void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
	376	wxPoint pt = evt.GetPosition();
	377	m_swx->DoButtonMove(Point(pt.x, pt.y));
	378	}
	379
	380	void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
	381	wxPoint pt = evt.GetPosition();
	382	m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
	383	evt.ControlDown());
	384	}
	385
	386
ddf2da08 RD	387	void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
	388	wxPoint pt = evt.GetPosition();
	389	m_swx->DoContextMenu(Point(pt.x, pt.y));
	390	}
	391
	392
65ec6247	393	void wxStyledTextCtrl::OnContextMenu(wxContextMenuEvent& evt) {
f97d84a6	394	wxPoint pt = evt.GetPosition();
65ec6247	395	ScreenToClient(&pt.x, &pt.y);
f97d84a6 RD	396	m_swx->DoContextMenu(Point(pt.x, pt.y));
	397	}
	398
37d62433 RD	399
	400	void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
	401	m_swx->DoMouseWheel(evt.GetWheelRotation(),
	402	evt.GetWheelDelta(),
65ec6247 RD	403	evt.GetLinesPerAction(),
65ec6247 RD	404	evt.ControlDown());
37d62433 RD	405	}
	406
	407
f97d84a6 RD	408	void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
f97d84a6 RD	409	long key = evt.KeyCode();
f3c2c221 RD	410
	411	// printf("OnChar key:%%d consumed:%%d ctrl:%%d alt:%%d\n",
	412	// key, m_lastKeyDownConsumed, evt.ControlDown(), evt.AltDown());
	413
	414	// AltGr keys???
	415