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 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/wx.h>
  24 #include <wx/tokenzr.h>
  25 #include <wx/mstream.h>
  26 #include <wx/image.h>
  27
  28
  29 //----------------------------------------------------------------------
  30
  31 const wxChar* wxSTCNameStr = wxT("stcwindow");
  32
  33 #ifdef MAKELONG
  34 #undef MAKELONG
  35 #endif
  36
  37 #define MAKELONG(a, b) ((a) | ((b) << 16))
  38
  39
  40 static long wxColourAsLong(const wxColour& co) {
  41     return (((long)co.Blue()  << 16) |
  42             ((long)co.Green() <<  8) |
  43             ((long)co.Red()));
  44 }
  45
  46 static wxColour wxColourFromLong(long c) {
  47     wxColour clr;
  48     clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
  49     return clr;
  50 }
  51
  52
  53 static wxColour wxColourFromSpec(const wxString& spec) {
  54     // spec should be "#RRGGBB"
  55     long red, green, blue;
  56     red = green = blue = 0;
  57     spec.Mid(1,2).ToLong(&red,   16);
  58     spec.Mid(3,2).ToLong(&green, 16);
  59     spec.Mid(5,2).ToLong(&blue,  16);
  60     return wxColour(red, green, blue);
  61 }
  62
  63 //----------------------------------------------------------------------
  64
  65 DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
  66 DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
  67 DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
  68 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
  69 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
  70 DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
  71 DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
  72 DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
  73 DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
  74 DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
  75 DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
  76 DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
  77 DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
  78 DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )
  79 DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
  80 DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
  81 DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
  82 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLSTART )
  83 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLEND )
  84 DEFINE_EVENT_TYPE( wxEVT_STC_START_DRAG )
  85 DEFINE_EVENT_TYPE( wxEVT_STC_DRAG_OVER )
  86 DEFINE_EVENT_TYPE( wxEVT_STC_DO_DROP )
  87 DEFINE_EVENT_TYPE( wxEVT_STC_ZOOM )
  88 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_CLICK )
  89 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_DCLICK )
  90 DEFINE_EVENT_TYPE( wxEVT_STC_CALLTIP_CLICK )
  91
  92
  93
  94 BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
  95     EVT_PAINT                   (wxStyledTextCtrl::OnPaint)
  96     EVT_SCROLLWIN               (wxStyledTextCtrl::OnScrollWin)
  97     EVT_SCROLL                  (wxStyledTextCtrl::OnScroll)
  98     EVT_SIZE                    (wxStyledTextCtrl::OnSize)
  99     EVT_LEFT_DOWN               (wxStyledTextCtrl::OnMouseLeftDown)
 100     // Let Scintilla see the double click as a second click
 101     EVT_LEFT_DCLICK             (wxStyledTextCtrl::OnMouseLeftDown)
 102     EVT_MOTION                  (wxStyledTextCtrl::OnMouseMove)
 103     EVT_LEFT_UP                 (wxStyledTextCtrl::OnMouseLeftUp)
 104 #if defined(__WXGTK__) || defined(__WXMAC__)
 105     EVT_RIGHT_UP                (wxStyledTextCtrl::OnMouseRightUp)
 106 #else
 107     EVT_CONTEXT_MENU            (wxStyledTextCtrl::OnContextMenu)
 108 #endif
 109     EVT_MOUSEWHEEL              (wxStyledTextCtrl::OnMouseWheel)
 110     EVT_MIDDLE_UP               (wxStyledTextCtrl::OnMouseMiddleUp)
 111     EVT_CHAR                    (wxStyledTextCtrl::OnChar)
 112     EVT_KEY_DOWN                (wxStyledTextCtrl::OnKeyDown)
 113     EVT_KILL_FOCUS              (wxStyledTextCtrl::OnLoseFocus)
 114     EVT_SET_FOCUS               (wxStyledTextCtrl::OnGainFocus)
 115     EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
 116     EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
 117     EVT_MENU_RANGE              (10, 16, wxStyledTextCtrl::OnMenu)
 118     EVT_LISTBOX_DCLICK          (-1, wxStyledTextCtrl::OnListBox)
 119 END_EVENT_TABLE()
 120
 121
 122 IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
 123 IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
 124
 125 #ifdef LINK_LEXERS
 126 // forces the linking of the lexer modules
 127 int Scintilla_LinkLexers();
 128 #endif
 129
 130 //----------------------------------------------------------------------
 131 // Constructor and Destructor
 132
 133 wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
 134                                    wxWindowID id,
 135                                    const wxPoint& pos,
 136                                    const wxSize& size,
 137                                    long style,
 138                                    const wxString& name) :
 139     wxControl(parent, id, pos, size,
 140               style | wxVSCROLL | wxHSCROLL | wxWANTS_CHARS | wxCLIP_CHILDREN,
 141               wxDefaultValidator, name)
 142 {
 143 #ifdef LINK_LEXERS
 144     Scintilla_LinkLexers();
 145 #endif
 146     m_swx = new ScintillaWX(this);
 147     m_stopWatch.Start();
 148     m_lastKeyDownConsumed = FALSE;
 149     m_vScrollBar = NULL;
 150     m_hScrollBar = NULL;
 151 #if wxUSE_UNICODE
 152     // Put Scintilla into unicode (UTF-8) mode
 153     SetCodePage(wxSTC_CP_UTF8);
 154 #endif
 155 }
 156
 157
 158 wxStyledTextCtrl::~wxStyledTextCtrl() {
 159     delete m_swx;
 160 }
 161
 162
 163 //----------------------------------------------------------------------
 164
 165 long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
 166
 167     return m_swx->WndProc(msg, wp, lp);
 168 }
 169
 170
 171
 172 //----------------------------------------------------------------------
 173 // BEGIN generated section.  The following code is automatically generated
 174 //       by gen_iface.py from the contents of Scintilla.iface.  Do not edit
 175 //       this file.  Edit stc.cpp.in or gen_iface.py instead and regenerate.
 176
 177
 178 // Add text to the document.
 179 void wxStyledTextCtrl::AddText(const wxString& text) {
 180                     wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
 181                     SendMsg(2001, strlen(buf), (long)(const char*)buf);
 182 }
 183
 184 // Add array of cells to document.
 185 void wxStyledTextCtrl::AddStyledText(const wxMemoryBuffer& data) {
 186                           SendMsg(2002, data.GetDataLen(), (long)data.GetData());
 187 }
 188
 189 // Insert string at a position.
 190 void wxStyledTextCtrl::InsertText(int pos, const wxString& text) {
 191     SendMsg(2003, pos, (long)(const char*)wx2stc(text));
 192 }
 193
 194 // Delete all text in the document.
 195 void wxStyledTextCtrl::ClearAll() {
 196     SendMsg(2004, 0, 0);
 197 }
 198
 199 // Set all style bytes to 0, remove all folding information.
 200 void wxStyledTextCtrl::ClearDocumentStyle() {
 201     SendMsg(2005, 0, 0);
 202 }
 203
 204 // The number of characters in the document.
 205 int wxStyledTextCtrl::GetLength() {
 206     return SendMsg(2006, 0, 0);
 207 }
 208
 209 // Returns the character byte at the position.
 210 int wxStyledTextCtrl::GetCharAt(int pos) {
 211          return (unsigned char)SendMsg(2007, pos, 0);
 212 }
 213
 214 // Returns the position of the caret.
 215 int wxStyledTextCtrl::GetCurrentPos() {
 216     return SendMsg(2008, 0, 0);
 217 }
 218
 219 // Returns the position of the opposite end of the selection to the caret.
 220 int wxStyledTextCtrl::GetAnchor() {
 221     return SendMsg(2009, 0, 0);
 222 }
 223
 224 // Returns the style byte at the position.
 225 int wxStyledTextCtrl::GetStyleAt(int pos) {
 226          return (unsigned char)SendMsg(2010, pos, 0);
 227 }
 228
 229 // Redoes the next action on the undo history.
 230 void wxStyledTextCtrl::Redo() {
 231     SendMsg(2011, 0, 0);
 232 }
 233
 234 // Choose between collecting actions into the undo
 235 // history and discarding them.
 236 void wxStyledTextCtrl::SetUndoCollection(bool collectUndo) {
 237     SendMsg(2012, collectUndo, 0);
 238 }
 239
 240 // Select all the text in the document.
 241 void wxStyledTextCtrl::SelectAll() {
 242     SendMsg(2013, 0, 0);
 243 }
 244
 245 // Remember the current position in the undo history as the position
 246 // at which the document was saved.
 247 void wxStyledTextCtrl::SetSavePoint() {
 248     SendMsg(2014, 0, 0);
 249 }
 250
 251 // Retrieve a buffer of cells.
 252 wxMemoryBuffer wxStyledTextCtrl::GetStyledText(int startPos, int endPos) {
 253         wxMemoryBuffer buf;
 254         if (endPos < startPos) {
 255             int temp = startPos;
 256             startPos = endPos;
 257             endPos = temp;
 258         }
 259         int len = endPos - startPos;
 260         if (!len) return buf;
 261         TextRange tr;
 262         tr.lpstrText = (char*)buf.GetWriteBuf(len*2+1);
 263         tr.chrg.cpMin = startPos;
 264         tr.chrg.cpMax = endPos;
 265         len = SendMsg(2015, 0, (long)&tr);
 266         buf.UngetWriteBuf(len);
 267         return buf;
 268 }
 269
 270 // Are there any redoable actions in the undo history?
 271 bool wxStyledTextCtrl::CanRedo() {
 272     return SendMsg(2016, 0, 0) != 0;
 273 }
 274
 275 // Retrieve the line number at which a particular marker is located.
 276 int wxStyledTextCtrl::MarkerLineFromHandle(int handle) {
 277     return SendMsg(2017, handle, 0);
 278 }
 279
 280 // Delete a marker.
 281 void wxStyledTextCtrl::MarkerDeleteHandle(int handle) {
 282     SendMsg(2018, handle, 0);
 283 }
 284
 285 // Is undo history being collected?
 286 bool wxStyledTextCtrl::GetUndoCollection() {
 287     return SendMsg(2019, 0, 0) != 0;
 288 }
 289
 290 // Are white space characters currently visible?
 291 // Returns one of SCWS_* constants.
 292 int wxStyledTextCtrl::GetViewWhiteSpace() {
 293     return SendMsg(2020, 0, 0);
 294 }
 295
 296 // Make white space characters invisible, always visible or visible outside indentation.
 297 void wxStyledTextCtrl::SetViewWhiteSpace(int viewWS) {
 298     SendMsg(2021, viewWS, 0);
 299 }
 300
 301 // Find the position from a point within the window.
 302 int wxStyledTextCtrl::PositionFromPoint(wxPoint pt) {
 303         return SendMsg(2022, pt.x, pt.y);
 304 }
 305
 306 // Find the position from a point within the window but return
 307 // INVALID_POSITION if not close to text.
 308 int wxStyledTextCtrl::PositionFromPointClose(int x, int y) {
 309     return SendMsg(2023, x, y);
 310 }
 311
 312 // Set caret to start of a line and ensure it is visible.
 313 void wxStyledTextCtrl::GotoLine(int line) {
 314     SendMsg(2024, line, 0);
 315 }
 316
 317 // Set caret to a position and ensure it is visible.
 318 void wxStyledTextCtrl::GotoPos(int pos) {
 319     SendMsg(2025, pos, 0);
 320 }
 321
 322 // Set the selection anchor to a position. The anchor is the opposite
 323 // end of the selection from the caret.
 324 void wxStyledTextCtrl::SetAnchor(int posAnchor) {
 325     SendMsg(2026, posAnchor, 0);
 326 }
 327
 328 // Retrieve the text of the line containing the caret.
 329 // Returns the index of the caret on the line.
 330 wxString wxStyledTextCtrl::GetCurLine(int* linePos) {
 331         int len = LineLength(GetCurrentLine());
 332         if (!len) {
 333             if (linePos)  *linePos = 0;
 334             return wxEmptyString;
 335         }
 336
 337         wxMemoryBuffer mbuf(len+1);
 338         char* buf = (char*)mbuf.GetWriteBuf(len+1);
 339
 340         int pos = SendMsg(2027, len+1, (long)buf);
 341         mbuf.UngetWriteBuf(len);
 342         mbuf.AppendByte(0);
 343         if (linePos)  *linePos = pos;
 344         return stc2wx(buf);
 345 }
 346
 347 // Retrieve the position of the last correctly styled character.
 348 int wxStyledTextCtrl::GetEndStyled() {
 349     return SendMsg(2028, 0, 0);
 350 }
 351
 352 // Convert all line endings in the document to one mode.
 353 void wxStyledTextCtrl::ConvertEOLs(int eolMode) {
 354     SendMsg(2029, eolMode, 0);
 355 }
 356
 357 // Retrieve the current end of line mode - one of CRLF, CR, or LF.
 358 int wxStyledTextCtrl::GetEOLMode() {
 359     return SendMsg(2030, 0, 0);
 360 }
 361
 362 // Set the current end of line mode.
 363 void wxStyledTextCtrl::SetEOLMode(int eolMode) {
 364     SendMsg(2031, eolMode, 0);
 365 }
 366
 367 // Set the current styling position to pos and the styling mask to mask.
 368 // The styling mask can be used to protect some bits in each styling byte from modification.
 369 void wxStyledTextCtrl::StartStyling(int pos, int mask) {
 370     SendMsg(2032, pos, mask);
 371 }
 372
 373 // Change style from current styling position for length characters to a style
 374 // and move the current styling position to after this newly styled segment.
 375 void wxStyledTextCtrl::SetStyling(int length, int style) {
 376     SendMsg(2033, length, style);
 377 }
 378
 379 // Is drawing done first into a buffer or direct to the screen?
 380 bool wxStyledTextCtrl::GetBufferedDraw() {
 381     return SendMsg(2034, 0, 0) != 0;
 382 }
 383
 384 // If drawing is buffered then each line of text is drawn into a bitmap buffer
 385 // before drawing it to the screen to avoid flicker.
 386 void wxStyledTextCtrl::SetBufferedDraw(bool buffered) {
 387     SendMsg(2035, buffered, 0);
 388 }
 389
 390 // Change the visible size of a tab to be a multiple of the width of a space character.
 391 void wxStyledTextCtrl::SetTabWidth(int tabWidth) {
 392     SendMsg(2036, tabWidth, 0);
 393 }
 394
 395 // Retrieve the visible size of a tab.
 396 int wxStyledTextCtrl::GetTabWidth() {
 397     return SendMsg(2121, 0, 0);
 398 }
 399
 400 // Set the code page used to interpret the bytes of the document as characters.
 401 void wxStyledTextCtrl::SetCodePage(int codePage) {
 402 #if wxUSE_UNICODE
 403     wxASSERT_MSG(codePage == wxSTC_CP_UTF8,
 404                  wxT("Only wxSTC_CP_UTF8 may be used when wxUSE_UNICODE is on."));
 405 #else
 406     wxASSERT_MSG(codePage != wxSTC_CP_UTF8,
 407                  wxT("wxSTC_CP_UTF8 may not be used when wxUSE_UNICODE is off."));
 408 #endif
 409     SendMsg(2037, codePage);
 410 }
 411
 412 // Set the symbol used for a particular marker number,
 413 // and optionally the fore and background colours.
 414 void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol,
 415                 const wxColour& foreground,
 416                 const wxColour& background) {
 417
 418                 SendMsg(2040, markerNumber, markerSymbol);
 419                 if (foreground.Ok())
 420                     MarkerSetForeground(markerNumber, foreground);
 421                 if (background.Ok())
 422                     MarkerSetBackground(markerNumber, background);
 423 }
 424
 425 // Set the foreground colour used for a particular marker number.
 426 void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour& fore) {
 427     SendMsg(2041, markerNumber, wxColourAsLong(fore));
 428 }
 429
 430 // Set the background colour used for a particular marker number.
 431 void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour& back) {
 432     SendMsg(2042, markerNumber, wxColourAsLong(back));
 433 }
 434
 435 // Add a marker to a line, returning an ID which can be used to find or delete the marker.
 436 int wxStyledTextCtrl::MarkerAdd(int line, int markerNumber) {
 437     return SendMsg(2043, line, markerNumber);
 438 }
 439
 440 // Delete a marker from a line.
 441 void wxStyledTextCtrl::MarkerDelete(int line, int markerNumber) {
 442     SendMsg(2044, line, markerNumber);
 443 }
 444
 445 // Delete all markers with a particular number from all lines.
 446 void wxStyledTextCtrl::MarkerDeleteAll(int markerNumber) {
 447     SendMsg(2045, markerNumber, 0);
 448 }
 449
 450 // Get a bit mask of all the markers set on a line.
 451 int wxStyledTextCtrl::MarkerGet(int line) {
 452     return SendMsg(2046, line, 0);
 453 }
 454
 455 // Find the next line after lineStart that includes a marker in mask.
 456 int wxStyledTextCtrl::MarkerNext(int lineStart, int markerMask) {
 457     return SendMsg(2047, lineStart, markerMask);
 458 }
 459
 460 // Find the previous line before lineStart that includes a marker in mask.
 461 int wxStyledTextCtrl::MarkerPrevious(int lineStart, int markerMask) {
 462     return SendMsg(2048, lineStart, markerMask);
 463 }
 464
 465 // Define a marker from a bitmap
 466 void wxStyledTextCtrl::MarkerDefineBitmap(int markerNumber, const wxBitmap& bmp) {
 467         // convert bmp to a xpm in a string
 468         wxMemoryOutputStream strm;
 469         wxImage img = bmp.ConvertToImage();
 470         img.SaveFile(strm, wxBITMAP_TYPE_XPM);
 471         size_t len = strm.GetSize();
 472         char* buff = new char[len+1];
 473         strm.CopyTo(buff, len);
 474         buff[len] = 0;
 475         SendMsg(2049, markerNumber, (long)buff);
 476         delete [] buff;
 477
 478 }
 479
 480 // Set a margin to be either numeric or symbolic.
 481 void wxStyledTextCtrl::SetMarginType(int margin, int marginType) {
 482     SendMsg(2240, margin, marginType);
 483 }
 484
 485 // Retrieve the type of a margin.
 486 int wxStyledTextCtrl::GetMarginType(int margin) {
 487     return SendMsg(2241, margin, 0);
 488 }
 489
 490 // Set the width of a margin to a width expressed in pixels.
 491 void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) {
 492     SendMsg(2242, margin, pixelWidth);
 493 }
 494
 495 // Retrieve the width of a margin in pixels.
 496 int wxStyledTextCtrl::GetMarginWidth(int margin) {
 497     return SendMsg(2243, margin, 0);
 498 }
 499
 500 // Set a mask that determines which markers are displayed in a margin.
 501 void wxStyledTextCtrl::SetMarginMask(int margin, int mask) {
 502     SendMsg(2244, margin, mask);
 503 }
 504
 505 // Retrieve the marker mask of a margin.
 506 int wxStyledTextCtrl::GetMarginMask(int margin) {
 507     return SendMsg(2245, margin, 0);
 508 }
 509
 510 // Make a margin sensitive or insensitive to mouse clicks.
 511 void wxStyledTextCtrl::SetMarginSensitive(int margin, bool sensitive) {
 512     SendMsg(2246, margin, sensitive);
 513 }
 514
 515 // Retrieve the mouse click sensitivity of a margin.
 516 bool wxStyledTextCtrl::GetMarginSensitive(int margin) {
 517     return SendMsg(2247, margin, 0) != 0;
 518 }
 519
 520 // Clear all the styles and make equivalent to the global default style.
 521 void wxStyledTextCtrl::StyleClearAll() {
 522     SendMsg(2050, 0, 0);
 523 }
 524
 525 // Set the foreground colour of a style.
 526 void wxStyledTextCtrl::StyleSetForeground(int style, const wxColour& fore) {
 527     SendMsg(2051, style, wxColourAsLong(fore));
 528 }
 529
 530 // Set the background colour of a style.
 531 void wxStyledTextCtrl::StyleSetBackground(int style, const wxColour& back) {
 532     SendMsg(2052, style, wxColourAsLong(back));
 533 }
 534
 535 // Set a style to be bold or not.
 536 void wxStyledTextCtrl::StyleSetBold(int style, bool bold) {
 537     SendMsg(2053, style, bold);
 538 }
 539
 540 // Set a style to be italic or not.
 541 void wxStyledTextCtrl::StyleSetItalic(int style, bool italic) {
 542     SendMsg(2054, style, italic);
 543 }
 544
 545 // Set the size of characters of a style.
 546 void wxStyledTextCtrl::StyleSetSize(int style, int sizePoints) {
 547     SendMsg(2055, style, sizePoints);
 548 }
 549
 550 // Set the font of a style.
 551 void wxStyledTextCtrl::StyleSetFaceName(int style, const wxString& fontName) {
 552     SendMsg(2056, style, (long)(const char*)wx2stc(fontName));
 553 }
 554
 555 // Set a style to have its end of line filled or not.
 556 void wxStyledTextCtrl::StyleSetEOLFilled(int style, bool filled) {
 557     SendMsg(2057, style, filled);
 558 }
 559
 560 // Reset the default style to its state at startup
 561 void wxStyledTextCtrl::StyleResetDefault() {
 562     SendMsg(2058, 0, 0);
 563 }
 564
 565 // Set a style to be underlined or not.
 566 void wxStyledTextCtrl::StyleSetUnderline(int style, bool underline) {
 567     SendMsg(2059, style, underline);
 568 }
 569
 570 // Set a style to be mixed case, or to force upper or lower case.
 571 void wxStyledTextCtrl::StyleSetCase(int style, int caseForce) {
 572     SendMsg(2060, style, caseForce);
 573 }
 574
 575 // Set the character set of the font in a style.
 576 void wxStyledTextCtrl::StyleSetCharacterSet(int style, int characterSet) {
 577     SendMsg(2066, style, characterSet);
 578 }
 579
 580 // Set a style to be a hotspot or not.
 581 void wxStyledTextCtrl::StyleSetHotSpot(int style, bool hotspot) {
 582     SendMsg(2409, style, hotspot);
 583 }
 584
 585 // Set the foreground colour of the selection and whether to use this setting.
 586 void wxStyledTextCtrl::SetSelForeground(bool useSetting, const wxColour& fore) {
 587     SendMsg(2067, useSetting, wxColourAsLong(fore));
 588 }
 589
 590 // Set the background colour of the selection and whether to use this setting.
 591 void wxStyledTextCtrl::SetSelBackground(bool useSetting, const wxColour& back) {
 592     SendMsg(2068, useSetting, wxColourAsLong(back));
 593 }
 594
 595 // Set the foreground colour of the caret.
 596 void wxStyledTextCtrl::SetCaretForeground(const wxColour& fore) {
 597     SendMsg(2069, wxColourAsLong(fore), 0);
 598 }
 599
 600 // When key+modifier combination km is pressed perform msg.
 601 void wxStyledTextCtrl::CmdKeyAssign(int key, int modifiers, int cmd) {
 602          SendMsg(2070, MAKELONG(key, modifiers), cmd);
 603 }
 604
 605 // When key+modifier combination km do nothing.
 606 void wxStyledTextCtrl::CmdKeyClear(int key, int modifiers) {
 607          SendMsg(2071, MAKELONG(key, modifiers));
 608 }
 609
 610 // Drop all key mappings.
 611 void wxStyledTextCtrl::CmdKeyClearAll() {
 612     SendMsg(2072, 0, 0);
 613 }
 614
 615 // Set the styles for a segment of the document.
 616 void wxStyledTextCtrl::SetStyleBytes(int length, char* styleBytes) {
 617         SendMsg(2073, length, (long)styleBytes);
 618 }
 619
 620 // Set a style to be visible or not.
 621 void wxStyledTextCtrl::StyleSetVisible(int style, bool visible) {
 622     SendMsg(2074, style, visible);
 623 }
 624
 625 // Get the time in milliseconds that the caret is on and off.
 626 int wxStyledTextCtrl::GetCaretPeriod() {
 627     return SendMsg(2075, 0, 0);
 628 }
 629
 630 // Get the time in milliseconds that the caret is on and off. 0 = steady on.
 631 void wxStyledTextCtrl::SetCaretPeriod(int periodMilliseconds) {
 632     SendMsg(2076, periodMilliseconds, 0);
 633 }
 634
 635 // Set the set of characters making up words for when moving or selecting by word.
 636 void wxStyledTextCtrl::SetWordChars(const wxString& characters) {
 637     SendMsg(2077, 0, (long)(const char*)wx2stc(characters));
 638 }
 639
 640 // Start a sequence of actions that is undone and redone as a unit.
 641 // May be nested.
 642 void wxStyledTextCtrl::BeginUndoAction() {
 643     SendMsg(2078, 0, 0);
 644 }
 645
 646 // End a sequence of actions that is undone and redone as a unit.
 647 void wxStyledTextCtrl::EndUndoAction() {
 648     SendMsg(2079, 0, 0);
 649 }
 650
 651 // Set an indicator to plain, squiggle or TT.
 652 void wxStyledTextCtrl::IndicatorSetStyle(int indic, int style) {
 653     SendMsg(2080, indic, style);
 654 }
 655
 656 // Retrieve the style of an indicator.
 657 int wxStyledTextCtrl::IndicatorGetStyle(int indic) {
 658     return SendMsg(2081, indic, 0);
 659 }
 660
 661 // Set the foreground colour of an indicator.
 662 void wxStyledTextCtrl::IndicatorSetForeground(int indic, const wxColour& fore) {
 663     SendMsg(2082, indic, wxColourAsLong(fore));
 664 }
 665
 666 // Retrieve the foreground colour of an indicator.
 667 wxColour wxStyledTextCtrl::IndicatorGetForeground(int indic) {
 668     long c = SendMsg(2083, indic, 0);
 669     return wxColourFromLong(c);
 670 }
 671
 672 // Set the foreground colour of all whitespace and whether to use this setting.
 673 void wxStyledTextCtrl::SetWhitespaceForeground(bool useSetting, const wxColour& fore) {
 674     SendMsg(2084, useSetting, wxColourAsLong(fore));
 675 }
 676
 677 // Set the background colour of all whitespace and whether to use this setting.
 678 void wxStyledTextCtrl::SetWhitespaceBackground(bool useSetting, const wxColour& back) {
 679     SendMsg(2085, useSetting, wxColourAsLong(back));
 680 }
 681
 682 // Divide each styling byte into lexical class bits (default: 5) and indicator
 683 // bits (default: 3). If a lexer requires more than 32 lexical states, then this
 684 // is used to expand the possible states.
 685 void wxStyledTextCtrl::SetStyleBits(int bits) {
 686     SendMsg(2090, bits, 0);
 687 }
 688
 689 // Retrieve number of bits in style bytes used to hold the lexical state.
 690 int wxStyledTextCtrl::GetStyleBits() {
 691     return SendMsg(2091, 0, 0);
 692 }
 693
 694 // Used to hold extra styling information for each line.
 695 void wxStyledTextCtrl::SetLineState(int line, int state) {
 696     SendMsg(2092, line, state);
 697 }
 698
 699 // Retrieve the extra styling information for a line.
 700 int wxStyledTextCtrl::GetLineState(int line) {
 701     return SendMsg(2093, line, 0);
 702 }
 703
 704 // Retrieve the last line number that has line state.
 705 int wxStyledTextCtrl::GetMaxLineState() {
 706     return SendMsg(2094, 0, 0);
 707 }
 708
 709 // Is the background of the line containing the caret in a different colour?
 710 bool wxStyledTextCtrl::GetCaretLineVisible() {
 711     return SendMsg(2095, 0, 0) != 0;
 712 }
 713
 714 // Display the background of the line containing the caret in a different colour.
 715 void wxStyledTextCtrl::SetCaretLineVisible(bool show) {
 716     SendMsg(2096, show, 0);
 717 }
 718
 719 // Get the colour of the background of the line containing the caret.
 720 wxColour wxStyledTextCtrl::GetCaretLineBack() {
 721     long c = SendMsg(2097, 0, 0);
 722     return wxColourFromLong(c);
 723 }
 724
 725 // Set the colour of the background of the line containing the caret.
 726 void wxStyledTextCtrl::SetCaretLineBack(const wxColour& back) {
 727     SendMsg(2098, wxColourAsLong(back), 0);
 728 }
 729
 730 // Set a style to be changeable or not (read only).
 731 // Experimental feature, currently buggy.
 732 void wxStyledTextCtrl::StyleSetChangeable(int style, bool changeable) {
 733     SendMsg(2099, style, changeable);
 734 }
 735
 736 // Display a auto-completion list.
 737 // The lenEntered parameter indicates how many characters before
 738 // the caret should be used to provide context.
 739 void wxStyledTextCtrl::AutoCompShow(int lenEntered, const wxString& itemList) {
 740     SendMsg(2100, lenEntered, (long)(const char*)wx2stc(itemList));
 741 }
 742
 743 // Remove the auto-completion list from the screen.
 744 void wxStyledTextCtrl::AutoCompCancel() {
 745     SendMsg(2101, 0, 0);
 746 }
 747
 748 // Is there an auto-completion list visible?
 749 bool wxStyledTextCtrl::AutoCompActive() {
 750     return SendMsg(2102, 0, 0) != 0;
 751 }
 752
 753 // Retrieve the position of the caret when the auto-completion list was displayed.
 754 int wxStyledTextCtrl::AutoCompPosStart() {
 755     return SendMsg(2103, 0, 0);
 756 }
 757
 758 // User has selected an item so remove the list and insert the selection.
 759 void wxStyledTextCtrl::AutoCompComplete() {
 760     SendMsg(2104, 0, 0);
 761 }
 762
 763 // Define a set of character that when typed cancel the auto-completion list.
 764 void wxStyledTextCtrl::AutoCompStops(const wxString& characterSet) {
 765     SendMsg(2105, 0, (long)(const char*)wx2stc(characterSet));
 766 }
 767
 768 // Change the separator character in the string setting up an auto-completion list.
 769 // Default is space but can be changed if items contain space.
 770 void wxStyledTextCtrl::AutoCompSetSeparator(int separatorCharacter) {
 771     SendMsg(2106, separatorCharacter, 0);
 772 }
 773
 774 // Retrieve the auto-completion list separator character.
 775 int wxStyledTextCtrl::AutoCompGetSeparator() {
 776     return SendMsg(2107, 0, 0);
 777 }
 778
 779 // Select the item in the auto-completion list that starts with a string.
 780 void wxStyledTextCtrl::AutoCompSelect(const wxString& text) {
 781     SendMsg(2108, 0, (long)(const char*)wx2stc(text));
 782 }
 783
 784 // Should the auto-completion list be cancelled if the user backspaces to a
 785 // position before where the box was created.
 786 void wxStyledTextCtrl::AutoCompSetCancelAtStart(bool cancel) {
 787     SendMsg(2110, cancel, 0);
 788 }
 789
 790 // Retrieve whether auto-completion cancelled by backspacing before start.
 791 bool wxStyledTextCtrl::AutoCompGetCancelAtStart() {
 792     return SendMsg(2111, 0, 0) != 0;
 793 }
 794
 795 // Define a set of characters that when typed will cause the autocompletion to
 796 // choose the selected item.
 797 void wxStyledTextCtrl::AutoCompSetFillUps(const wxString& characterSet) {
 798     SendMsg(2112, 0, (long)(const char*)wx2stc(characterSet));
 799 }
 800
 801 // Should a single item auto-completion list automatically choose the item.
 802 void wxStyledTextCtrl::AutoCompSetChooseSingle(bool chooseSingle) {
 803     SendMsg(2113, chooseSingle, 0);
 804 }
 805
 806 // Retrieve whether a single item auto-completion list automatically choose the item.
 807 bool wxStyledTextCtrl::AutoCompGetChooseSingle() {
 808     return SendMsg(2114, 0, 0) != 0;
 809 }
 810
 811 // Set whether case is significant when performing auto-completion searches.
 812 void wxStyledTextCtrl::AutoCompSetIgnoreCase(bool ignoreCase) {
 813     SendMsg(2115, ignoreCase, 0);
 814 }
 815
 816 // Retrieve state of ignore case flag.
 817 bool wxStyledTextCtrl::AutoCompGetIgnoreCase() {
 818     return SendMsg(2116, 0, 0) != 0;
 819 }
 820
 821 // Display a list of strings and send notification when user chooses one.
 822 void wxStyledTextCtrl::UserListShow(int listType, const wxString& itemList) {
 823     SendMsg(2117, listType, (long)(const char*)wx2stc(itemList));
 824 }
 825
 826 // Set whether or not autocompletion is hidden automatically when nothing matches.
 827 void wxStyledTextCtrl::AutoCompSetAutoHide(bool autoHide) {
 828     SendMsg(2118, autoHide, 0);
 829 }
 830
 831 // Retrieve whether or not autocompletion is hidden automatically when nothing matches.
 832 bool wxStyledTextCtrl::AutoCompGetAutoHide() {
 833     return SendMsg(2119, 0, 0) != 0;
 834 }
 835
 836 // Set whether or not autocompletion deletes any word characters
 837 // after the inserted text upon completion.
 838 void wxStyledTextCtrl::AutoCompSetDropRestOfWord(bool dropRestOfWord) {
 839     SendMsg(2270, dropRestOfWord, 0);
 840 }
 841
 842 // Retrieve whether or not autocompletion deletes any word characters
 843 // after the inserted text upon completion.
 844 bool wxStyledTextCtrl::AutoCompGetDropRestOfWord() {
 845     return SendMsg(2271, 0, 0) != 0;
 846 }
 847
 848 // Register an image for use in autocompletion lists.
 849 void wxStyledTextCtrl::RegisterImage(int type, const wxBitmap& bmp) {
 850         // convert bmp to a xpm in a string
 851         wxMemoryOutputStream strm;
 852         wxImage img = bmp.ConvertToImage();
 853         img.SaveFile(strm, wxBITMAP_TYPE_XPM);
 854         size_t len = strm.GetSize();
 855         char* buff = new char[len+1];
 856         strm.CopyTo(buff, len);
 857         buff[len] = 0;
 858         SendMsg(2405, type, (long)buff);
 859         delete [] buff;
 860
 861 }
 862
 863 // Clear all the registered images.
 864 void wxStyledTextCtrl::ClearRegisteredImages() {
 865     SendMsg(2408, 0, 0);
 866 }
 867
 868 // Retrieve the auto-completion list type-separator character.
 869 int wxStyledTextCtrl::AutoCompGetTypeSeparator() {
 870     return SendMsg(2285, 0, 0);
 871 }
 872
 873 // Change the type-separator character in the string setting up an auto-completion list.
 874 // Default is '?' but can be changed if items contain '?'.
 875 void wxStyledTextCtrl::AutoCompSetTypeSeparator(int separatorCharacter) {
 876     SendMsg(2286, separatorCharacter, 0);
 877 }
 878
 879 // Set the number of spaces used for one level of indentation.
 880 void wxStyledTextCtrl::SetIndent(int indentSize) {
 881     SendMsg(2122, indentSize, 0);
 882 }
 883
 884 // Retrieve indentation size.
 885 int wxStyledTextCtrl::GetIndent() {
 886     return SendMsg(2123, 0, 0);
 887 }
 888
 889 // Indentation will only use space characters if useTabs is false, otherwise
 890 // it will use a combination of tabs and spaces.
 891 void wxStyledTextCtrl::SetUseTabs(bool useTabs) {
 892     SendMsg(2124, useTabs, 0);
 893 }
 894
 895 // Retrieve whether tabs will be used in indentation.
 896 bool wxStyledTextCtrl::GetUseTabs() {
 897     return SendMsg(2125, 0, 0) != 0;
 898 }
 899
 900 // Change the indentation of a line to a number of columns.
 901 void wxStyledTextCtrl::SetLineIndentation(int line, int indentSize) {
 902     SendMsg(2126, line, indentSize);
 903 }
 904
 905 // Retrieve the number of columns that a line is indented.
 906 int wxStyledTextCtrl::GetLineIndentation(int line) {
 907     return SendMsg(2127, line, 0);
 908 }
 909
 910 // Retrieve the position before the first non indentation character on a line.
 911 int wxStyledTextCtrl::GetLineIndentPosition(int line) {
 912     return SendMsg(2128, line, 0);
 913 }
 914
 915 // Retrieve the column number of a position, taking tab width into account.
 916 int wxStyledTextCtrl::GetColumn(int pos) {
 917     return SendMsg(2129, pos, 0);
 918 }
 919
 920 // Show or hide the horizontal scroll bar.
 921 void wxStyledTextCtrl::SetUseHorizontalScrollBar(bool show) {
 922     SendMsg(2130, show, 0);
 923 }
 924
 925 // Is the horizontal scroll bar visible?
 926 bool wxStyledTextCtrl::GetUseHorizontalScrollBar() {
 927     return SendMsg(2131, 0, 0) != 0;
 928 }
 929
 930 // Show or hide indentation guides.
 931 void wxStyledTextCtrl::SetIndentationGuides(bool show) {
 932     SendMsg(2132, show, 0);
 933 }
 934
 935 // Are the indentation guides visible?
 936 bool wxStyledTextCtrl::GetIndentationGuides() {
 937     return SendMsg(2133, 0, 0) != 0;
 938 }
 939
 940 // Set the highlighted indentation guide column.
 941 // 0 = no highlighted guide.
 942 void wxStyledTextCtrl::SetHighlightGuide(int column) {
 943     SendMsg(2134, column, 0);
 944 }
 945
 946 // Get the highlighted indentation guide column.
 947 int wxStyledTextCtrl::GetHighlightGuide() {
 948     return SendMsg(2135, 0, 0);
 949 }
 950
 951 // Get the position after the last visible characters on a line.
 952 int wxStyledTextCtrl::GetLineEndPosition(int line) {
 953     return SendMsg(2136, line, 0);
 954 }
 955
 956 // Get the code page used to interpret the bytes of the document as characters.
 957 int wxStyledTextCtrl::GetCodePage() {
 958     return SendMsg(2137, 0, 0);
 959 }
 960
 961 // Get the foreground colour of the caret.
 962 wxColour wxStyledTextCtrl::GetCaretForeground() {
 963     long c = SendMsg(2138, 0, 0);
 964     return wxColourFromLong(c);
 965 }
 966
 967 // In read-only mode?
 968 bool wxStyledTextCtrl::GetReadOnly() {
 969     return SendMsg(2140, 0, 0) != 0;
 970 }
 971
 972 // Sets the position of the caret.
 973 void wxStyledTextCtrl::SetCurrentPos(int pos) {
 974     SendMsg(2141, pos, 0);
 975 }
 976
 977 // Sets the position that starts the selection - this becomes the anchor.
 978 void wxStyledTextCtrl::SetSelectionStart(int pos) {
 979     SendMsg(2142, pos, 0);
 980 }
 981
 982 // Returns the position at the start of the selection.
 983 int wxStyledTextCtrl::GetSelectionStart() {
 984     return SendMsg(2143, 0, 0);
 985 }
 986
 987 // Sets the position that ends the selection - this becomes the currentPosition.
 988 void wxStyledTextCtrl::SetSelectionEnd(int pos) {
 989     SendMsg(2144, pos, 0);
 990 }
 991
 992 // Returns the position at the end of the selection.
 993 int wxStyledTextCtrl::GetSelectionEnd() {
 994     return SendMsg(2145, 0, 0);
 995 }
 996
 997 // Sets the print magnification added to the point size of each style for printing.
 998 void wxStyledTextCtrl::SetPrintMagnification(int magnification) {
 999     SendMsg(2146, magnification, 0);
1000 }
1001
1002 // Returns the print magnification.
1003 int wxStyledTextCtrl::GetPrintMagnification() {
1004     return SendMsg(2147, 0, 0);
1005 }
1006
1007 // Modify colours when printing for clearer printed text.
1008 void wxStyledTextCtrl::SetPrintColourMode(int mode) {
1009     SendMsg(2148, mode, 0);
1010 }
1011
1012 // Returns the print colour mode.
1013 int wxStyledTextCtrl::GetPrintColourMode() {
1014     return SendMsg(2149, 0, 0);
1015 }
1016
1017 // Find some text in the document.
1018 int wxStyledTextCtrl::FindText(int minPos, int maxPos,
1019                const wxString& text,
1020                int flags) {
1021             TextToFind  ft;
1022             ft.chrg.cpMin = minPos;
1023             ft.chrg.cpMax = maxPos;
1024             wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1025             ft.lpstrText = (char*)(const char*)buf;
1026
1027             return SendMsg(2150, flags, (long)&ft);
1028 }
1029
1030 // On Windows, will draw the document into a display context such as a printer.
1031  int wxStyledTextCtrl::FormatRange(bool   doDraw,
1032                 int    startPos,
1033                 int    endPos,
1034                 wxDC*  draw,
1035                 wxDC*  target,  // Why does it use two? Can they be the same?
1036                 wxRect renderRect,
1037                 wxRect pageRect) {
1038              RangeToFormat fr;
1039
1040              if (endPos < startPos) {
1041                  int temp = startPos;
1042                  startPos = endPos;
1043                  endPos = temp;
1044              }
1045              fr.hdc = draw;
1046              fr.hdcTarget = target;
1047              fr.rc.top = renderRect.GetTop();
1048              fr.rc.left = renderRect.GetLeft();
1049              fr.rc.right = renderRect.GetRight();
1050              fr.rc.bottom = renderRect.GetBottom();
1051              fr.rcPage.top = pageRect.GetTop();
1052              fr.rcPage.left = pageRect.GetLeft();
1053              fr.rcPage.right = pageRect.GetRight();
1054              fr.rcPage.bottom = pageRect.GetBottom();
1055              fr.chrg.cpMin = startPos;
1056              fr.chrg.cpMax = endPos;
1057
1058              return SendMsg(2151, doDraw, (long)&fr);
1059 }
1060
1061 // Retrieve the display line at the top of the display.
1062 int wxStyledTextCtrl::GetFirstVisibleLine() {
1063     return SendMsg(2152, 0, 0);
1064 }
1065
1066 // Retrieve the contents of a line.
1067 wxString wxStyledTextCtrl::GetLine(int line) {
1068          int len = LineLength(line);
1069          if (!len) return wxEmptyString;
1070
1071          wxMemoryBuffer mbuf(len+1);
1072          char* buf = (char*)mbuf.GetWriteBuf(len+1);
1073          SendMsg(2153, line, (long)buf);
1074          mbuf.UngetWriteBuf(len);
1075          mbuf.AppendByte(0);
1076          return stc2wx(buf);
1077 }
1078
1079 // Returns the number of lines in the document. There is always at least one.
1080 int wxStyledTextCtrl::GetLineCount() {
1081     return SendMsg(2154, 0, 0);
1082 }
1083
1084 // Sets the size in pixels of the left margin.
1085 void wxStyledTextCtrl::SetMarginLeft(int pixelWidth) {
1086     SendMsg(2155, 0, pixelWidth);
1087 }
1088
1089 // Returns the size in pixels of the left margin.
1090 int wxStyledTextCtrl::GetMarginLeft() {
1091     return SendMsg(2156, 0, 0);
1092 }
1093
1094 // Sets the size in pixels of the right margin.
1095 void wxStyledTextCtrl::SetMarginRight(int pixelWidth) {
1096     SendMsg(2157, 0, pixelWidth);
1097 }
1098
1099 // Returns the size in pixels of the right margin.
1100 int wxStyledTextCtrl::GetMarginRight() {
1101     return SendMsg(2158, 0, 0);
1102 }
1103
1104 // Is the document different from when it was last saved?
1105 bool wxStyledTextCtrl::GetModify() {
1106     return SendMsg(2159, 0, 0) != 0;
1107 }
1108
1109 // Select a range of text.
1110 void wxStyledTextCtrl::SetSelection(int start, int end) {
1111     SendMsg(2160, start, end);
1112 }
1113
1114 // Retrieve the selected text.
1115 wxString wxStyledTextCtrl::GetSelectedText() {
1116          int   start;
1117          int   end;
1118
1119          GetSelection(&start, &end);
1120          int   len  = end - start;
1121          if (!len) return wxEmptyString;
1122
1123          wxMemoryBuffer mbuf(len+1);
1124          char* buf = (char*)mbuf.GetWriteBuf(len+1);
1125          SendMsg(2161, 0, (long)buf);
1126          mbuf.UngetWriteBuf(len);
1127          mbuf.AppendByte(0);
1128          return stc2wx(buf);
1129 }
1130
1131 // Retrieve a range of text.
1132 wxString wxStyledTextCtrl::GetTextRange(int startPos, int endPos) {
1133          if (endPos < startPos) {
1134              int temp = startPos;
1135              startPos = endPos;
1136              endPos = temp;
1137          }
1138          int   len  = endPos - startPos;
1139          if (!len) return wxEmptyString;
1140          wxMemoryBuffer mbuf(len+1);
1141          char* buf = (char*)mbuf.GetWriteBuf(len);
1142          TextRange tr;
1143          tr.lpstrText = buf;
1144          tr.chrg.cpMin = startPos;
1145          tr.chrg.cpMax = endPos;
1146          SendMsg(2162, 0, (long)&tr);
1147          mbuf.UngetWriteBuf(len);
1148          mbuf.AppendByte(0);
1149          return stc2wx(buf);
1150 }
1151
1152 // Draw the selection in normal style or with selection highlighted.
1153 void wxStyledTextCtrl::HideSelection(bool normal) {
1154     SendMsg(2163, normal, 0);
1155 }
1156
1157 // Retrieve the line containing a position.
1158 int wxStyledTextCtrl::LineFromPosition(int pos) {
1159     return SendMsg(2166, pos, 0);
1160 }
1161
1162 // Retrieve the position at the start of a line.
1163 int wxStyledTextCtrl::PositionFromLine(int line) {
1164     return SendMsg(2167, line, 0);
1165 }
1166
1167 // Scroll horizontally and vertically.
1168 void wxStyledTextCtrl::LineScroll(int columns, int lines) {
1169     SendMsg(2168, columns, lines);
1170 }
1171
1172 // Ensure the caret is visible.
1173 void wxStyledTextCtrl::EnsureCaretVisible() {
1174     SendMsg(2169, 0, 0);
1175 }
1176
1177 // Replace the selected text with the argument text.
1178 void wxStyledTextCtrl::ReplaceSelection(const wxString& text) {
1179     SendMsg(2170, 0, (long)(const char*)wx2stc(text));
1180 }
1181
1182 // Set to read only or read write.
1183 void wxStyledTextCtrl::SetReadOnly(bool readOnly) {
1184     SendMsg(2171, readOnly, 0);
1185 }
1186
1187 // Will a paste succeed?
1188 bool wxStyledTextCtrl::CanPaste() {
1189     return SendMsg(2173, 0, 0) != 0;
1190 }
1191
1192 // Are there any undoable actions in the undo history?
1193 bool wxStyledTextCtrl::CanUndo() {
1194     return SendMsg(2174, 0, 0) != 0;
1195 }
1196
1197 // Delete the undo history.
1198 void wxStyledTextCtrl::EmptyUndoBuffer() {
1199     SendMsg(2175, 0, 0);
1200 }
1201
1202 // Undo one action in the undo history.
1203 void wxStyledTextCtrl::Undo() {
1204     SendMsg(2176, 0, 0);
1205 }
1206
1207 // Cut the selection to the clipboard.
1208 void wxStyledTextCtrl::Cut() {
1209     SendMsg(2177, 0, 0);
1210 }
1211
1212 // Copy the selection to the clipboard.
1213 void wxStyledTextCtrl::Copy() {
1214     SendMsg(2178, 0, 0);
1215 }
1216
1217 // Paste the contents of the clipboard into the document replacing the selection.
1218 void wxStyledTextCtrl::Paste() {
1219     SendMsg(2179, 0, 0);
1220 }
1221
1222 // Clear the selection.
1223 void wxStyledTextCtrl::Clear() {
1224     SendMsg(2180, 0, 0);
1225 }
1226
1227 // Replace the contents of the document with the argument text.
1228 void wxStyledTextCtrl::SetText(const wxString& text) {
1229     SendMsg(2181, 0, (long)(const char*)wx2stc(text));
1230 }
1231
1232 // Retrieve all the text in the document.
1233 wxString wxStyledTextCtrl::GetText() {
1234          int len  = GetTextLength();
1235          wxMemoryBuffer mbuf(len+1);   // leave room for the null...
1236          char* buf = (char*)mbuf.GetWriteBuf(len+1);
1237          SendMsg(2182, len+1, (long)buf);
1238          mbuf.UngetWriteBuf(len);
1239          mbuf.AppendByte(0);
1240          return stc2wx(buf);
1241 }
1242
1243 // Retrieve the number of characters in the document.
1244 int wxStyledTextCtrl::GetTextLength() {
1245     return SendMsg(2183, 0, 0);
1246 }
1247
1248 // Set to overtype (true) or insert mode.
1249 void wxStyledTextCtrl::SetOvertype(bool overtype) {
1250     SendMsg(2186, overtype, 0);
1251 }
1252
1253 // Returns true if overtype mode is active otherwise false is returned.
1254 bool wxStyledTextCtrl::GetOvertype() {
1255     return SendMsg(2187, 0, 0) != 0;
1256 }
1257
1258 // Set the width of the insert mode caret.
1259 void wxStyledTextCtrl::SetCaretWidth(int pixelWidth) {
1260     SendMsg(2188, pixelWidth, 0);
1261 }
1262
1263 // Returns the width of the insert mode caret.
1264 int wxStyledTextCtrl::GetCaretWidth() {
1265     return SendMsg(2189, 0, 0);
1266 }
1267
1268 // Sets the position that starts the target which is used for updating the
1269 // document without affecting the scroll position.
1270 void wxStyledTextCtrl::SetTargetStart(int pos) {
1271     SendMsg(2190, pos, 0);
1272 }
1273
1274 // Get the position that starts the target.
1275 int wxStyledTextCtrl::GetTargetStart() {
1276     return SendMsg(2191, 0, 0);
1277 }
1278
1279 // Sets the position that ends the target which is used for updating the
1280 // document without affecting the scroll position.
1281 void wxStyledTextCtrl::SetTargetEnd(int pos) {
1282     SendMsg(2192, pos, 0);
1283 }
1284
1285 // Get the position that ends the target.
1286 int wxStyledTextCtrl::GetTargetEnd() {
1287     return SendMsg(2193, 0, 0);
1288 }
1289
1290 // Replace the target text with the argument text.
1291 // Text is counted so it can contain nulls.
1292 // Returns the length of the replacement text.
1293
1294      int wxStyledTextCtrl::ReplaceTarget(const wxString& text) {
1295          wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1296          return SendMsg(2194, strlen(buf), (long)(const char*)buf);
1297 }
1298
1299 // Replace the target text with the argument text after \d processing.
1300 // Text is counted so it can contain nulls.
1301 // Looks for \d where d is between 1 and 9 and replaces these with the strings
1302 // matched in the last search operation which were surrounded by \( and \).
1303 // Returns the length of the replacement text including any change
1304 // caused by processing the \d patterns.
1305
1306      int wxStyledTextCtrl::ReplaceTargetRE(const wxString& text) {
1307          wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1308          return SendMsg(2195, strlen(buf), (long)(const char*)buf);
1309 }
1310
1311 // Search for a counted string in the target and set the target to the found
1312 // range. Text is counted so it can contain nulls.
1313 // Returns length of range or -1 for failure in which case target is not moved.
1314
1315      int wxStyledTextCtrl::SearchInTarget(const wxString& text) {
1316          wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1317          return SendMsg(2197, strlen(buf), (long)(const char*)buf);
1318 }
1319
1320 // Set the search flags used by SearchInTarget.
1321 void wxStyledTextCtrl::SetSearchFlags(int flags) {
1322     SendMsg(2198, flags, 0);
1323 }
1324
1325 // Get the search flags used by SearchInTarget.
1326 int wxStyledTextCtrl::GetSearchFlags() {
1327     return SendMsg(2199, 0, 0);
1328 }
1329
1330 // Show a call tip containing a definition near position pos.
1331 void wxStyledTextCtrl::CallTipShow(int pos, const wxString& definition) {
1332     SendMsg(2200, pos, (long)(const char*)wx2stc(definition));
1333 }
1334
1335 // Remove the call tip from the screen.
1336 void wxStyledTextCtrl::CallTipCancel() {
1337     SendMsg(2201, 0, 0);
1338 }
1339
1340 // Is there an active call tip?
1341 bool wxStyledTextCtrl::CallTipActive() {
1342     return SendMsg(2202, 0, 0) != 0;
1343 }
1344
1345 // Retrieve the position where the caret was before displaying the call tip.
1346 int wxStyledTextCtrl::CallTipPosAtStart() {
1347     return SendMsg(2203, 0, 0);
1348 }
1349
1350 // Highlight a segment of the definition.
1351 void wxStyledTextCtrl::CallTipSetHighlight(int start, int end) {
1352     SendMsg(2204, start, end);
1353 }
1354
1355 // Set the background colour for the call tip.
1356 void wxStyledTextCtrl::CallTipSetBackground(const wxColour& back) {
1357     SendMsg(2205, wxColourAsLong(back), 0);
1358 }
1359
1360 // Set the foreground colour for the call tip.
1361 void wxStyledTextCtrl::CallTipSetForeground(const wxColour& fore) {
1362     SendMsg(2206, wxColourAsLong(fore), 0);
1363 }
1364
1365 // Set the foreground colour for the highlighted part of the call tip.
1366 void wxStyledTextCtrl::CallTipSetForegroundHighlight(const wxColour& fore) {
1367     SendMsg(2207, wxColourAsLong(fore), 0);
1368 }
1369
1370 // Find the display line of a document line taking hidden lines into account.
1371 int wxStyledTextCtrl::VisibleFromDocLine(int line) {
1372     return SendMsg(2220, line, 0);
1373 }
1374
1375 // Find the document line of a display line taking hidden lines into account.
1376 int wxStyledTextCtrl::DocLineFromVisible(int lineDisplay) {
1377     return SendMsg(2221, lineDisplay, 0);
1378 }
1379
1380 // Set the fold level of a line.
1381 // This encodes an integer level along with flags indicating whether the
1382 // line is a header and whether it is effectively white space.
1383 void wxStyledTextCtrl::SetFoldLevel(int line, int level) {
1384     SendMsg(2222, line, level);
1385 }
1386
1387 // Retrieve the fold level of a line.
1388 int wxStyledTextCtrl::GetFoldLevel(int line) {
1389     return SendMsg(2223, line, 0);
1390 }
1391
1392 // Find the last child line of a header line.
1393 int wxStyledTextCtrl::GetLastChild(int line, int level) {
1394     return SendMsg(2224, line, level);
1395 }
1396
1397 // Find the parent line of a child line.
1398 int wxStyledTextCtrl::GetFoldParent(int line) {
1399     return SendMsg(2225, line, 0);
1400 }
1401
1402 // Make a range of lines visible.
1403 void wxStyledTextCtrl::ShowLines(int lineStart, int lineEnd) {
1404     SendMsg(2226, lineStart, lineEnd);
1405 }
1406
1407 // Make a range of lines invisible.
1408 void wxStyledTextCtrl::HideLines(int lineStart, int lineEnd) {
1409     SendMsg(2227, lineStart, lineEnd);
1410 }
1411
1412 // Is a line visible?
1413 bool wxStyledTextCtrl::GetLineVisible(int line) {
1414     return SendMsg(2228, line, 0) != 0;
1415 }
1416
1417 // Show the children of a header line.
1418 void wxStyledTextCtrl::SetFoldExpanded(int line, bool expanded) {
1419     SendMsg(2229, line, expanded);
1420 }
1421
1422 // Is a header line expanded?
1423 bool wxStyledTextCtrl::GetFoldExpanded(int line) {
1424     return SendMsg(2230, line, 0) != 0;
1425 }
1426
1427 // Switch a header line between expanded and contracted.
1428 void wxStyledTextCtrl::ToggleFold(int line) {
1429     SendMsg(2231, line, 0);
1430 }
1431
1432 // Ensure a particular line is visible by expanding any header line hiding it.
1433 void wxStyledTextCtrl::EnsureVisible(int line) {
1434     SendMsg(2232, line, 0);
1435 }
1436
1437 // Set some style options for folding.
1438 void wxStyledTextCtrl::SetFoldFlags(int flags) {
1439     SendMsg(2233, flags, 0);
1440 }
1441
1442 // Ensure a particular line is visible by expanding any header line hiding it.
1443 // Use the currently set visibility policy to determine which range to display.
1444 void wxStyledTextCtrl::EnsureVisibleEnforcePolicy(int line) {
1445     SendMsg(2234, line, 0);
1446 }
1447
1448 // Sets whether a tab pressed when caret is within indentation indents.
1449 void wxStyledTextCtrl::SetTabIndents(bool tabIndents) {
1450     SendMsg(2260, tabIndents, 0);
1451 }
1452
1453 // Does a tab pressed when caret is within indentation indent?
1454 bool wxStyledTextCtrl::GetTabIndents() {
1455     return SendMsg(2261, 0, 0) != 0;
1456 }
1457
1458 // Sets whether a backspace pressed when caret is within indentation unindents.
1459 void wxStyledTextCtrl::SetBackSpaceUnIndents(bool bsUnIndents) {
1460     SendMsg(2262, bsUnIndents, 0);
1461 }
1462
1463 // Does a backspace pressed when caret is within indentation unindent?
1464 bool wxStyledTextCtrl::GetBackSpaceUnIndents() {
1465     return SendMsg(2263, 0, 0) != 0;
1466 }
1467
1468 // Sets the time the mouse must sit still to generate a mouse dwell event.
1469 void wxStyledTextCtrl::SetMouseDwellTime(int periodMilliseconds) {
1470     SendMsg(2264, periodMilliseconds, 0);
1471 }
1472
1473 // Retrieve the time the mouse must sit still to generate a mouse dwell event.
1474 int wxStyledTextCtrl::GetMouseDwellTime() {
1475     return SendMsg(2265, 0, 0);
1476 }
1477
1478 // Get position of start of word.
1479 int wxStyledTextCtrl::WordStartPosition(int pos, bool onlyWordCharacters) {
1480     return SendMsg(2266, pos, onlyWordCharacters);
1481 }
1482
1483 // Get position of end of word.
1484 int wxStyledTextCtrl::WordEndPosition(int pos, bool onlyWordCharacters) {
1485     return SendMsg(2267, pos, onlyWordCharacters);
1486 }
1487
1488 // Sets whether text is word wrapped.
1489 void wxStyledTextCtrl::SetWrapMode(int mode) {
1490     SendMsg(2268, mode, 0);
1491 }
1492
1493 // Retrieve whether text is word wrapped.
1494 int wxStyledTextCtrl::GetWrapMode() {
1495     return SendMsg(2269, 0, 0);
1496 }
1497
1498 // Sets the degree of caching of layout information.
1499 void wxStyledTextCtrl::SetLayoutCache(int mode) {
1500     SendMsg(2272, mode, 0);
1501 }
1502
1503 // Retrieve the degree of caching of layout information.
1504 int wxStyledTextCtrl::GetLayoutCache() {
1505     return SendMsg(2273, 0, 0);
1506 }
1507
1508 // Sets the document width assumed for scrolling.
1509 void wxStyledTextCtrl::SetScrollWidth(int pixelWidth) {
1510     SendMsg(2274, pixelWidth, 0);
1511 }
1512
1513 // Retrieve the document width assumed for scrolling.
1514 int wxStyledTextCtrl::GetScrollWidth() {
1515     return SendMsg(2275, 0, 0);
1516 }
1517
1518 // Measure the pixel width of some text in a particular style.
1519 // Nul terminated text argument.
1520 // Does not handle tab or control characters.
1521 int wxStyledTextCtrl::TextWidth(int style, const wxString& text) {
1522     return SendMsg(2276, style, (long)(const char*)wx2stc(text));
1523 }
1524
1525 // Sets the scroll range so that maximum scroll position has
1526 // the last line at the bottom of the view (default).
1527 // Setting this to false allows scrolling one page below the last line.
1528 void wxStyledTextCtrl::SetEndAtLastLine(bool endAtLastLine) {
1529     SendMsg(2277, endAtLastLine, 0);
1530 }
1531
1532 // Retrieve whether the maximum scroll position has the last
1533 // line at the bottom of the view.
1534 int wxStyledTextCtrl::GetEndAtLastLine() {
1535     return SendMsg(2278, 0, 0);
1536 }
1537
1538 // Retrieve the height of a particular line of text in pixels.
1539 int wxStyledTextCtrl::TextHeight(int line) {
1540     return SendMsg(2279, line, 0);
1541 }
1542
1543 // Show or hide the vertical scroll bar.
1544 void wxStyledTextCtrl::SetUseVerticalScrollBar(bool show) {
1545     SendMsg(2280, show, 0);
1546 }
1547
1548 // Is the vertical scroll bar visible?
1549 bool wxStyledTextCtrl::GetUseVerticalScrollBar() {
1550     return SendMsg(2281, 0, 0) != 0;
1551 }
1552
1553 // Append a string to the end of the document without changing the selection.
1554 void wxStyledTextCtrl::AppendText(int length, const wxString& text) {
1555     SendMsg(2282, length, (long)(const char*)wx2stc(text));
1556 }
1557
1558 // Is drawing done in two phases with backgrounds drawn before foregrounds?
1559 bool wxStyledTextCtrl::GetTwoPhaseDraw() {
1560     return SendMsg(2283, 0, 0) != 0;
1561 }
1562
1563 // In twoPhaseDraw mode, drawing is performed in two phases, first the background
1564 // and then the foreground. This avoids chopping off characters that overlap the next run.
1565 void wxStyledTextCtrl::SetTwoPhaseDraw(bool twoPhase) {
1566     SendMsg(2284, twoPhase, 0);
1567 }
1568
1569 // Make the target range start and end be the same as the selection range start and end.
1570 void wxStyledTextCtrl::TargetFromSelection() {
1571     SendMsg(2287, 0, 0);
1572 }
1573
1574 // Join the lines in the target.
1575 void wxStyledTextCtrl::LinesJoin() {
1576     SendMsg(2288, 0, 0);
1577 }
1578
1579 // Split the lines in the target into lines that are less wide than pixelWidth
1580 // where possible.
1581 void wxStyledTextCtrl::LinesSplit(int pixelWidth) {
1582     SendMsg(2289, pixelWidth, 0);
1583 }
1584
1585 // Set the colours used as a chequerboard pattern in the fold margin
1586 void wxStyledTextCtrl::SetFoldMarginColour(bool useSetting, const wxColour& back) {
1587     SendMsg(2290, useSetting, wxColourAsLong(back));
1588 }
1589 void wxStyledTextCtrl::SetFoldMarginHiColour(bool useSetting, const wxColour& fore) {
1590     SendMsg(2291, useSetting, wxColourAsLong(fore));
1591 }
1592
1593 // Duplicate the current line.
1594 void wxStyledTextCtrl::LineDuplicate() {
1595     SendMsg(2404, 0, 0);
1596 }
1597
1598 // Move caret to first position on display line.
1599 void wxStyledTextCtrl::HomeDisplay() {
1600     SendMsg(2345, 0, 0);
1601 }
1602
1603 // Move caret to first position on display line extending selection to
1604 // new caret position.
1605 void wxStyledTextCtrl::HomeDisplayExtend() {
1606     SendMsg(2346, 0, 0);
1607 }
1608
1609 // Move caret to last position on display line.
1610 void wxStyledTextCtrl::LineEndDisplay() {
1611     SendMsg(2347, 0, 0);
1612 }
1613
1614 // Move caret to last position on display line extending selection to new
1615 // caret position.
1616 void wxStyledTextCtrl::LineEndDisplayExtend() {
1617     SendMsg(2348, 0, 0);
1618 }
1619
1620 // Move the caret inside current view if it's not there already.
1621 void wxStyledTextCtrl::MoveCaretInsideView() {
1622     SendMsg(2401, 0, 0);
1623 }
1624
1625 // How many characters are on a line, not including end of line characters?
1626 int wxStyledTextCtrl::LineLength(int line) {
1627     return SendMsg(2350, line, 0);
1628 }
1629
1630 // Highlight the characters at two positions.
1631 void wxStyledTextCtrl::BraceHighlight(int pos1, int pos2) {
1632     SendMsg(2351, pos1, pos2);
1633 }
1634
1635 // Highlight the character at a position indicating there is no matching brace.
1636 void wxStyledTextCtrl::BraceBadLight(int pos) {
1637     SendMsg(2352, pos, 0);
1638 }
1639
1640 // Find the position of a matching brace or INVALID_POSITION if no match.
1641 int wxStyledTextCtrl::BraceMatch(int pos) {
1642     return SendMsg(2353, pos, 0);
1643 }
1644
1645 // Are the end of line characters visible?
1646 bool wxStyledTextCtrl::GetViewEOL() {
1647     return SendMsg(2355, 0, 0) != 0;
1648 }
1649
1650 // Make the end of line characters visible or invisible.
1651 void wxStyledTextCtrl::SetViewEOL(bool visible) {
1652     SendMsg(2356, visible, 0);
1653 }
1654
1655 // Retrieve a pointer to the document object.
1656 void* wxStyledTextCtrl::GetDocPointer() {
1657          return (void*)SendMsg(2357);
1658 }
1659
1660 // Change the document object used.
1661 void wxStyledTextCtrl::SetDocPointer(void* docPointer) {
1662          SendMsg(2358, 0, (long)docPointer);
1663 }
1664
1665 // Set which document modification events are sent to the container.
1666 void wxStyledTextCtrl::SetModEventMask(int mask) {
1667     SendMsg(2359, mask, 0);
1668 }
1669
1670 // Retrieve the column number which text should be kept within.
1671 int wxStyledTextCtrl::GetEdgeColumn() {
1672     return SendMsg(2360, 0, 0);
1673 }
1674
1675 // Set the column number of the edge.
1676 // If text goes past the edge then it is highlighted.
1677 void wxStyledTextCtrl::SetEdgeColumn(int column) {
1678     SendMsg(2361, column, 0);
1679 }
1680
1681 // Retrieve the edge highlight mode.
1682 int wxStyledTextCtrl::GetEdgeMode() {
1683     return SendMsg(2362, 0, 0);
1684 }
1685
1686 // The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
1687 // goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
1688 void wxStyledTextCtrl::SetEdgeMode(int mode) {
1689     SendMsg(2363, mode, 0);
1690 }
1691
1692 // Retrieve the colour used in edge indication.
1693 wxColour wxStyledTextCtrl::GetEdgeColour() {
1694     long c = SendMsg(2364, 0, 0);
1695     return wxColourFromLong(c);
1696 }
1697
1698 // Change the colour used in edge indication.
1699 void wxStyledTextCtrl::SetEdgeColour(const wxColour& edgeColour) {
1700     SendMsg(2365, wxColourAsLong(edgeColour), 0);
1701 }
1702
1703 // Sets the current caret position to be the search anchor.
1704 void wxStyledTextCtrl::SearchAnchor() {
1705     SendMsg(2366, 0, 0);
1706 }
1707
1708 // Find some text starting at the search anchor.
1709 // Does not ensure the selection is visible.
1710 int wxStyledTextCtrl::SearchNext(int flags, const wxString& text) {
1711     return SendMsg(2367, flags, (long)(const char*)wx2stc(text));
1712 }
1713
1714 // Find some text starting at the search anchor and moving backwards.
1715 // Does not ensure the selection is visible.
1716 int wxStyledTextCtrl::SearchPrev(int flags, const wxString& text) {
1717     return SendMsg(2368, flags, (long)(const char*)wx2stc(text));
1718 }
1719
1720 // Retrieves the number of lines completely visible.
1721 int wxStyledTextCtrl::LinesOnScreen() {
1722     return SendMsg(2370, 0, 0);
1723 }
1724
1725 // Set whether a pop up menu is displayed automatically when the user presses
1726 // the wrong mouse button.
1727 void wxStyledTextCtrl::UsePopUp(bool allowPopUp) {
1728     SendMsg(2371, allowPopUp, 0);
1729 }
1730
1731 // Is the selection rectangular? The alternative is the more common stream selection.
1732 bool wxStyledTextCtrl::SelectionIsRectangle() {
1733     return SendMsg(2372, 0, 0) != 0;
1734 }
1735
1736 // Set the zoom level. This number of points is added to the size of all fonts.
1737 // It may be positive to magnify or negative to reduce.
1738 void wxStyledTextCtrl::SetZoom(int zoom) {
1739     SendMsg(2373, zoom, 0);
1740 }
1741
1742 // Retrieve the zoom level.
1743 int wxStyledTextCtrl::GetZoom() {
1744     return SendMsg(2374, 0, 0);
1745 }
1746
1747 // Create a new document object.
1748 // Starts with reference count of 1 and not selected into editor.
1749 void* wxStyledTextCtrl::CreateDocument() {
1750          return (void*)SendMsg(2375);
1751 }
1752
1753 // Extend life of document.
1754 void wxStyledTextCtrl::AddRefDocument(void* docPointer) {
1755          SendMsg(2376, 0, (long)docPointer);
1756 }
1757
1758 // Release a reference to the document, deleting document if it fades to black.
1759 void wxStyledTextCtrl::ReleaseDocument(void* docPointer) {
1760          SendMsg(2377, 0, (long)docPointer);
1761 }
1762
1763 // Get which document modification events are sent to the container.
1764 int wxStyledTextCtrl::GetModEventMask() {
1765     return SendMsg(2378, 0, 0);
1766 }
1767
1768 // Change internal focus flag.
1769 void wxStyledTextCtrl::SetSTCFocus(bool focus) {
1770     SendMsg(2380, focus, 0);
1771 }
1772
1773 // Get internal focus flag.
1774 bool wxStyledTextCtrl::GetSTCFocus() {
1775     return SendMsg(2381, 0, 0) != 0;
1776 }
1777
1778 // Change error status - 0 = OK.
1779 void wxStyledTextCtrl::SetStatus(int statusCode) {
1780     SendMsg(2382, statusCode, 0);
1781 }
1782
1783 // Get error status.
1784 int wxStyledTextCtrl::GetStatus() {
1785     return SendMsg(2383, 0, 0);
1786 }
1787
1788 // Set whether the mouse is captured when its button is pressed.
1789 void wxStyledTextCtrl::SetMouseDownCaptures(bool captures) {
1790     SendMsg(2384, captures, 0);
1791 }
1792
1793 // Get whether mouse gets captured.
1794 bool wxStyledTextCtrl::GetMouseDownCaptures() {
1795     return SendMsg(2385, 0, 0) != 0;
1796 }
1797
1798 // Sets the cursor to one of the SC_CURSOR* values.
1799 void wxStyledTextCtrl::SetCursor(int cursorType) {
1800     SendMsg(2386, cursorType, 0);
1801 }
1802
1803 // Get cursor type.
1804 int wxStyledTextCtrl::GetCursor() {
1805     return SendMsg(2387, 0, 0);
1806 }
1807
1808 // Change the way control characters are displayed:
1809 // If symbol is < 32, keep the drawn way, else, use the given character.
1810 void wxStyledTextCtrl::SetControlCharSymbol(int symbol) {
1811     SendMsg(2388, symbol, 0);
1812 }
1813
1814 // Get the way control characters are displayed.
1815 int wxStyledTextCtrl::GetControlCharSymbol() {
1816     return SendMsg(2389, 0, 0);
1817 }
1818
1819 // Move to the previous change in capitalisation.
1820 void wxStyledTextCtrl::WordPartLeft() {
1821     SendMsg(2390, 0, 0);
1822 }
1823
1824 // Move to the previous change in capitalisation extending selection
1825 // to new caret position.
1826 void wxStyledTextCtrl::WordPartLeftExtend() {
1827     SendMsg(2391, 0, 0);
1828 }
1829
1830 // Move to the change next in capitalisation.
1831 void wxStyledTextCtrl::WordPartRight() {
1832     SendMsg(2392, 0, 0);
1833 }
1834
1835 // Move to the next change in capitalisation extending selection
1836 // to new caret position.
1837 void wxStyledTextCtrl::WordPartRightExtend() {
1838     SendMsg(2393, 0, 0);
1839 }
1840
1841 // Set the way the display area is determined when a particular line
1842 // is to be moved to by Find, FindNext, GotoLine, etc.
1843 void wxStyledTextCtrl::SetVisiblePolicy(int visiblePolicy, int visibleSlop) {
1844     SendMsg(2394, visiblePolicy, visibleSlop);
1845 }
1846
1847 // Delete back from the current position to the start of the line.
1848 void wxStyledTextCtrl::DelLineLeft() {
1849     SendMsg(2395, 0, 0);
1850 }
1851
1852 // Delete forwards from the current position to the end of the line.
1853 void wxStyledTextCtrl::DelLineRight() {
1854     SendMsg(2396, 0, 0);
1855 }
1856
1857 // Get and Set the xOffset (ie, horizonal scroll position).
1858 void wxStyledTextCtrl::SetXOffset(int newOffset) {
1859     SendMsg(2397, newOffset, 0);
1860 }
1861 int wxStyledTextCtrl::GetXOffset() {
1862     return SendMsg(2398, 0, 0);
1863 }
1864
1865 // Set the last x chosen value to be the caret x position
1866 void wxStyledTextCtrl::ChooseCaretX() {
1867     SendMsg(2399, 0, 0);
1868 }
1869
1870 // Set the way the caret is kept visible when going sideway.
1871 // The exclusion zone is given in pixels.
1872 void wxStyledTextCtrl::SetXCaretPolicy(int caretPolicy, int caretSlop) {
1873     SendMsg(2402, caretPolicy, caretSlop);
1874 }
1875
1876 // Set the way the line the caret is on is kept visible.
1877 // The exclusion zone is given in lines.
1878 void wxStyledTextCtrl::SetYCaretPolicy(int caretPolicy, int caretSlop) {
1879     SendMsg(2403, caretPolicy, caretSlop);
1880 }
1881
1882 // Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
1883 void wxStyledTextCtrl::SetPrintWrapMode(int mode) {
1884     SendMsg(2406, mode, 0);
1885 }
1886
1887 // Is printing line wrapped.
1888 int wxStyledTextCtrl::GetPrintWrapMode() {
1889     return SendMsg(2407, 0, 0);
1890 }
1891
1892 // Set a fore colour for active hotspots.
1893 void wxStyledTextCtrl::SetHotspotActiveForeground(bool useSetting, const wxColour& fore) {
1894     SendMsg(2410, useSetting, wxColourAsLong(fore));
1895 }
1896
1897 // Set a back colour for active hotspots.
1898 void wxStyledTextCtrl::SetHotspotActiveBackground(bool useSetting, const wxColour& back) {
1899     SendMsg(2411, useSetting, wxColourAsLong(back));
1900 }
1901
1902 // Enable / Disable underlining active hotspots.
1903 void wxStyledTextCtrl::SetHotspotActiveUnderline(bool underline) {
1904     SendMsg(2412, underline, 0);
1905 }
1906
1907 // Start notifying the container of all key presses and commands.
1908 void wxStyledTextCtrl::StartRecord() {
1909     SendMsg(3001, 0, 0);
1910 }
1911
1912 // Stop notifying the container of all key presses and commands.
1913 void wxStyledTextCtrl::StopRecord() {
1914     SendMsg(3002, 0, 0);
1915 }
1916
1917 // Set the lexing language of the document.
1918 void wxStyledTextCtrl::SetLexer(int lexer) {
1919     SendMsg(4001, lexer, 0);
1920 }
1921
1922 // Retrieve the lexing language of the document.
1923 int wxStyledTextCtrl::GetLexer() {
1924     return SendMsg(4002, 0, 0);
1925 }
1926
1927 // Colourise a segment of the document using the current lexing language.
1928 void wxStyledTextCtrl::Colourise(int start, int end) {
1929     SendMsg(4003, start, end);
1930 }
1931
1932 // Set up a value that may be used by a lexer for some optional feature.
1933 void wxStyledTextCtrl::SetProperty(const wxString& key, const wxString& value) {
1934     SendMsg(4004, (long)(const char*)wx2stc(key), (long)(const char*)wx2stc(value));
1935 }
1936
1937 // Set up the key words used by the lexer.
1938 void wxStyledTextCtrl::SetKeyWords(int keywordSet, const wxString& keyWords) {
1939     SendMsg(4005, keywordSet, (long)(const char*)wx2stc(keyWords));
1940 }
1941
1942 // Set the lexing language of the document based on string name.
1943 void wxStyledTextCtrl::SetLexerLanguage(const wxString& language) {
1944     SendMsg(4006, 0, (long)(const char*)wx2stc(language));
1945 }
1946
1947 // END of generated section
1948 //----------------------------------------------------------------------
1949
1950
1951 // Returns the line number of the line with the caret.
1952 int wxStyledTextCtrl::GetCurrentLine() {
1953     int line = LineFromPosition(GetCurrentPos());
1954     return line;
1955 }
1956
1957
1958 // Extract style settings from a spec-string which is composed of one or
1959 // more of the following comma separated elements:
1960 //
1961 //      bold                    turns on bold
1962 //      italic                  turns on italics
1963 //      fore:#RRGGBB            sets the foreground colour
1964 //      back:#RRGGBB            sets the background colour
1965 //      face:[facename]         sets the font face name to use
1966 //      size:[num]              sets the font size in points
1967 //      eol                     turns on eol filling
1968 //      underline               turns on underlining
1969 //
1970 void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
1971
1972     wxStringTokenizer tkz(spec, wxT(","));
1973     while (tkz.HasMoreTokens()) {
1974         wxString token = tkz.GetNextToken();
1975
1976         wxString option = token.BeforeFirst(':');
1977         wxString val = token.AfterFirst(':');
1978
1979         if (option == wxT("bold"))
1980             StyleSetBold(styleNum, true);
1981
1982         else if (option == wxT("italic"))
1983             StyleSetItalic(styleNum, true);
1984
1985         else if (option == wxT("underline"))
1986             StyleSetUnderline(styleNum, true);
1987
1988         else if (option == wxT("eol"))
1989             StyleSetEOLFilled(styleNum, true);
1990
1991         else if (option == wxT("size")) {
1992             long points;
1993             if (val.ToLong(&points))
1994                 StyleSetSize(styleNum, points);
1995         }
1996
1997         else if (option == wxT("face"))
1998             StyleSetFaceName(styleNum, val);
1999
2000         else if (option == wxT("fore"))
2001             StyleSetForeground(styleNum, wxColourFromSpec(val));
2002
2003         else if (option == wxT("back"))
2004             StyleSetBackground(styleNum, wxColourFromSpec(val));
2005     }
2006 }
2007
2008
2009 // Set style size, face, bold, italic, and underline attributes from
2010 // a wxFont's attributes.
2011 void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
2012     int      size     = font.GetPointSize();
2013     wxString faceName = font.GetFaceName();
2014     bool     bold     = font.GetWeight() == wxBOLD;
2015     bool     italic   = font.GetStyle() != wxNORMAL;
2016     bool     under    = font.GetUnderlined();
2017
2018     // TODO: add encoding/charset mapping
2019     StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
2020 }
2021
2022 // Set all font style attributes at once.
2023 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
2024                                         const wxString& faceName,
2025                                         bool bold, bool italic,
2026                                         bool underline) {
2027     StyleSetSize(styleNum, size);
2028     StyleSetFaceName(styleNum, faceName);
2029     StyleSetBold(styleNum, bold);
2030     StyleSetItalic(styleNum, italic);
2031     StyleSetUnderline(styleNum, underline);
2032
2033     // TODO: add encoding/charset mapping
2034 }
2035
2036
2037 // Perform one of the operations defined by the wxSTC_CMD_* constants.
2038 void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
2039     SendMsg(cmd);
2040 }
2041
2042
2043 // Set the left and right margin in the edit area, measured in pixels.
2044 void wxStyledTextCtrl::SetMargins(int left, int right) {
2045     SetMarginLeft(left);
2046     SetMarginRight(right);
2047 }
2048
2049
2050 // Retrieve the start and end positions of the current selection.
2051 void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
2052     if (startPos != NULL)
2053         *startPos = SendMsg(SCI_GETSELECTIONSTART);
2054     if (endPos != NULL)
2055         *endPos = SendMsg(SCI_GETSELECTIONEND);
2056 }
2057
2058
2059 // Retrieve the point in the window where a position is displayed.
2060 wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
2061     int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
2062     int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
2063     return wxPoint(x, y);
2064 }
2065
2066 // Scroll enough to make the given line visible
2067 void wxStyledTextCtrl::ScrollToLine(int line) {
2068     m_swx->DoScrollToLine(line);
2069 }
2070
2071
2072 // Scroll enough to make the given column visible
2073 void wxStyledTextCtrl::ScrollToColumn(int column) {
2074     m_swx->DoScrollToColumn(column);
2075 }
2076
2077
2078
2079 //----------------------------------------------------------------------
2080 // Event handlers
2081
2082 void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
2083     wxPaintDC dc(this);
2084     m_swx->DoPaint(&dc, GetUpdateRegion().GetBox());
2085 }
2086
2087 void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
2088     if (evt.GetOrientation() == wxHORIZONTAL)
2089         m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
2090     else
2091         m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
2092 }
2093
2094 void wxStyledTextCtrl::OnScroll(wxScrollEvent& evt) {
2095     wxScrollBar* sb = wxDynamicCast(evt.GetEventObject(), wxScrollBar);
2096     if (sb) {
2097         if (sb->IsVertical())
2098             m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
2099         else
2100             m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
2101     }
2102 }
2103
2104 void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
2105     wxSize sz = GetClientSize();
2106     m_swx->DoSize(sz.x, sz.y);
2107 }
2108
2109 void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
2110     SetFocus();
2111     wxPoint pt = evt.GetPosition();
2112     m_swx->DoLeftButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
2113                       evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
2114 }
2115
2116 void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
2117     wxPoint pt = evt.GetPosition();
2118     m_swx->DoLeftButtonMove(Point(pt.x, pt.y));
2119 }
2120
2121 void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
2122     wxPoint pt = evt.GetPosition();
2123     m_swx->DoLeftButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
2124                       evt.ControlDown());
2125 }
2126
2127
2128 void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
2129     wxPoint pt = evt.GetPosition();
2130     m_swx->DoContextMenu(Point(pt.x, pt.y));
2131 }
2132
2133
2134 void wxStyledTextCtrl::OnMouseMiddleUp(wxMouseEvent& evt) {
2135     wxPoint pt = evt.GetPosition();
2136     m_swx->DoMiddleButtonUp(Point(pt.x, pt.y));
2137 }
2138
2139 void wxStyledTextCtrl::OnContextMenu(wxContextMenuEvent& evt) {
2140     wxPoint pt = evt.GetPosition();
2141     ScreenToClient(&pt.x, &pt.y);
2142     m_swx->DoContextMenu(Point(pt.x, pt.y));
2143 }
2144
2145
2146 void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
2147     m_swx->DoMouseWheel(evt.GetWheelRotation(),
2148                         evt.GetWheelDelta(),
2149                         evt.GetLinesPerAction(),
2150                         evt.ControlDown(),
2151                         evt.IsPageScroll());
2152 }
2153
2154
2155 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
2156     // On (some?) non-US keyboards the AltGr key is required to enter some
2157     // common characters.  It comes to us as both Alt and Ctrl down so we need
2158     // to let the char through in that case, otherwise if only ctrl or only
2159     // alt let's skip it.
2160     bool ctrl = evt.ControlDown();
2161     bool alt  = evt.AltDown();
2162     bool skip = ((ctrl || alt) && ! (ctrl && alt));
2163
2164     int key = evt.GetKeyCode();
2165
2166 //     printf("OnChar key:%d  consumed:%d  ctrl:%d  alt:%d  skip:%d\n",
2167 //            key, m_lastKeyDownConsumed, ctrl, alt, skip);
2168
2169     if ( (key <= WXK_START || key > WXK_NUMPAD_DIVIDE) &&
2170          !m_lastKeyDownConsumed && !skip) {
2171         m_swx->DoAddChar(key);
2172         return;
2173     }
2174     evt.Skip();
2175 }
2176
2177
2178 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
2179     int key = evt.GetKeyCode();
2180     bool shift = evt.ShiftDown(),
2181          ctrl  = evt.ControlDown(),
2182          alt   = evt.AltDown();
2183
2184     int processed = m_swx->DoKeyDown(key, shift, ctrl, alt, &m_lastKeyDownConsumed);
2185
2186 //     printf("KeyDn  key:%d  shift:%d  ctrl:%d  alt:%d  processed:%d  consumed:%d\n",
2187 //            key, shift, ctrl, alt, processed, m_lastKeyDownConsumed);
2188
2189     if (!processed && !m_lastKeyDownConsumed)
2190         evt.Skip();
2191 }
2192
2193
2194 void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
2195     m_swx->DoLoseFocus();
2196 }
2197
2198
2199 void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
2200     m_swx->DoGainFocus();
2201 }
2202
2203
2204 void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
2205     m_swx->DoSysColourChange();
2206 }
2207
2208
2209 void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
2210     // do nothing to help avoid flashing
2211 }
2212
2213
2214
2215 void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
2216     m_swx->DoCommand(evt.GetId());
2217 }
2218
2219
2220 void wxStyledTextCtrl::OnListBox(wxCommandEvent& evt) {
2221     m_swx->DoOnListBox();
2222 }
2223
2224
2225 //----------------------------------------------------------------------
2226 // Turn notifications from Scintilla into events
2227
2228
2229 void wxStyledTextCtrl::NotifyChange() {
2230     wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
2231     evt.SetEventObject(this);
2232     GetEventHandler()->ProcessEvent(evt);
2233 }
2234
2235
2236 static void SetEventText(wxStyledTextEvent& evt, const char* text,
2237                          size_t length) {
2238     if(!text) return;
2239
2240     // The unicode conversion MUST have a null byte to terminate the
2241     // string so move it into a buffer first and give it one.
2242     wxMemoryBuffer buf(length+1);
2243     buf.AppendData((void*)text, length);
2244     buf.AppendByte(0);
2245     evt.SetText(stc2wx(buf));
2246 }
2247
2248
2249 void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
2250     SCNotification& scn = *_scn;
2251     wxStyledTextEvent evt(0, GetId());
2252
2253     evt.SetEventObject(this);
2254     evt.SetPosition(scn.position);
2255     evt.SetKey(scn.ch);
2256     evt.SetModifiers(scn.modifiers);
2257
2258     switch (scn.nmhdr.code) {
2259     case SCN_STYLENEEDED:
2260         evt.SetEventType(wxEVT_STC_STYLENEEDED);
2261         break;
2262
2263     case SCN_CHARADDED:
2264         evt.SetEventType(wxEVT_STC_CHARADDED);
2265         break;
2266
2267     case SCN_SAVEPOINTREACHED:
2268         evt.SetEventType(wxEVT_STC_SAVEPOINTREACHED);
2269         break;
2270
2271     case SCN_SAVEPOINTLEFT:
2272         evt.SetEventType(wxEVT_STC_SAVEPOINTLEFT);
2273         break;
2274
2275     case SCN_MODIFYATTEMPTRO:
2276         evt.SetEventType(wxEVT_STC_ROMODIFYATTEMPT);
2277         break;
2278
2279     case SCN_KEY:
2280         evt.SetEventType(wxEVT_STC_KEY);
2281         break;
2282
2283     case SCN_DOUBLECLICK:
2284         evt.SetEventType(wxEVT_STC_DOUBLECLICK);
2285         break;
2286
2287     case SCN_UPDATEUI:
2288         evt.SetEventType(wxEVT_STC_UPDATEUI);
2289         break;
2290
2291     case SCN_MODIFIED:
2292         evt.SetEventType(wxEVT_STC_MODIFIED);
2293         evt.SetModificationType(scn.modificationType);
2294         SetEventText(evt, scn.text, scn.length);
2295         evt.SetLength(scn.length);
2296         evt.SetLinesAdded(scn.linesAdded);
2297         evt.SetLine(scn.line);
2298         evt.SetFoldLevelNow(scn.foldLevelNow);
2299         evt.SetFoldLevelPrev(scn.foldLevelPrev);
2300         break;
2301
2302     case SCN_MACRORECORD:
2303         evt.SetEventType(wxEVT_STC_MACRORECORD);
2304         evt.SetMessage(scn.message);
2305         evt.SetWParam(scn.wParam);
2306         evt.SetLParam(scn.lParam);
2307         break;
2308
2309     case SCN_MARGINCLICK:
2310         evt.SetEventType(wxEVT_STC_MARGINCLICK);
2311         evt.SetMargin(scn.margin);
2312         break;
2313
2314     case SCN_NEEDSHOWN:
2315         evt.SetEventType(wxEVT_STC_NEEDSHOWN);
2316         evt.SetLength(scn.length);
2317         break;
2318
2319     case SCN_PAINTED:
2320         evt.SetEventType(wxEVT_STC_PAINTED);
2321         break;
2322
2323     case SCN_USERLISTSELECTION:
2324         evt.SetEventType(wxEVT_STC_USERLISTSELECTION);
2325         evt.SetListType(scn.listType);
2326         SetEventText(evt, scn.text, strlen(scn.text));
2327         break;
2328
2329     case SCN_URIDROPPED:
2330         evt.SetEventType(wxEVT_STC_URIDROPPED);
2331         SetEventText(evt, scn.text, strlen(scn.text));
2332         break;
2333
2334     case SCN_DWELLSTART:
2335         evt.SetEventType(wxEVT_STC_DWELLSTART);
2336         evt.SetX(scn.x);
2337         evt.SetY(scn.y);
2338         break;
2339
2340     case SCN_DWELLEND:
2341         evt.SetEventType(wxEVT_STC_DWELLEND);
2342         evt.SetX(scn.x);
2343         evt.SetY(scn.y);
2344         break;
2345
2346     case SCN_ZOOM:
2347         evt.SetEventType(wxEVT_STC_ZOOM);
2348         break;
2349
2350     case SCN_HOTSPOTCLICK:
2351         evt.SetEventType(wxEVT_STC_HOTSPOT_CLICK);
2352         break;
2353
2354     case SCN_HOTSPOTDOUBLECLICK:
2355         evt.SetEventType(wxEVT_STC_HOTSPOT_DCLICK);
2356         break;
2357
2358     case SCN_CALLTIPCLICK:
2359         evt.SetEventType(wxEVT_STC_CALLTIP_CLICK);
2360         break;
2361
2362     default:
2363         return;
2364     }
2365
2366     GetEventHandler()->ProcessEvent(evt);
2367 }
2368
2369
2370 //----------------------------------------------------------------------
2371 //----------------------------------------------------------------------
2372 //----------------------------------------------------------------------
2373
2374 wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
2375     : wxCommandEvent(commandType, id)
2376 {
2377     m_position = 0;
2378     m_key = 0;
2379     m_modifiers = 0;
2380     m_modificationType = 0;
2381     m_length = 0;
2382     m_linesAdded = 0;
2383     m_line = 0;
2384     m_foldLevelNow = 0;
2385     m_foldLevelPrev = 0;
2386     m_margin = 0;
2387     m_message = 0;
2388     m_wParam = 0;
2389     m_lParam = 0;
2390     m_listType = 0;
2391     m_x = 0;
2392     m_y = 0;
2393     m_dragAllowMove = FALSE;
2394 #if wxUSE_DRAG_AND_DROP
2395     m_dragResult = wxDragNone;
2396 #endif
2397 }
2398
2399 bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
2400 bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
2401 bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
2402
2403
2404 wxStyledTextEvent::wxStyledTextEvent(const wxStyledTextEvent& event):
2405   wxCommandEvent(event)
2406 {
2407     m_position =      event.m_position;
2408     m_key =           event.m_key;
2409     m_modifiers =     event.m_modifiers;
2410     m_modificationType = event.m_modificationType;
2411     m_text =          event.m_text;
2412     m_length =        event.m_length;
2413     m_linesAdded =    event.m_linesAdded;
2414     m_line =          event.m_line;
2415     m_foldLevelNow =  event.m_foldLevelNow;
2416     m_foldLevelPrev = event.m_foldLevelPrev;
2417
2418     m_margin =        event.m_margin;
2419
2420     m_message =       event.m_message;
2421     m_wParam =        event.m_wParam;
2422     m_lParam =        event.m_lParam;
2423
2424     m_listType =     event.m_listType;
2425     m_x =            event.m_x;
2426     m_y =            event.m_y;
2427
2428     m_dragText =     event.m_dragText;
2429     m_dragAllowMove =event.m_dragAllowMove;
2430 #if wxUSE_DRAG_AND_DROP
2431     m_dragResult =   event.m_dragResult;
2432 #endif
2433 }
2434
2435 //----------------------------------------------------------------------
2436 //----------------------------------------------------------------------
2437
2438
2439
2440
2441
2442
2443
2444
2445