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 lmCPP;
  extern LexerModule lmHTML;
  extern LexerModule lmXML;
  extern LexerModule lmProps;
  extern LexerModule lmErrorList;
  extern LexerModule lmMake;
  extern LexerModule lmBatch;
  extern LexerModule lmPerl;
  extern LexerModule lmPython;
  extern LexerModule lmSQL;
  extern LexerModule lmVB;

  if (
      &lmCPP
      && &lmHTML
      && &lmXML
      && &lmProps
      && &lmErrorList
      && &lmMake
      && &lmBatch
      && &lmPerl
      && &lmPython
      && &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_UPDATEUI )
DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )


BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
    EVT_PAINT                   (wxStyledTextCtrl::OnPaint)
    EVT_SCROLLWIN               (wxStyledTextCtrl::OnScrollWin)
    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)
    EVT_RIGHT_UP                (wxStyledTextCtrl::OnMouseRightUp)
    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)
{
    m_swx = new ScintillaWX(this);
    m_stopWatch.Start();
}


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::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::OnMouseWheel(wxMouseEvent& evt) {
    m_swx->DoMouseWheel(evt.GetWheelRotation(),
                        evt.GetWheelDelta(),
                        evt.GetLinesPerAction());
}


void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
    long key = evt.KeyCode();
    if ((key > WXK_ESCAPE) &&
        (key != WXK_DELETE) && (key < 255) &&
        !evt.ControlDown() && !evt.AltDown()) {

        m_swx->DoAddChar(key);
    }
    else {
        evt.Skip();
    }
}

void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
    long key = evt.KeyCode();
    key = toupper(key);
    int processed = m_swx->DoKeyDown(key, evt.ShiftDown(),
                                     evt.ControlDown(), evt.AltDown());
    if (! processed)
        evt.Skip();
}

void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
    m_swx->DoLoseFocus();
}

void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
    m_swx->DoGainFocus();
}

void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
    m_swx->DoSysColourChange();
}

void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
    // do nothing to help avoid flashing
}


void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
    m_swx->DoCommand(evt.GetId());
}


void wxStyledTextCtrl::OnListBox(wxCommandEvent& evt) {
    m_swx->DoOnListBox();
}


//----------------------------------------------------------------------
// Turn notifications from Scintilla into events


void wxStyledTextCtrl::NotifyChange() {
    wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
    GetEventHandler()->ProcessEvent(evt);
}

void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
    SCNotification& scn = *_scn;
    int eventType = 0;
    switch (scn.nmhdr.code) {
    case SCN_STYLENEEDED:
        eventType = wxEVT_STC_STYLENEEDED;
        break;
    case SCN_CHARADDED:
        eventType = wxEVT_STC_CHARADDED;
        break;
    case SCN_UPDATEUI:
        eventType = wxEVT_STC_UPDATEUI;
        break;
    case SCN_SAVEPOINTREACHED:
        eventType = wxEVT_STC_SAVEPOINTREACHED;
        break;
    case SCN_SAVEPOINTLEFT:
        eventType = wxEVT_STC_SAVEPOINTLEFT;
        break;
    case SCN_MODIFYATTEMPTRO:
        eventType = wxEVT_STC_ROMODIFYATTEMPT;
        break;
    case SCN_DOUBLECLICK:
        eventType = wxEVT_STC_DOUBLECLICK;
        break;
    case SCN_MODIFIED:
        eventType = wxEVT_STC_MODIFIED;
        break;
    case SCN_KEY:
        eventType = wxEVT_STC_KEY;
        break;
    case SCN_MACRORECORD:
        eventType = wxEVT_STC_MACRORECORD;
        break;
    case SCN_MARGINCLICK:
        eventType = wxEVT_STC_MARGINCLICK;
        break;
    case SCN_NEEDSHOWN:
        eventType = wxEVT_STC_NEEDSHOWN;
        break;
    case SCN_POSCHANGED:
        eventType = wxEVT_STC_POSCHANGED;
        break;
    }
    if (eventType) {
        wxStyledTextEvent evt(eventType, GetId());
        evt.SetPosition(scn.position);
        evt.SetKey(scn.ch);
        evt.SetModifiers(scn.modifiers);
        if (eventType == wxEVT_STC_MODIFIED) {
            evt.SetModificationType(scn.modificationType);
            if (scn.text)
                evt.SetText(wxString(scn.text, scn.length));
            evt.SetLength(scn.length);
            evt.SetLinesAdded(scn.linesAdded);
            evt.SetLine(scn.line);
            evt.SetFoldLevelNow(scn.foldLevelNow);
            evt.SetFoldLevelPrev(scn.foldLevelPrev);
        }
        if (eventType == wxEVT_STC_MARGINCLICK)
            evt.SetMargin(scn.margin);
        if (eventType == wxEVT_STC_MACRORECORD) {
            evt.SetMessage(scn.message);
            evt.SetWParam(scn.wParam);
            evt.SetLParam(scn.lParam);
        }

        GetEventHandler()->ProcessEvent(evt);
    }
}


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

wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
    : wxCommandEvent(commandType, id)
{
    m_position = 0;
    m_key = 0;
    m_modifiers = 0;
    m_modificationType = 0;
    m_length = 0;
    m_linesAdded = 0;
    m_line = 0;
    m_foldLevelNow = 0;
    m_foldLevelPrev = 0;
    m_margin = 0;
    m_message = 0;
    m_wParam = 0;
    m_lParam = 0;


}

bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }

void wxStyledTextEvent::CopyObject(wxObject& obj) const {
    wxCommandEvent::CopyObject(obj);

    wxStyledTextEvent* o = (wxStyledTextEvent*)&obj;
    o->m_position =      m_position;
    o->m_key =           m_key;
    o->m_modifiers =     m_modifiers;
    o->m_modificationType = m_modificationType;
    o->m_text =          m_text;
    o->m_length =        m_length;
    o->m_linesAdded =    m_linesAdded;
    o->m_line =          m_line;
    o->m_foldLevelNow =  m_foldLevelNow;
    o->m_foldLevelPrev = m_foldLevelPrev;

    o->m_margin =        m_margin;

    o->m_message =       m_message;
    o->m_wParam =        m_wParam;
    o->m_lParam =        m_lParam;


}

//----------------------------------------------------------------------
//----------------------------------------------------------------------
Commit	Line	Data
	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	{
	31	extern LexerModule lmCPP;
	32	extern LexerModule lmHTML;
	33	extern LexerModule lmXML;
	34	extern LexerModule lmProps;
	35	extern LexerModule lmErrorList;
	36	extern LexerModule lmMake;
	37	extern LexerModule lmBatch;
	38	extern LexerModule lmPerl;
	39	extern LexerModule lmPython;
	40	extern LexerModule lmSQL;
	41	extern LexerModule lmVB;
	42
	43	if (
	44	&lmCPP
	45	&& &lmHTML
	46	&& &lmXML
	47	&& &lmProps
	48	&& &lmErrorList
	49	&& &lmMake
	50	&& &lmBatch
	51	&& &lmPerl
	52	&& &lmPython
	53	&& &lmSQL
	54	&& &lmVB
	55	)
	56	{
	57	return 1;
	58	}
	59	else
	60	{
	61	return 0;
	62	}
	63	}
	64
	65	//----------------------------------------------------------------------
	66
	67	const wxChar* wxSTCNameStr = "stcwindow";
	68
	69
	70	DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
	71	DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
	72	DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
	73	DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
	74	DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
	75	DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
	76	DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
	77	DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
	78	DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
	79	DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
	80	DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
	81	DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
	82	DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
	83	DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )
	84
	85
	86	BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
	87	EVT_PAINT (wxStyledTextCtrl::OnPaint)
	88	EVT_SCROLLWIN (wxStyledTextCtrl::OnScrollWin)
	89	EVT_SIZE (wxStyledTextCtrl::OnSize)
	90	EVT_LEFT_DOWN (wxStyledTextCtrl::OnMouseLeftDown)
	91	#ifdef __WXMSW__
	92	// Let Scintilla see the double click as a second click
	93	EVT_LEFT_DCLICK (wxStyledTextCtrl::OnMouseLeftDown)
	94	#endif
	95	EVT_MOTION (wxStyledTextCtrl::OnMouseMove)
	96	EVT_LEFT_UP (wxStyledTextCtrl::OnMouseLeftUp)
	97	EVT_RIGHT_UP (wxStyledTextCtrl::OnMouseRightUp)
	98	EVT_MOUSEWHEEL (wxStyledTextCtrl::OnMouseWheel)
	99	EVT_CHAR (wxStyledTextCtrl::OnChar)
	100	EVT_KEY_DOWN (wxStyledTextCtrl::OnKeyDown)
	101	EVT_KILL_FOCUS (wxStyledTextCtrl::OnLoseFocus)
	102	EVT_SET_FOCUS (wxStyledTextCtrl::OnGainFocus)
	103	EVT_SYS_COLOUR_CHANGED (wxStyledTextCtrl::OnSysColourChanged)
	104	EVT_ERASE_BACKGROUND (wxStyledTextCtrl::OnEraseBackground)
	105	EVT_MENU_RANGE (-1, -1, wxStyledTextCtrl::OnMenu)
	106	EVT_LISTBOX_DCLICK (-1, wxStyledTextCtrl::OnListBox)
	107	END_EVENT_TABLE()
	108
	109
	110	IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
	111	IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
	112
	113	//----------------------------------------------------------------------
	114	// Constructor and Destructor
	115
	116	wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
	117	wxWindowID id,
	118	const wxPoint& pos,
	119	const wxSize& size,
	120	long style,
	121	const wxString& name) :
	122	wxControl(parent, id, pos, size,
	123	style \| wxVSCROLL \| wxHSCROLL \| wxWANTS_CHARS \| wxCLIP_CHILDREN,
	124	wxDefaultValidator, name)
	125	{
	126	m_swx = new ScintillaWX(this);
	127	m_stopWatch.Start();
	128	}
	129
	130
	131	wxStyledTextCtrl::~wxStyledTextCtrl() {
	132	delete m_swx;
	133	}
	134
	135
	136	//----------------------------------------------------------------------
	137
	138	long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
	139
	140	return m_swx->WndProc(msg, wp, lp);
	141	}
	142
	143
	144	#ifdef MAKELONG
	145	#undef MAKELONG
	146	#endif
	147
	148	#define MAKELONG(a, b) ((a) \| ((b) << 16))
	149
	150
	151	static long wxColourAsLong(const wxColour& co) {
	152	return (((long)co.Blue() << 16) \|
	153	((long)co.Green() << 8) \|
	154	((long)co.Red()));
	155	}
	156
	157	static wxColour wxColourFromLong(long c) {
	158	wxColour clr;
	159	clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
	160	return clr;
	161	}
	162
	163
	164	static wxColour wxColourFromSpec(const wxString& spec) {
	165	// spec should be #RRGGBB
	166	char* junk;
	167	int red = strtol(spec.Mid(1,2), &junk, 16);
	168	int green = strtol(spec.Mid(3,2), &junk, 16);
	169	int blue = strtol(spec.Mid(5,2), &junk, 16);
	170	return wxColour(red, green, blue);
	171	}
	172
	173
	174	//----------------------------------------------------------------------
	175	// BEGIN generated section. The following code is automatically generated
	176	// by gen_iface.py from the contents of Scintilla.iface. Do not edit
	177	// this file. Edit stc.cpp.in or gen_iface.py instead and regenerate.
	178
	179	%(METHOD_IMPS)s
	180
	181	// END of generated section
	182	//----------------------------------------------------------------------
	183
	184
	185	// Returns the line number of the line with the caret.
	186	int wxStyledTextCtrl::GetCurrentLine() {
	187	int line = LineFromPosition(GetCurrentPos());
	188	return line;
	189	}
	190
	191
	192	// Extract style settings from a spec-string which is composed of one or
	193	// more of the following comma separated elements:
	194	//
	195	// bold turns on bold
	196	// italic turns on italics
	197	// fore:#RRGGBB sets the foreground colour
	198	// back:#RRGGBB sets the background colour
	199	// face:[facename] sets the font face name to use
	200	// size:[num] sets the font size in points
	201	// eol turns on eol filling
	202	// underline turns on underlining
	203	//
	204	void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
	205
	206	wxStringTokenizer tkz(spec, ",");
	207	while (tkz.HasMoreTokens()) {
	208	wxString token = tkz.GetNextToken();
	209
	210	wxString option = token.BeforeFirst(':');
	211	wxString val = token.AfterFirst(':');
	212
	213	if (option == "bold")
	214	StyleSetBold(styleNum, true);
	215
	216	else if (option == "italic")
	217	StyleSetItalic(styleNum, true);
	218
	219	else if (option == "underline")
	220	StyleSetUnderline(styleNum, true);
	221
	222	else if (option == "eol")
	223	StyleSetEOLFilled(styleNum, true);
	224
	225	else if (option == "size") {
	226	long points;
	227	if (val.ToLong(&points))
	228	StyleSetSize(styleNum, points);
	229	}
	230
	231	else if (option == "face")
	232	StyleSetFaceName(styleNum, val);
	233
	234	else if (option == "fore")
	235	StyleSetForeground(styleNum, wxColourFromSpec(val));
	236
	237	else if (option == "back")
	238	StyleSetBackground(styleNum, wxColourFromSpec(val));
	239	}
	240	}
	241
	242
	243	// Set style size, face, bold, italic, and underline attributes from
	244	// a wxFont's attributes.
	245	void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
	246	int size = font.GetPointSize();
	247	wxString faceName = font.GetFaceName();
	248	bool bold = font.GetWeight() == wxBOLD;
	249	bool italic = font.GetStyle() != wxNORMAL;
	250	bool under = font.GetUnderlined();
	251
	252	// TODO: add encoding/charset mapping
	253	StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
	254	}
	255
	256	// Set all font style attributes at once.
	257	void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
	258	const wxString& faceName,
	259	bool bold, bool italic,
	260	bool underline) {
	261	StyleSetSize(styleNum, size);
	262	StyleSetFaceName(styleNum, faceName);
	263	StyleSetBold(styleNum, bold);
	264	StyleSetItalic(styleNum, italic);
	265	StyleSetUnderline(styleNum, underline);
	266
	267	// TODO: add encoding/charset mapping
	268	}
	269
	270
	271	// Perform one of the operations defined by the wxSTC_CMD_* constants.
	272	void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
	273	SendMsg(cmd);
	274	}
	275
	276
	277	// Set the left and right margin in the edit area, measured in pixels.
	278	void wxStyledTextCtrl::SetMargins(int left, int right) {
	279	SetMarginLeft(left);
	280	SetMarginRight(right);
	281	}
	282
	283
	284	// Retrieve the start and end positions of the current selection.
	285	void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
	286	if (startPos != NULL)
	287	*startPos = SendMsg(SCI_GETSELECTIONSTART);
	288	if (endPos != NULL)
	289	*endPos = SendMsg(SCI_GETSELECTIONEND);
	290	}
	291
	292
	293	// Retrieve the point in the window where a position is displayed.
	294	wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
	295	int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
	296	int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
	297	return wxPoint(x, y);
	298	}
	299
	300	// Scroll enough to make the given line visible
	301	void wxStyledTextCtrl::ScrollToLine(int line) {
	302	m_swx->DoScrollToLine(line);
	303	}
	304
	305
	306	// Scroll enough to make the given column visible
	307	void wxStyledTextCtrl::ScrollToColumn(int column) {
	308	m_swx->DoScrollToColumn(column);
	309	}
	310
	311
	312
	313	//----------------------------------------------------------------------
	314	// Event handlers
	315
	316	void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
	317	wxPaintDC dc(this);
	318	wxRegion region = GetUpdateRegion();
	319
	320	m_swx->DoPaint(&dc, region.GetBox());
	321	}
	322
	323	void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
	324	if (evt.GetOrientation() == wxHORIZONTAL)
	325	m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
	326	else
	327	m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
	328	}
	329
	330	void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
	331	wxSize sz = GetClientSize();
	332	m_swx->DoSize(sz.x, sz.y);
	333	}
	334
	335	void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
	336	wxPoint pt = evt.GetPosition();
	337	m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
	338	evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
	339	}
	340
	341	void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
	342	wxPoint pt = evt.GetPosition();
	343	m_swx->DoButtonMove(Point(pt.x, pt.y));
	344	}
	345
	346	void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
	347	wxPoint pt = evt.GetPosition();
	348	m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
	349	evt.ControlDown());
	350	}
	351
	352
	353	void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
	354	wxPoint pt = evt.GetPosition();
	355	m_swx->DoContextMenu(Point(pt.x, pt.y));
	356	}
	357
	358
	359	void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
	360	m_swx->DoMouseWheel(evt.GetWheelRotation(),
	361	evt.GetWheelDelta(),
	362	evt.GetLinesPerAction());
	363	}
	364
	365
	366	void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
	367	long key = evt.KeyCode();
	368	if ((key > WXK_ESCAPE) &&
	369	(key != WXK_DELETE) && (key < 255) &&
	370	!evt.ControlDown() && !evt.AltDown()) {
	371
	372	m_swx->DoAddChar(key);
	373	}
	374	else {
	375	evt.Skip();
	376	}
	377	}
	378
	379	void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
	380	long key = evt.KeyCode();
	381	key = toupper(key);
	382	int processed = m_swx->DoKeyDown(key, evt.ShiftDown(),
	383	evt.ControlDown(), evt.AltDown());
	384	if (! processed)
	385	evt.Skip();
	386	}
	387
	388	void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
	389	m_swx->DoLoseFocus();
	390	}
	391
	392	void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
	393	m_swx->DoGainFocus();
	394	}
	395
	396	void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
	397	m_swx->DoSysColourChange();
	398	}
	399
	400	void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
	401	// do nothing to help avoid flashing
	402	}
	403
	404
	405
	406	void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
	407	m_swx->DoCommand(evt.GetId());
	408	}
	409
	410
	411	void wxStyledTextCtrl::OnListBox(wxCommandEvent& evt) {
	412	m_swx->DoOnListBox();
	413	}
	414
	415
	416	//----------------------------------------------------------------------
	417	// Turn notifications from Scintilla into events
	418
	419
	420	void wxStyledTextCtrl::NotifyChange() {
	421	wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
	422	GetEventHandler()->ProcessEvent(evt);
	423	}
	424
	425	void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
	426	SCNotification& scn = *_scn;
	427	int eventType = 0;
	428	switch (scn.nmhdr.code) {
	429	case SCN_STYLENEEDED:
	430	eventType = wxEVT_STC_STYLENEEDED;
	431	break;
	432	case SCN_CHARADDED:
	433	eventType = wxEVT_STC_CHARADDED;
	434	break;
	435	case SCN_UPDATEUI:
	436	eventType = wxEVT_STC_UPDATEUI;
	437	break;
	438	case SCN_SAVEPOINTREACHED:
	439	eventType = wxEVT_STC_SAVEPOINTREACHED;
	440	break;
	441	case SCN_SAVEPOINTLEFT:
	442	eventType = wxEVT_STC_SAVEPOINTLEFT;
	443	break;
	444	case SCN_MODIFYATTEMPTRO:
	445	eventType = wxEVT_STC_ROMODIFYATTEMPT;
	446	break;
	447	case SCN_DOUBLECLICK:
	448	eventType = wxEVT_STC_DOUBLECLICK;
	449	break;
	450	case SCN_MODIFIED:
	451	eventType = wxEVT_STC_MODIFIED;
	452	break;
	453	case SCN_KEY:
	454	eventType = wxEVT_STC_KEY;
	455	break;
	456	case SCN_MACRORECORD:
	457	eventType = wxEVT_STC_MACRORECORD;
	458	break;
	459	case SCN_MARGINCLICK:
	460	eventType = wxEVT_STC_MARGINCLICK;
	461	break;
	462	case SCN_NEEDSHOWN:
	463	eventType = wxEVT_STC_NEEDSHOWN;
	464	break;
	465	case SCN_POSCHANGED:
	466	eventType = wxEVT_STC_POSCHANGED;
	467	break;
	468	}
	469	if (eventType) {
	470	wxStyledTextEvent evt(eventType, GetId());
	471	evt.SetPosition(scn.position);
	472	evt.SetKey(scn.ch);
	473	evt.SetModifiers(scn.modifiers);
	474	if (eventType == wxEVT_STC_MODIFIED) {
	475	evt.SetModificationType(scn.modificationType);
	476	if (scn.text)
	477	evt.SetText(wxString(scn.text, scn.length));
	478	evt.SetLength(scn.length);
	479	evt.SetLinesAdded(scn.linesAdded);
	480	evt.SetLine(scn.line);
	481	evt.SetFoldLevelNow(scn.foldLevelNow);
	482	evt.SetFoldLevelPrev(scn.foldLevelPrev);
	483	}
	484	if (eventType == wxEVT_STC_MARGINCLICK)
	485	evt.SetMargin(scn.margin);
	486	if (eventType == wxEVT_STC_MACRORECORD) {
	487	evt.SetMessage(scn.message);
	488	evt.SetWParam(scn.wParam);
	489	evt.SetLParam(scn.lParam);
	490	}
	491
	492	GetEventHandler()->ProcessEvent(evt);
	493	}
	494	}
	495
	496
	497
	498	//----------------------------------------------------------------------
	499	//----------------------------------------------------------------------
	500	//----------------------------------------------------------------------
	501
	502	wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
	503	: wxCommandEvent(commandType, id)
	504	{
	505	m_position = 0;
	506	m_key = 0;
	507	m_modifiers = 0;
	508	m_modificationType = 0;
	509	m_length = 0;
	510	m_linesAdded = 0;
	511	m_line = 0;
	512	m_foldLevelNow = 0;
	513	m_foldLevelPrev = 0;
	514	m_margin = 0;
	515	m_message = 0;
	516	m_wParam = 0;
	517	m_lParam = 0;
	518
	519
	520	}
	521
	522	bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
	523	bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
	524	bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
	525
	526	void wxStyledTextEvent::CopyObject(wxObject& obj) const {
	527	wxCommandEvent::CopyObject(obj);
	528
	529	wxStyledTextEvent* o = (wxStyledTextEvent*)&obj;
	530	o->m_position = m_position;
	531	o->m_key = m_key;
	532	o->m_modifiers = m_modifiers;
	533	o->m_modificationType = m_modificationType;
	534	o->m_text = m_text;
	535	o->m_length = m_length;
	536	o->m_linesAdded = m_linesAdded;
	537	o->m_line = m_line;
	538	o->m_foldLevelNow = m_foldLevelNow;
	539	o->m_foldLevelPrev = m_foldLevelPrev;
	540
	541	o->m_margin = m_margin;
	542
	543	o->m_message = m_message;
	544	o->m_wParam = m_wParam;
	545	o->m_lParam = m_lParam;
	546
	547
	548
	549	}
	550
	551	//----------------------------------------------------------------------
	552	//----------------------------------------------------------------------
	553