src/stc/stc.cpp

   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 itentifiers 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 "wx/stc/stc.h"
  19 #include "ScintillaWX.h"
  20
  21 #include <wx/tokenzr.h>
  22
  23 //----------------------------------------------------------------------
  24
  25 const wxChar* wxSTCNameStr = "stcwindow";
  26
  27 BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
  28     EVT_PAINT                   (wxStyledTextCtrl::OnPaint)
  29     EVT_SCROLLWIN               (wxStyledTextCtrl::OnScrollWin)
  30     EVT_SIZE                    (wxStyledTextCtrl::OnSize)
  31     EVT_LEFT_DOWN               (wxStyledTextCtrl::OnMouseLeftDown)
  32     EVT_MOTION                  (wxStyledTextCtrl::OnMouseMove)
  33     EVT_LEFT_UP                 (wxStyledTextCtrl::OnMouseLeftUp)
  34     EVT_RIGHT_UP                (wxStyledTextCtrl::OnMouseRightUp)
  35     EVT_CHAR                    (wxStyledTextCtrl::OnChar)
  36     EVT_KILL_FOCUS              (wxStyledTextCtrl::OnLoseFocus)
  37     EVT_SET_FOCUS               (wxStyledTextCtrl::OnGainFocus)
  38     EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
  39     EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
  40     EVT_MENU_RANGE              (-1, -1, wxStyledTextCtrl::OnMenu)
  41 END_EVENT_TABLE()
  42
  43 //----------------------------------------------------------------------
  44 // Constructor and Destructor
  45
  46 wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
  47                                    wxWindowID id,
  48                                    const wxPoint& pos,
  49                                    const wxSize& size,
  50                                    long style,
  51                                    const wxString& name) :
  52     wxControl(parent, id, pos, size,
  53               style | wxVSCROLL | wxHSCROLL | wxWANTS_CHARS,
  54               wxDefaultValidator, name)
  55 {
  56     m_swx = new ScintillaWX(this);
  57     // m_keywords = new WordList;
  58     m_stopWatch.Start();
  59     m_readOnly = false;
  60     m_undoType = wxSTC_UndoCollectAutoStart;
  61 }
  62
  63
  64 wxStyledTextCtrl::~wxStyledTextCtrl() {
  65     delete m_swx;
  66     // delete m_keywords;
  67 }
  68
  69
  70 //----------------------------------------------------------------------
  71
  72 inline long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
  73
  74     return m_swx->WndProc(msg, wp, lp);
  75 }
  76
  77
  78 //----------------------------------------------------------------------
  79 // Text retrieval and modification
  80
  81 wxString wxStyledTextCtrl::GetText() {
  82     wxString text;
  83     int   len  = GetTextLength();
  84     char* buff = text.GetWriteBuf(len);
  85
  86     SendMsg(WM_GETTEXT, len, (long)buff);
  87     text.UngetWriteBuf();
  88     return text;
  89 }
  90
  91
  92 bool wxStyledTextCtrl::SetText(const wxString& text) {
  93     return SendMsg(WM_SETTEXT, 0, (long)text.c_str()) != 0;
  94 }
  95
  96
  97 wxString wxStyledTextCtrl::GetLine(int line) {
  98     wxString text;
  99     int   len  = GetLineLength(line);
 100     char* buff = text.GetWriteBuf(len+1);
 101
 102     *((WORD*)buff) = len+1;
 103     SendMsg(EM_GETLINE, line, (long)buff);
 104     text.UngetWriteBuf();
 105     return text;
 106 }
 107
 108
 109 void wxStyledTextCtrl::ReplaceSelection(const wxString& text) {
 110     SendMsg(EM_REPLACESEL, 0, (long)text.c_str());
 111 }
 112
 113
 114 void wxStyledTextCtrl::SetReadOnly(bool readOnly) {
 115     SendMsg(EM_SETREADONLY, (long)readOnly);
 116     m_readOnly = readOnly;
 117 }
 118
 119
 120 bool wxStyledTextCtrl::GetReadOnly() {
 121     // TODO: need support in Scintilla to do this right,
 122     //       until then we'll track it ourselves
 123     return m_readOnly;
 124 }
 125
 126
 127 void wxStyledTextCtrl::GetTextRange(int startPos, int endPos, char* buff) {
 128     TEXTRANGE tr;
 129     tr.lpstrText = buff;
 130     tr.chrg.cpMin = startPos;
 131     tr.chrg.cpMax = endPos;
 132     SendMsg(EM_GETTEXTRANGE, 0, (long)&tr);
 133 }
 134
 135
 136 wxString wxStyledTextCtrl::GetTextRange(int startPos, int endPos) {
 137     wxString  text;
 138     int       len  = endPos - startPos;
 139     char*     buff = text.GetWriteBuf(len);
 140     GetTextRange(startPos, endPos, buff);
 141     text.UngetWriteBuf();
 142     return text;
 143 }
 144
 145
 146 void wxStyledTextCtrl::GetStyledTextRange(int startPos, int endPos, char* buff) {
 147     TEXTRANGE tr;
 148     tr.lpstrText = buff;
 149     tr.chrg.cpMin = startPos;
 150     tr.chrg.cpMax = endPos;
 151     SendMsg(SCI_GETSTYLEDTEXT, 0, (long)&tr);
 152 }
 153
 154
 155 wxString wxStyledTextCtrl::GetStyledTextRange(int startPos, int endPos) {
 156     wxString  text;
 157     int       len  = endPos - startPos;
 158     char*     buff = text.GetWriteBuf(len*2);
 159     GetStyledTextRange(startPos, endPos, buff);
 160     text.UngetWriteBuf(len*2);
 161     return text;
 162 }
 163
 164
 165 void wxStyledTextCtrl::AddText(const wxString& text) {
 166     SendMsg(SCI_ADDTEXT, text.Len(), (long)text.c_str());
 167 }
 168
 169
 170 void wxStyledTextCtrl::AddStyledText(const wxString& text) {
 171     SendMsg(SCI_ADDSTYLEDTEXT, text.Len(), (long)text.c_str());
 172 }
 173
 174
 175 void wxStyledTextCtrl::InsertText(int pos, const wxString& text) {
 176     SendMsg(SCI_INSERTTEXT, pos, (long)text.c_str());
 177 }
 178
 179
 180 void wxStyledTextCtrl::ClearAll() {
 181     SendMsg(SCI_CLEARALL);
 182 }
 183
 184
 185 char wxStyledTextCtrl::GetCharAt(int pos) {
 186     return SendMsg(SCI_GETCHARAT, pos);
 187 }
 188
 189
 190 char wxStyledTextCtrl::GetStyleAt(int pos) {
 191     return SendMsg(SCI_GETSTYLEAT, pos);
 192 }
 193
 194
 195 void wxStyledTextCtrl::SetStyleBits(int bits) {
 196     SendMsg(SCI_SETSTYLEBITS, bits);
 197 }
 198
 199
 200 int  wxStyledTextCtrl::GetStyleBits() {
 201     return SendMsg(SCI_GETSTYLEBITS);
 202 }
 203
 204
 205 //----------------------------------------------------------------------
 206 // Clipboard
 207
 208
 209 void wxStyledTextCtrl::Cut() {
 210     SendMsg(WM_CUT);
 211 }
 212
 213
 214 void wxStyledTextCtrl::Copy() {
 215     SendMsg(WM_COPY);
 216 }
 217
 218
 219 void wxStyledTextCtrl::Paste() {
 220     SendMsg(WM_PASTE);
 221 }
 222
 223
 224 bool wxStyledTextCtrl::CanPaste() {
 225     return SendMsg(EM_CANPASTE) != 0;
 226 }
 227
 228
 229 void wxStyledTextCtrl::ClearClipbrd() {
 230     SendMsg(WM_CLEAR);
 231 }
 232
 233
 234
 235 //----------------------------------------------------------------------
 236 // Undo and Redo
 237
 238 void wxStyledTextCtrl::Undo() {
 239     SendMsg(WM_UNDO);
 240 }
 241
 242
 243 bool wxStyledTextCtrl::CanUndo() {
 244     return SendMsg(EM_CANUNDO) != 0;
 245 }
 246
 247
 248 void wxStyledTextCtrl::EmptyUndoBuffer() {
 249     SendMsg(EM_EMPTYUNDOBUFFER);
 250 }
 251
 252
 253 void wxStyledTextCtrl::Redo() {
 254     SendMsg(SCI_REDO);
 255 }
 256
 257
 258 bool wxStyledTextCtrl::CanRedo() {
 259     return SendMsg(SCI_CANREDO) != 0;
 260 }
 261
 262
 263 void wxStyledTextCtrl::SetUndoCollection(wxSTC_UndoType type) {
 264     SendMsg(SCI_SETUNDOCOLLECTION, type);
 265     m_undoType = type;
 266 }
 267
 268
 269 wxSTC_UndoType wxStyledTextCtrl::GetUndoCollection() {
 270     // TODO: need support in Scintilla to do this right,
 271     //       until then we'll track it ourselves
 272     return m_undoType;
 273 }
 274
 275
 276 void wxStyledTextCtrl::BeginUndoAction() {
 277     SendMsg(SCI_BEGINUNDOACTION);
 278 }
 279
 280
 281 void wxStyledTextCtrl::EndUndoAction() {
 282     SendMsg(SCI_ENDUNDOACTION);
 283 }
 284
 285
 286
 287
 288 //----------------------------------------------------------------------
 289 // Selection and information
 290
 291
 292 void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
 293     SendMsg(EM_GETSEL, (long)startPos, (long)endPos);
 294 }
 295
 296
 297 void wxStyledTextCtrl::SetSelection(int  startPos, int  endPos) {
 298     SendMsg(EM_SETSEL, startPos, endPos);
 299 }
 300
 301
 302 wxString wxStyledTextCtrl::GetSelectedText() {
 303     wxString text;
 304     int   start;
 305     int   end;
 306
 307     GetSelection(&start, &end);
 308     int   len  = end - start;
 309     char* buff = text.GetWriteBuf(len);
 310
 311     SendMsg(EM_GETSELTEXT, 0, (long)buff);
 312     text.UngetWriteBuf();
 313     return text;
 314 }
 315
 316
 317 void wxStyledTextCtrl::HideSelection(bool hide) {
 318     SendMsg(EM_HIDESELECTION, hide);
 319 }
 320
 321
 322 bool wxStyledTextCtrl::GetHideSelection() {
 323     return m_swx->GetHideSelection();
 324 }
 325
 326
 327 int wxStyledTextCtrl::GetTextLength() {
 328     return SendMsg(WM_GETTEXTLENGTH);
 329 }
 330
 331
 332 int wxStyledTextCtrl::GetFirstVisibleLine() {
 333     return SendMsg(EM_GETFIRSTVISIBLELINE);
 334 }
 335
 336
 337 int wxStyledTextCtrl::GetLineCount() {
 338     return SendMsg(EM_GETLINECOUNT);
 339 }
 340
 341
 342 bool wxStyledTextCtrl::GetModified() {
 343     return SendMsg(EM_GETMODIFY) != 0;
 344 }
 345
 346
 347 wxRect wxStyledTextCtrl::GetRect() {
 348     PRectangle pr;
 349     SendMsg(EM_GETRECT, 0, (long)&pr);
 350
 351     wxRect rect = wxRectFromPRectangle(pr);
 352     return rect;
 353 }
 354
 355
 356 int wxStyledTextCtrl::GetLineFromPos(int pos) {
 357     return SendMsg(EM_LINEFROMCHAR, pos);
 358 }
 359
 360
 361 int wxStyledTextCtrl::GetLineStartPos(int line) {
 362     return SendMsg(EM_LINEINDEX, line);
 363 }
 364
 365
 366 int wxStyledTextCtrl::GetLineLengthAtPos(int pos) {
 367     return SendMsg(EM_LINELENGTH, pos);
 368 }
 369
 370
 371 int wxStyledTextCtrl::GetLineLength(int line) {
 372     return SendMsg(SCI_LINELENGTH, line);
 373 }
 374
 375
 376 int wxStyledTextCtrl::GetCurrentLine() {
 377     int line = GetLineFromPos(GetCurrentPos());
 378     return line;
 379 }
 380
 381
 382 wxString wxStyledTextCtrl::GetCurrentLineText(int* linePos) {
 383     wxString text;
 384     int   len  = GetLineLength(GetCurrentLine());
 385     char* buff = text.GetWriteBuf(len+1);
 386
 387     int pos = SendMsg(SCI_GETCURLINE, len+1, (long)buff);
 388     text.UngetWriteBuf();
 389
 390     if (linePos)
 391         *linePos = pos;
 392
 393     return text;
 394 }
 395
 396
 397 int wxStyledTextCtrl::PositionFromPoint(wxPoint pt) {
 398     Point spt(pt.x, pt.y);
 399     long rv = SendMsg(EM_CHARFROMPOS, 0, (long)&spt);
 400     return LOWORD(rv);
 401 }
 402
 403
 404 int wxStyledTextCtrl::LineFromPoint(wxPoint pt) {
 405     Point spt(pt.x, pt.y);
 406     long rv = SendMsg(EM_CHARFROMPOS, 0, (long)&spt);
 407     return HIWORD(rv);
 408 }
 409
 410
 411 wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
 412     Point pt;
 413     SendMsg(EM_POSFROMCHAR, pos, (long)&pt);
 414     return wxPoint(pt.x, pt.y);
 415 }
 416
 417
 418 int wxStyledTextCtrl::GetCurrentPos() {
 419     return SendMsg(SCI_GETCURRENTPOS);
 420 }
 421
 422
 423 int wxStyledTextCtrl::GetAnchor() {
 424     return SendMsg(SCI_GETANCHOR);
 425 }
 426
 427
 428 void wxStyledTextCtrl::SelectAll() {
 429     SendMsg(SCI_SELECTALL);
 430 }
 431
 432
 433 void wxStyledTextCtrl::SetCurrentPosition(int pos) {
 434     SendMsg(SCI_GOTOPOS, pos);
 435 }
 436
 437
 438 void wxStyledTextCtrl::SetAnchor(int pos) {
 439     SendMsg(SCI_SETANCHOR, pos);
 440 }
 441
 442
 443 void wxStyledTextCtrl::GotoPos(int pos) {
 444     SendMsg(SCI_GOTOPOS, pos);
 445 }
 446
 447
 448 void wxStyledTextCtrl::GotoLine(int line) {
 449     SendMsg(SCI_GOTOLINE, line);
 450 }
 451
 452
 453 void wxStyledTextCtrl::ChangePosition(int delta, bool extendSelection) {
 454     // TODO:  Is documented but doesn't seem to be implemented
 455     //SendMsg(SCI_CHANGEPOSITION, delta, extendSelection);
 456 }
 457
 458
 459 void wxStyledTextCtrl::PageMove(int cmdKey, bool extendSelection) {
 460     // TODO:  Is documented but doesn't seem to be implemented
 461     //SendMsg(SCI_PAGEMOVE, cmdKey, extendSelection);
 462 }
 463
 464
 465 void wxStyledTextCtrl::ScrollBy(int columnDelta, int lineDelta) {
 466     SendMsg(EM_LINESCROLL, columnDelta, lineDelta);
 467 }
 468
 469 void wxStyledTextCtrl::ScrollToLine(int line) {
 470     m_swx->DoScrollToLine(line);
 471 }
 472
 473
 474 void wxStyledTextCtrl::ScrollToColumn(int column) {
 475     m_swx->DoScrollToColumn(column);
 476 }
 477
 478
 479 void wxStyledTextCtrl::EnsureCaretVisible() {
 480     SendMsg(EM_SCROLLCARET);
 481 }
 482
 483
 484 void wxStyledTextCtrl::SetCaretPolicy(int policy, int slop) {
 485     SendMsg(SCI_SETCARETPOLICY, policy, slop);
 486 }
 487
 488
 489 int wxStyledTextCtrl::GetSelectionType() {
 490     return SendMsg(EM_SELECTIONTYPE);
 491 }
 492
 493
 494
 495
 496 //----------------------------------------------------------------------
 497 // Searching
 498
 499 int wxStyledTextCtrl::FindText(int minPos, int maxPos,
 500                                      const wxString& text,
 501                                      bool caseSensitive, bool wholeWord) {
 502     FINDTEXTEX  ft;
 503     int         flags = 0;
 504
 505     flags |= caseSensitive ? FR_MATCHCASE : 0;
 506     flags |= wholeWord     ? FR_WHOLEWORD : 0;
 507     ft.chrg.cpMin = minPos;
 508     ft.chrg.cpMax = maxPos;
 509     ft.lpstrText = (char*)text.c_str();
 510
 511     return SendMsg(EM_FINDTEXT, flags, (long)&ft);
 512 }
 513
 514
 515 void wxStyledTextCtrl::SearchAnchor() {
 516     SendMsg(SCI_SEARCHANCHOR);
 517 }
 518
 519
 520 int wxStyledTextCtrl::SearchNext(const wxString& text, bool caseSensitive, bool wholeWord) {
 521     int flags = 0;
 522     flags |= caseSensitive ? FR_MATCHCASE : 0;
 523     flags |= wholeWord     ? FR_WHOLEWORD : 0;
 524
 525     return SendMsg(SCI_SEARCHNEXT, flags, (long)text.c_str());
 526 }
 527
 528
 529 int wxStyledTextCtrl::SearchPrev(const wxString& text, bool caseSensitive, bool wholeWord) {
 530     int flags = 0;
 531     flags |= caseSensitive ? FR_MATCHCASE : 0;
 532     flags |= wholeWord     ? FR_WHOLEWORD : 0;
 533
 534     return SendMsg(SCI_SEARCHPREV, flags, (long)text.c_str());
 535 }
 536
 537 //----------------------------------------------------------------------
 538 // Visible whitespace
 539
 540
 541 bool wxStyledTextCtrl::GetViewWhitespace() {
 542     return SendMsg(SCI_GETVIEWWS) != 0;
 543 }
 544
 545
 546 void wxStyledTextCtrl::SetViewWhitespace(bool visible) {
 547     SendMsg(SCI_SETVIEWWS, visible);
 548 }
 549
 550
 551
 552 //----------------------------------------------------------------------
 553 // Line endings
 554
 555 wxSTC_EOL wxStyledTextCtrl::GetEOLMode() {
 556     return (wxSTC_EOL)SendMsg(SCI_GETEOLMODE);
 557 }
 558
 559
 560 void wxStyledTextCtrl::SetEOLMode(wxSTC_EOL mode) {
 561     SendMsg(SCI_SETEOLMODE, mode);
 562 }
 563
 564
 565 bool wxStyledTextCtrl::GetViewEOL() {
 566     return SendMsg(SCI_GETVIEWEOL) != 0;
 567 }
 568
 569
 570 void wxStyledTextCtrl::SetViewEOL(bool visible) {
 571     SendMsg(SCI_SETVIEWEOL, visible);
 572 }
 573
 574 void wxStyledTextCtrl::ConvertEOL(wxSTC_EOL mode) {
 575     SendMsg(SCI_CONVERTEOLS, mode);
 576 }
 577
 578 //----------------------------------------------------------------------
 579 // Styling
 580
 581 int wxStyledTextCtrl::GetEndStyled() {
 582     return SendMsg(SCI_GETENDSTYLED);
 583 }
 584
 585
 586 void wxStyledTextCtrl::StartStyling(int pos, int mask) {
 587     SendMsg(SCI_STARTSTYLING, pos, mask);
 588 }
 589
 590
 591 void wxStyledTextCtrl::SetStyleFor(int length, int style) {
 592     SendMsg(SCI_SETSTYLING, length, style);
 593 }
 594
 595
 596 void wxStyledTextCtrl::SetStyleBytes(int length, char* styleBytes) {
 597     SendMsg(SCI_SETSTYLINGEX, length, (long)styleBytes);
 598 }
 599
 600
 601 //----------------------------------------------------------------------
 602 // Style Definition
 603
 604
 605 static long wxColourAsLong(const wxColour& co) {
 606     return (((long)co.Blue()  << 16) |
 607             ((long)co.Green() <<  8) |
 608             ((long)co.Red()));
 609 }
 610
 611 static wxColour wxColourFromLong(long c) {
 612     wxColour clr;
 613     clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
 614     return clr;
 615 }
 616
 617
 618 static wxColour wxColourFromSpec(const wxString& spec) {
 619     // spec should be #RRGGBB
 620     char* junk;
 621     int red   = strtol(spec.Mid(1,2), &junk, 16);
 622     int green = strtol(spec.Mid(3,2), &junk, 16);
 623     int blue  = strtol(spec.Mid(5,2), &junk, 16);
 624     return wxColour(red, green, blue);
 625 }
 626
 627
 628 void wxStyledTextCtrl::StyleClearAll() {
 629     SendMsg(SCI_STYLECLEARALL);
 630 }
 631
 632
 633 void wxStyledTextCtrl::StyleResetDefault() {
 634     SendMsg(SCI_STYLERESETDEFAULT);
 635 }
 636
 637
 638
 639 // Extract style settings from a spec-string which is composed of one or
 640 // more of the following comma separated elements:
 641 //
 642 //      bold                    turns on bold
 643 //      italic                  turns on italics
 644 //      fore:#RRGGBB            sets the foreground colour
 645 //      back:#RRGGBB            sets the background colour
 646 //      face:[facename]         sets the font face name to use
 647 //      size:[num]              sets the font size in points
 648 //      eol                     turns on eol filling
 649 //
 650
 651 void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
 652
 653     wxStringTokenizer tkz(spec, ",");
 654     while (tkz.HasMoreTokens()) {
 655         wxString token = tkz.GetNextToken();
 656
 657         wxString option = token.BeforeFirst(':');
 658         wxString val = token.AfterFirst(':');
 659
 660         if (option == "bold")
 661             StyleSetBold(styleNum, true);
 662
 663         else if (option == "italic")
 664             StyleSetItalic(styleNum, true);
 665
 666         else if (option == "eol")
 667             StyleSetEOLFilled(styleNum, true);
 668
 669         else if (option == "size") {
 670             long points;
 671             if (val.ToLong(&points))
 672                 StyleSetSize(styleNum, points);
 673         }
 674
 675         else if (option == "face")
 676             StyleSetFaceName(styleNum, val);
 677
 678         else if (option == "fore")
 679             StyleSetForeground(styleNum, wxColourFromSpec(val));
 680
 681         else if (option == "back")
 682             StyleSetBackground(styleNum, wxColourFromSpec(val));
 683     }
 684 }
 685
 686
 687 void wxStyledTextCtrl::StyleSetForeground(int styleNum, const wxColour& colour) {
 688     SendMsg(SCI_STYLESETFORE, styleNum, wxColourAsLong(colour));
 689 }
 690
 691
 692 void wxStyledTextCtrl::StyleSetBackground(int styleNum, const wxColour& colour) {
 693     SendMsg(SCI_STYLESETBACK, styleNum, wxColourAsLong(colour));
 694 }
 695
 696
 697 void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
 698     int      size     = font.GetPointSize();
 699     wxString faceName = font.GetFaceName();
 700     bool     bold     = font.GetWeight() == wxBOLD;
 701     bool     italic   = font.GetStyle() != wxNORMAL;
 702
 703     StyleSetFontAttr(styleNum, size, faceName, bold, italic);
 704 }
 705
 706
 707 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
 708                                         const wxString& faceName,
 709                                         bool bold, bool italic) {
 710     StyleSetSize(styleNum, size);
 711     StyleSetFaceName(styleNum, faceName);
 712     StyleSetBold(styleNum, bold);
 713     StyleSetItalic(styleNum, italic);
 714 }
 715
 716
 717 void wxStyledTextCtrl::StyleSetBold(int styleNum, bool bold) {
 718     SendMsg(SCI_STYLESETBOLD, styleNum, bold);
 719 }
 720
 721
 722 void wxStyledTextCtrl::StyleSetItalic(int styleNum, bool italic) {
 723     SendMsg(SCI_STYLESETITALIC, styleNum, italic);
 724 }
 725
 726
 727 void wxStyledTextCtrl::StyleSetFaceName(int styleNum, const wxString& faceName) {
 728     SendMsg(SCI_STYLESETFONT, styleNum, (long)faceName.c_str());
 729 }
 730
 731
 732 void wxStyledTextCtrl::StyleSetSize(int styleNum, int pointSize) {
 733     SendMsg(SCI_STYLESETSIZE, styleNum, pointSize);
 734 }
 735
 736
 737 void wxStyledTextCtrl::StyleSetEOLFilled(int styleNum, bool fillEOL) {
 738     SendMsg(SCI_STYLESETEOLFILLED, styleNum, fillEOL);
 739 }
 740
 741
 742 //----------------------------------------------------------------------
 743 // Margins in the edit area
 744
 745 int wxStyledTextCtrl::GetLeftMargin() {
 746     return LOWORD(SendMsg(EM_GETMARGINS));
 747 }
 748
 749
 750 int wxStyledTextCtrl::GetRightMargin() {
 751     return HIWORD(SendMsg(EM_GETMARGINS));
 752 }
 753
 754
 755 void wxStyledTextCtrl::SetMargins(int left, int right) {
 756     int flag = 0;
 757     int val = 0;
 758
 759     if (right != -1) {
 760         flag |= EC_RIGHTMARGIN;
 761         val = right << 16;
 762     }
 763     if (left != -1) {
 764         flag |= EC_LEFTMARGIN;
 765         val |= (left & 0xffff);
 766     }
 767
 768     SendMsg(EM_SETMARGINS, flag, val);
 769 }
 770
 771
 772 //----------------------------------------------------------------------
 773 // Margins for selection, markers, etc.
 774
 775 void wxStyledTextCtrl::SetMarginType(int margin, int type) {
 776     SendMsg(SCI_SETMARGINTYPEN, margin, type);
 777 }
 778
 779
 780 int  wxStyledTextCtrl::GetMarginType(int margin) {
 781     return SendMsg(SCI_GETMARGINTYPEN, margin);
 782 }
 783
 784
 785 void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) {
 786     SendMsg(SCI_SETMARGINWIDTHN, margin, pixelWidth);
 787 }
 788
 789
 790 int  wxStyledTextCtrl::GetMarginWidth(int margin) {
 791     return SendMsg(SCI_GETMARGINWIDTHN, margin);
 792 }
 793
 794
 795 void wxStyledTextCtrl::SetMarginMask(int margin, int mask) {
 796     SendMsg(SCI_SETMARGINMASKN, margin, mask);
 797 }
 798
 799
 800 int  wxStyledTextCtrl::GetMarginMask(int margin) {
 801     return SendMsg(SCI_GETMARGINMASKN, margin);
 802 }
 803
 804
 805 void wxStyledTextCtrl::SetMarginSensitive(int margin, bool sensitive) {
 806     SendMsg(SCI_SETMARGINSENSITIVEN, margin, sensitive);
 807 }
 808
 809
 810 bool wxStyledTextCtrl::GetMarginSensitive(int margin) {
 811     return SendMsg(SCI_GETMARGINSENSITIVEN, margin) != 0;
 812 }
 813
 814
 815
 816
 817 //----------------------------------------------------------------------
 818 // Selection and Caret styles
 819
 820
 821 void wxStyledTextCtrl::SetSelectionForeground(const wxColour& colour) {
 822     SendMsg(SCI_SETSELFORE, 0, wxColourAsLong(colour));
 823 }
 824
 825
 826 void wxStyledTextCtrl::SetSelectionBackground(const wxColour& colour) {
 827     SendMsg(SCI_SETSELBACK, 0, wxColourAsLong(colour));
 828 }
 829
 830
 831 void wxStyledTextCtrl::SetCaretForeground(const wxColour& colour) {
 832     SendMsg(SCI_SETCARETFORE, 0, wxColourAsLong(colour));
 833 }
 834
 835
 836 int wxStyledTextCtrl::GetCaretPeriod() {
 837     return SendMsg(SCI_GETCARETPERIOD);
 838 }
 839
 840
 841 void wxStyledTextCtrl::SetCaretPeriod(int milliseconds) {
 842     SendMsg(SCI_SETCARETPERIOD, milliseconds);
 843 }
 844
 845
 846
 847 //----------------------------------------------------------------------
 848 // Other settings
 849
 850
 851 void wxStyledTextCtrl::SetBufferedDraw(bool isBuffered) {
 852     SendMsg(SCI_SETBUFFEREDDRAW, isBuffered);
 853 }
 854
 855
 856 void wxStyledTextCtrl::SetTabWidth(int numChars) {
 857     SendMsg(SCI_SETTABWIDTH, numChars);
 858 }
 859
 860
 861 void wxStyledTextCtrl::SetWordChars(const wxString& wordChars) {
 862     SendMsg(SCI_SETTABWIDTH, 0, (long)wordChars.c_str());
 863 }
 864
 865
 866 //----------------------------------------------------------------------
 867 // Brace highlighting
 868
 869
 870 void wxStyledTextCtrl::BraceHighlight(int pos1, int pos2) {
 871     SendMsg(SCI_BRACEHIGHLIGHT, pos1, pos2);
 872 }
 873
 874
 875 void wxStyledTextCtrl::BraceBadlight(int pos) {
 876     SendMsg(SCI_BRACEBADLIGHT, pos);
 877 }
 878
 879
 880 int wxStyledTextCtrl::BraceMatch(int pos, int maxReStyle) {
 881     return SendMsg(SCI_BRACEMATCH, pos, maxReStyle);
 882 }
 883
 884
 885
 886 //----------------------------------------------------------------------
 887 // Markers
 888
 889 void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol,
 890                                           const wxColour& foreground,
 891                                           const wxColour& background) {
 892     MarkerSetType(markerNumber, markerSymbol);
 893     MarkerSetForeground(markerNumber, foreground);
 894     MarkerSetBackground(markerNumber, background);
 895 }
 896
 897
 898 void wxStyledTextCtrl::MarkerSetType(int markerNumber, int markerSymbol) {
 899     SendMsg(SCI_MARKERDEFINE, markerNumber, markerSymbol);
 900 }
 901
 902
 903 void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour& colour) {
 904     SendMsg(SCI_MARKERSETFORE, markerNumber, wxColourAsLong(colour));
 905 }
 906
 907
 908 void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour& colour) {
 909     SendMsg(SCI_MARKERSETBACK, markerNumber, wxColourAsLong(colour));
 910 }
 911
 912
 913 int wxStyledTextCtrl::MarkerAdd(int line, int markerNumber) {
 914     return SendMsg(SCI_MARKERADD, line, markerNumber);
 915 }
 916
 917
 918 void wxStyledTextCtrl::MarkerDelete(int line, int markerNumber) {
 919     SendMsg(SCI_MARKERDELETE, line, markerNumber);
 920 }
 921
 922
 923 void wxStyledTextCtrl::MarkerDeleteAll(int markerNumber) {
 924     SendMsg(SCI_MARKERDELETEALL, markerNumber);
 925 }
 926
 927
 928 int wxStyledTextCtrl::MarkerGet(int line) {
 929     return SendMsg(SCI_MARKERGET);
 930 }
 931
 932
 933 int wxStyledTextCtrl::MarkerGetNextLine(int lineStart, int markerMask) {
 934     return SendMsg(SCI_MARKERNEXT, lineStart, markerMask);
 935 }
 936
 937
 938 int wxStyledTextCtrl::MarkerGetPrevLine(int lineStart, int markerMask) {
 939 //    return SendMsg(SCI_MARKERPREV, lineStart, markerMask);
 940     return 0;
 941 }
 942
 943
 944 int wxStyledTextCtrl::MarkerLineFromHandle(int handle) {
 945     return SendMsg(SCI_MARKERLINEFROMHANDLE, handle);
 946 }
 947
 948
 949 void wxStyledTextCtrl::MarkerDeleteHandle(int handle) {
 950     SendMsg(SCI_MARKERDELETEHANDLE, handle);
 951 }
 952
 953
 954
 955 //----------------------------------------------------------------------
 956 // Indicators
 957
 958
 959 void wxStyledTextCtrl::IndicatorSetStyle(int indicNum, int indicStyle) {
 960     SendMsg(SCI_INDICSETSTYLE, indicNum, indicStyle);
 961 }
 962
 963
 964 int wxStyledTextCtrl::IndicatorGetStyle(int indicNum) {
 965     return SendMsg(SCI_INDICGETSTYLE, indicNum);
 966 }
 967
 968
 969 void wxStyledTextCtrl::IndicatorSetColour(int indicNum, const wxColour& colour) {
 970     SendMsg(SCI_INDICSETSTYLE, indicNum, wxColourAsLong(colour));
 971 }
 972
 973
 974
 975 //----------------------------------------------------------------------
 976 // Auto completion
 977
 978
 979 void wxStyledTextCtrl::AutoCompShow(const wxString& listOfWords) {
 980     SendMsg(SCI_AUTOCSHOW, 0, (long)listOfWords.c_str());
 981 }
 982
 983
 984 void wxStyledTextCtrl::AutoCompCancel() {
 985     SendMsg(SCI_AUTOCCANCEL);
 986 }
 987
 988
 989 bool wxStyledTextCtrl::AutoCompActive() {
 990     return SendMsg(SCI_AUTOCACTIVE) != 0;
 991 }
 992
 993
 994 int wxStyledTextCtrl::AutoCompPosAtStart() {
 995     return SendMsg(SCI_AUTOCPOSSTART);
 996 }
 997
 998
 999 void wxStyledTextCtrl::AutoCompComplete() {
1000     SendMsg(SCI_AUTOCCOMPLETE);
1001 }
1002
1003
1004 void wxStyledTextCtrl::AutoCompStopChars(const wxString& stopChars) {
1005     SendMsg(SCI_AUTOCSHOW, 0, (long)stopChars.c_str());
1006 }
1007
1008
1009 //----------------------------------------------------------------------
1010 // Call tips
1011
1012 void wxStyledTextCtrl::CallTipShow(int pos, const wxString& text) {
1013     SendMsg(SCI_CALLTIPSHOW, pos, (long)text.c_str());
1014 }
1015
1016
1017 void wxStyledTextCtrl::CallTipCancel() {
1018     SendMsg(SCI_CALLTIPCANCEL);
1019 }
1020
1021
1022 bool wxStyledTextCtrl::CallTipActive() {
1023     return SendMsg(SCI_CALLTIPACTIVE) != 0;
1024 }
1025
1026
1027 int wxStyledTextCtrl::CallTipPosAtStart() {
1028     return SendMsg(SCI_CALLTIPPOSSTART);
1029 }
1030
1031
1032 void wxStyledTextCtrl::CallTipSetHighlight(int start, int end) {
1033     SendMsg(SCI_CALLTIPSETHLT, start, end);
1034 }
1035
1036
1037 void wxStyledTextCtrl::CallTipSetBackground(const wxColour& colour) {
1038     SendMsg(SCI_CALLTIPSETBACK, wxColourAsLong(colour));
1039 }
1040
1041
1042 //----------------------------------------------------------------------
1043 // Key bindings
1044
1045 void wxStyledTextCtrl::CmdKeyAssign(int key, int modifiers, int cmd) {
1046     SendMsg(SCI_ASSIGNCMDKEY, MAKELONG(key, modifiers), cmd);
1047 }
1048
1049
1050 void wxStyledTextCtrl::CmdKeyClear(int key, int modifiers) {
1051     SendMsg(SCI_CLEARCMDKEY, MAKELONG(key, modifiers));
1052 }
1053
1054
1055 void wxStyledTextCtrl::CmdKeyClearAll() {
1056     SendMsg(SCI_CLEARALLCMDKEYS);
1057 }
1058
1059
1060 void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
1061     SendMsg(cmd);
1062 }
1063
1064
1065
1066 //----------------------------------------------------------------------
1067 // Print formatting
1068
1069 int
1070 wxStyledTextCtrl::FormatRange(bool   doDraw,
1071                                     int    startPos,
1072                                     int    endPos,
1073                                     wxDC*  draw,
1074                                     wxDC*  target,  // Why does it use two? Can they be the same?
1075                                     wxRect renderRect,
1076                                     wxRect pageRect) {
1077     FORMATRANGE fr;
1078
1079     fr.hdc = draw;
1080     fr.hdcTarget = target;
1081     fr.rc.top = renderRect.GetTop();
1082     fr.rc.left = renderRect.GetLeft();
1083     fr.rc.right = renderRect.GetRight();
1084     fr.rc.bottom = renderRect.GetBottom();
1085     fr.rcPage.top = pageRect.GetTop();
1086     fr.rcPage.left = pageRect.GetLeft();
1087     fr.rcPage.right = pageRect.GetRight();
1088     fr.rcPage.bottom = pageRect.GetBottom();
1089     fr.chrg.cpMin = startPos;
1090     fr.chrg.cpMax = endPos;
1091
1092     return SendMsg(EM_FORMATRANGE, doDraw, (long)&fr);
1093 }
1094
1095
1096 //----------------------------------------------------------------------
1097 // Document Sharing
1098
1099 void* wxStyledTextCtrl::GetDocument() {
1100     return (void*)SendMsg(SCI_GETDOCPOINTER);
1101 }
1102
1103
1104 void wxStyledTextCtrl::SetDocument(void* document) {
1105     SendMsg(SCI_SETDOCPOINTER, 0, (long)document);
1106 }
1107
1108
1109 //----------------------------------------------------------------------
1110 // Folding
1111
1112 int  wxStyledTextCtrl::VisibleFromDocLine(int docLine) {
1113     return SendMsg(SCI_VISIBLEFROMDOCLINE, docLine);
1114 }
1115
1116
1117 int  wxStyledTextCtrl::DocLineFromVisible(int displayLine) {
1118     return SendMsg(SCI_DOCLINEFROMVISIBLE, displayLine);
1119 }
1120
1121
1122 int  wxStyledTextCtrl::SetFoldLevel(int line, int level) {
1123     return SendMsg(SCI_SETFOLDLEVEL, line, level);
1124 }
1125
1126
1127 int  wxStyledTextCtrl::GetFoldLevel(int line) {
1128     return SendMsg(SCI_GETFOLDLEVEL,  line);
1129 }
1130
1131
1132 int  wxStyledTextCtrl::GetLastChild(int line) {
1133     return SendMsg(SCI_GETLASTCHILD,  line);
1134 }
1135
1136
1137 int  wxStyledTextCtrl::GetFoldParent(int line) {
1138     return SendMsg(SCI_GETFOLDPARENT,  line);
1139 }
1140
1141
1142 void wxStyledTextCtrl::ShowLines(int lineStart, int lineEnd) {
1143     SendMsg(SCI_SHOWLINES, lineStart, lineEnd);
1144 }
1145
1146
1147 void wxStyledTextCtrl::HideLines(int lineStart, int lineEnd) {
1148     SendMsg(SCI_HIDELINES, lineStart, lineEnd);
1149 }
1150
1151
1152 bool wxStyledTextCtrl::GetLineVisible(int line) {
1153     return SendMsg(SCI_GETLINEVISIBLE, line) != 0;
1154 }
1155
1156
1157 void wxStyledTextCtrl::SetFoldExpanded(int line) {
1158     SendMsg(SCI_SETFOLDEXPANDED, line);
1159 }
1160
1161
1162 bool wxStyledTextCtrl::GetFoldExpanded(int line) {
1163     return SendMsg(SCI_GETFOLDEXPANDED, line) != 0;
1164 }
1165
1166
1167 void wxStyledTextCtrl::ToggleFold(int line) {
1168     SendMsg(SCI_TOGGLEFOLD, line);
1169 }
1170
1171
1172 void wxStyledTextCtrl::EnsureVisible(int line) {
1173     SendMsg(SCI_ENSUREVISIBLE, line);
1174 }
1175
1176
1177 //----------------------------------------------------------------------
1178 // Long Lines
1179
1180 int wxStyledTextCtrl::GetEdgeColumn() {
1181     return SendMsg(SCI_GETEDGECOLUMN);
1182 }
1183
1184 void wxStyledTextCtrl::SetEdgeColumn(int column) {
1185     SendMsg(SCI_SETEDGECOLUMN, column);
1186 }
1187
1188 wxSTC_EDGE wxStyledTextCtrl::GetEdgeMode() {
1189     return (wxSTC_EDGE) SendMsg(SCI_GETEDGEMODE);
1190 }
1191
1192 void wxStyledTextCtrl::SetEdgeMode(wxSTC_EDGE mode){
1193     SendMsg(SCI_SETEDGEMODE, mode);
1194 }
1195
1196 wxColour wxStyledTextCtrl::GetEdgeColour() {
1197     long c = SendMsg(SCI_GETEDGECOLOUR);
1198     return wxColourFromLong(c);
1199 }
1200
1201 void wxStyledTextCtrl::SetEdgeColour(const wxColour& colour) {
1202     SendMsg(SCI_SETEDGECOLOUR, wxColourAsLong(colour));
1203 }
1204
1205
1206 //----------------------------------------------------------------------
1207 // Lexer
1208
1209 void     wxStyledTextCtrl::SetLexer(wxSTC_LEX lexer) {
1210     SendMsg(SCI_SETLEXER, lexer);
1211 }
1212
1213
1214 wxSTC_LEX wxStyledTextCtrl::GetLexer() {
1215     return (wxSTC_LEX)SendMsg(SCI_GETLEXER);
1216 }
1217
1218
1219 void     wxStyledTextCtrl::Colourise(int start, int end) {
1220     SendMsg(SCI_COLOURISE, start, end);
1221 }
1222
1223
1224 void     wxStyledTextCtrl::SetProperty(const wxString& key, const wxString& value) {
1225     SendMsg(SCI_SETPROPERTY, (long)key.c_str(), (long)value.c_str());
1226 }
1227
1228
1229 void     wxStyledTextCtrl::SetKeywords(int keywordSet, const wxString& keywordList) {
1230     SendMsg(SCI_SETKEYWORDS, keywordSet, (long)keywordList.c_str());
1231 }
1232
1233
1234
1235 //----------------------------------------------------------------------
1236 // Event handlers
1237
1238 void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
1239     wxPaintDC dc(this);
1240     wxRegion  region = GetUpdateRegion();
1241
1242     m_swx->DoPaint(&dc, region.GetBox());
1243 }
1244
1245 void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
1246     if (evt.GetOrientation() == wxHORIZONTAL)
1247         m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
1248     else
1249         m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
1250 }
1251
1252 void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
1253     wxSize sz = GetClientSize();
1254     m_swx->DoSize(sz.x, sz.y);
1255 }
1256
1257 void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
1258     wxPoint pt = evt.GetPosition();
1259     m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
1260                       evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
1261 }
1262
1263 void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
1264     wxPoint pt = evt.GetPosition();
1265     m_swx->DoButtonMove(Point(pt.x, pt.y));
1266 }
1267
1268 void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
1269     wxPoint pt = evt.GetPosition();
1270     m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
1271                       evt.ControlDown());
1272 }
1273
1274
1275 void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
1276     wxPoint pt = evt.GetPosition();
1277     m_swx->DoContextMenu(Point(pt.x, pt.y));
1278 }
1279
1280 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
1281     int  processed = 0;
1282     long key = evt.KeyCode();
1283     if ((key > WXK_ESCAPE) &&
1284         (key != WXK_DELETE) && (key < 255) &&
1285         !evt.ControlDown() && !evt.AltDown()) {
1286
1287         m_swx->DoAddChar(key);
1288         processed = true;
1289     }
1290     else {
1291         key = toupper(key);
1292         processed = m_swx->DoKeyDown(key, evt.ShiftDown(),
1293                                      evt.ControlDown(), evt.AltDown());
1294     }
1295     if (! processed)
1296         evt.Skip();
1297 }
1298
1299 void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
1300     m_swx->DoLoseFocus();
1301 }
1302
1303 void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
1304     m_swx->DoGainFocus();
1305 }
1306
1307 void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
1308     m_swx->DoSysColourChange();
1309 }
1310
1311 void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
1312     // do nothing to help avoid flashing
1313 }
1314
1315
1316
1317 void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
1318     m_swx->DoCommand(evt.GetId());
1319 }
1320
1321
1322 //----------------------------------------------------------------------
1323 // Turn notifications from Scintilla into events
1324
1325 void wxStyledTextCtrl::NotifyChange() {
1326     wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
1327     GetEventHandler()->ProcessEvent(evt);
1328 }
1329
1330 void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
1331     SCNotification& scn = *_scn;
1332     int eventType = 0;
1333     switch (scn.nmhdr.code) {
1334     case SCN_STYLENEEDED:
1335         eventType = wxEVT_STC_STYLENEEDED;
1336         break;
1337     case SCN_CHARADDED:
1338         eventType = wxEVT_STC_CHARADDED;
1339         break;
1340     case SCN_UPDATEUI:
1341         eventType = wxEVT_STC_UPDATEUI;
1342         break;
1343     case SCN_SAVEPOINTREACHED:
1344         eventType = wxEVT_STC_SAVEPOINTREACHED;
1345         break;
1346     case SCN_SAVEPOINTLEFT:
1347         eventType = wxEVT_STC_SAVEPOINTLEFT;
1348         break;
1349     case SCN_MODIFYATTEMPTRO:
1350         eventType = wxEVT_STC_ROMODIFYATTEMPT;
1351         break;
1352     case SCN_DOUBLECLICK:
1353         eventType = wxEVT_STC_DOUBLECLICK;
1354         break;
1355     case SCN_MODIFIED:
1356         eventType = wxEVT_STC_MODIFIED;
1357         break;
1358     case SCN_KEY:
1359         eventType = wxEVT_STC_KEY;
1360         break;
1361     case SCN_MACRORECORD:
1362         eventType = wxEVT_STC_MACRORECORD;
1363         break;
1364     case SCN_MARGINCLICK:
1365         eventType = wxEVT_STC_MARGINCLICK;
1366         break;
1367     case SCN_NEEDSHOWN:
1368         eventType = wxEVT_STC_NEEDSHOWN;
1369         break;
1370     }
1371     if (eventType) {
1372         wxStyledTextEvent evt(eventType, GetId());
1373         evt.SetPosition(scn.position);
1374         evt.SetKey(scn.ch);
1375         evt.SetModifiers(scn.modifiers);
1376         if (eventType == wxEVT_STC_MODIFIED) {
1377             evt.SetModificationType(scn.modificationType);
1378             evt.SetText(scn.text);
1379             evt.SetLength(scn.length);
1380             evt.SetLinesAdded(scn.linesAdded);
1381             evt.SetLine(scn.line);
1382             evt.SetFoldLevelNow(scn.foldLevelNow);
1383             evt.SetFoldLevelPrev(scn.foldLevelPrev);
1384         }
1385         if (eventType == wxEVT_STC_MARGINCLICK)
1386             evt.SetMargin(scn.margin);
1387         if (eventType == wxEVT_STC_MACRORECORD) {
1388             evt.SetMessage(scn.message);
1389             evt.SetWParam(scn.wParam);
1390             evt.SetLParam(scn.lParam);
1391         }
1392
1393         GetEventHandler()->ProcessEvent(evt);
1394     }
1395 }
1396
1397
1398
1399 //----------------------------------------------------------------------
1400 //----------------------------------------------------------------------
1401 //----------------------------------------------------------------------
1402
1403 wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
1404     : wxCommandEvent(commandType, id)
1405 {
1406     m_position = 0;
1407     m_key = 0;
1408     m_modifiers = 0;
1409     m_modificationType = 0;
1410     m_length = 0;
1411     m_linesAdded = 0;
1412     m_line = 0;
1413     m_foldLevelNow = 0;
1414     m_foldLevelPrev = 0;
1415     m_margin = 0;
1416     m_message = 0;
1417     m_wParam = 0;
1418     m_lParam = 0;
1419
1420
1421 }
1422
1423 bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
1424 bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
1425 bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
1426
1427 void wxStyledTextEvent::CopyObject(wxObject& obj) const {
1428     wxCommandEvent::CopyObject(obj);
1429
1430     wxStyledTextEvent* o = (wxStyledTextEvent*)&obj;
1431     o->m_position =      m_position;
1432     o->m_key =           m_key;
1433     o->m_modifiers =     m_modifiers;
1434     o->m_modificationType = m_modificationType;
1435     o->m_text =          m_text;
1436     o->m_length =        m_length;
1437     o->m_linesAdded =    m_linesAdded;
1438     o->m_line =          m_line;
1439     o->m_foldLevelNow =  m_foldLevelNow;
1440     o->m_foldLevelPrev = m_foldLevelPrev;
1441
1442     o->m_margin =        m_margin;
1443
1444     o->m_message =       m_message;
1445     o->m_wParam =        m_wParam;
1446     o->m_lParam =        m_lParam;
1447
1448
1449
1450 }
1451
1452 //----------------------------------------------------------------------
1453 //----------------------------------------------------------------------
1454