src/stc/stc.cpp.in

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        stc.cpp
   3 // Purpose:     A wxWidgets 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 #include <wx/file.h>
  28
  29
  30 //----------------------------------------------------------------------
  31
  32 const wxChar* wxSTCNameStr = wxT("stcwindow");
  33
  34 #ifdef MAKELONG
  35 #undef MAKELONG
  36 #endif
  37
  38 #define MAKELONG(a, b) ((a) | ((b) << 16))
  39
  40
  41 static long wxColourAsLong(const wxColour& co) {
  42     return (((long)co.Blue()  << 16) |
  43             ((long)co.Green() <<  8) |
  44             ((long)co.Red()));
  45 }
  46
  47 static wxColour wxColourFromLong(long c) {
  48     wxColour clr;
  49     clr.Set((unsigned char)(c & 0xff),
  50             (unsigned char)((c >> 8) & 0xff),
  51             (unsigned char)((c >> 16) & 0xff));
  52     return clr;
  53 }
  54
  55
  56 static wxColour wxColourFromSpec(const wxString& spec) {
  57     // spec should be a colour name or "#RRGGBB"
  58     if (spec.GetChar(0) == wxT('#')) {
  59
  60         long red, green, blue;
  61         red = green = blue = 0;
  62         spec.Mid(1,2).ToLong(&red,   16);
  63         spec.Mid(3,2).ToLong(&green, 16);
  64         spec.Mid(5,2).ToLong(&blue,  16);
  65         return wxColour((unsigned char)red,
  66                         (unsigned char)green,
  67                         (unsigned char)blue);
  68     }
  69     else
  70         return wxColour(spec);
  71 }
  72
  73 //----------------------------------------------------------------------
  74
  75 DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
  76 DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
  77 DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
  78 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
  79 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
  80 DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
  81 DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
  82 DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
  83 DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
  84 DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
  85 DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
  86 DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
  87 DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
  88 DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
  89 DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
  90 DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
  91 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLSTART )
  92 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLEND )
  93 DEFINE_EVENT_TYPE( wxEVT_STC_START_DRAG )
  94 DEFINE_EVENT_TYPE( wxEVT_STC_DRAG_OVER )
  95 DEFINE_EVENT_TYPE( wxEVT_STC_DO_DROP )
  96 DEFINE_EVENT_TYPE( wxEVT_STC_ZOOM )
  97 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_CLICK )
  98 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_DCLICK )
  99 DEFINE_EVENT_TYPE( wxEVT_STC_CALLTIP_CLICK )
 100
 101
 102
 103 BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
 104     EVT_PAINT                   (wxStyledTextCtrl::OnPaint)
 105     EVT_SCROLLWIN               (wxStyledTextCtrl::OnScrollWin)
 106     EVT_SCROLL                  (wxStyledTextCtrl::OnScroll)
 107     EVT_SIZE                    (wxStyledTextCtrl::OnSize)
 108     EVT_LEFT_DOWN               (wxStyledTextCtrl::OnMouseLeftDown)
 109     // Let Scintilla see the double click as a second click
 110     EVT_LEFT_DCLICK             (wxStyledTextCtrl::OnMouseLeftDown)
 111     EVT_MOTION                  (wxStyledTextCtrl::OnMouseMove)
 112     EVT_LEFT_UP                 (wxStyledTextCtrl::OnMouseLeftUp)
 113 #if defined(__WXGTK__) || defined(__WXMAC__)
 114     EVT_RIGHT_UP                (wxStyledTextCtrl::OnMouseRightUp)
 115 #else
 116     EVT_CONTEXT_MENU            (wxStyledTextCtrl::OnContextMenu)
 117 #endif
 118     EVT_MOUSEWHEEL              (wxStyledTextCtrl::OnMouseWheel)
 119     EVT_MIDDLE_UP               (wxStyledTextCtrl::OnMouseMiddleUp)
 120     EVT_CHAR                    (wxStyledTextCtrl::OnChar)
 121     EVT_KEY_DOWN                (wxStyledTextCtrl::OnKeyDown)
 122     EVT_KILL_FOCUS              (wxStyledTextCtrl::OnLoseFocus)
 123     EVT_SET_FOCUS               (wxStyledTextCtrl::OnGainFocus)
 124     EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
 125     EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
 126     EVT_MENU_RANGE              (10, 16, wxStyledTextCtrl::OnMenu)
 127     EVT_LISTBOX_DCLICK          (wxID_ANY, wxStyledTextCtrl::OnListBox)
 128 END_EVENT_TABLE()
 129
 130
 131 IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
 132 IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
 133
 134 #ifdef LINK_LEXERS
 135 // forces the linking of the lexer modules
 136 int Scintilla_LinkLexers();
 137 #endif
 138
 139 //----------------------------------------------------------------------
 140 // Constructor and Destructor
 141
 142 wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
 143                                    wxWindowID id,
 144                                    const wxPoint& pos,
 145                                    const wxSize& size,
 146                                    long style,
 147                                    const wxString& name)
 148 {
 149     m_swx = NULL;
 150     Create(parent, id, pos, size, style, name);
 151 }
 152
 153
 154 void wxStyledTextCtrl::Create(wxWindow *parent,
 155                                    wxWindowID id,
 156                                    const wxPoint& pos,
 157                                    const wxSize& size,
 158                                    long style,
 159                                    const wxString& name)
 160 {
 161 #ifdef __WXMAC__
 162     style |= wxVSCROLL | wxHSCROLL;
 163 #endif
 164     wxControl::Create(parent, id, pos, size,
 165               style | wxWANTS_CHARS | wxCLIP_CHILDREN,
 166               wxDefaultValidator, name);
 167
 168 #ifdef LINK_LEXERS
 169     Scintilla_LinkLexers();
 170 #endif
 171     m_swx = new ScintillaWX(this);
 172     m_stopWatch.Start();
 173     m_lastKeyDownConsumed = false;
 174     m_vScrollBar = NULL;
 175     m_hScrollBar = NULL;
 176 #if wxUSE_UNICODE
 177     // Put Scintilla into unicode (UTF-8) mode
 178     SetCodePage(wxSTC_CP_UTF8);
 179 #endif
 180
 181     SetBestFittingSize(size);
 182 }
 183
 184
 185 wxStyledTextCtrl::~wxStyledTextCtrl() {
 186     delete m_swx;
 187 }
 188
 189
 190 //----------------------------------------------------------------------
 191
 192 long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
 193
 194     return m_swx->WndProc(msg, wp, lp);
 195 }
 196
 197 //----------------------------------------------------------------------
 198
 199 // Set the vertical scrollbar to use instead of the ont that's built-in.
 200 void wxStyledTextCtrl::SetVScrollBar(wxScrollBar* bar)  {
 201     m_vScrollBar = bar;
 202     if (bar != NULL) {
 203         // ensure that the built-in scrollbar is not visible
 204         SetScrollbar(wxVERTICAL, 0, 0, 0);
 205     }
 206 }
 207
 208
 209 // Set the horizontal scrollbar to use instead of the ont that's built-in.
 210 void wxStyledTextCtrl::SetHScrollBar(wxScrollBar* bar)  {
 211     m_hScrollBar = bar;
 212     if (bar != NULL) {
 213         // ensure that the built-in scrollbar is not visible
 214         SetScrollbar(wxHORIZONTAL, 0, 0, 0);
 215     }
 216 }
 217
 218 //----------------------------------------------------------------------
 219 // BEGIN generated section.  The following code is automatically generated
 220 //       by gen_iface.py from the contents of Scintilla.iface.  Do not edit
 221 //       this file.  Edit stc.cpp.in or gen_iface.py instead and regenerate.
 222
 223 %(METHOD_IMPS)s
 224
 225 // END of generated section
 226 //----------------------------------------------------------------------
 227
 228
 229 // Returns the line number of the line with the caret.
 230 int wxStyledTextCtrl::GetCurrentLine() {
 231     int line = LineFromPosition(GetCurrentPos());
 232     return line;
 233 }
 234
 235
 236 // Extract style settings from a spec-string which is composed of one or
 237 // more of the following comma separated elements:
 238 //
 239 //      bold                    turns on bold
 240 //      italic                  turns on italics
 241 //      fore:[name or #RRGGBB]  sets the foreground colour
 242 //      back:[name or #RRGGBB]  sets the background colour
 243 //      face:[facename]         sets the font face name to use
 244 //      size:[num]              sets the font size in points
 245 //      eol                     turns on eol filling
 246 //      underline               turns on underlining
 247 //
 248 void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
 249
 250     wxStringTokenizer tkz(spec, wxT(","));
 251     while (tkz.HasMoreTokens()) {
 252         wxString token = tkz.GetNextToken();
 253
 254         wxString option = token.BeforeFirst(':');
 255         wxString val = token.AfterFirst(':');
 256
 257         if (option == wxT("bold"))
 258             StyleSetBold(styleNum, true);
 259
 260         else if (option == wxT("italic"))
 261             StyleSetItalic(styleNum, true);
 262
 263         else if (option == wxT("underline"))
 264             StyleSetUnderline(styleNum, true);
 265
 266         else if (option == wxT("eol"))
 267             StyleSetEOLFilled(styleNum, true);
 268
 269         else if (option == wxT("size")) {
 270             long points;
 271             if (val.ToLong(&points))
 272                 StyleSetSize(styleNum, points);
 273         }
 274
 275         else if (option == wxT("face"))
 276             StyleSetFaceName(styleNum, val);
 277
 278         else if (option == wxT("fore"))
 279             StyleSetForeground(styleNum, wxColourFromSpec(val));
 280
 281         else if (option == wxT("back"))
 282             StyleSetBackground(styleNum, wxColourFromSpec(val));
 283     }
 284 }
 285
 286
 287 // Set style size, face, bold, italic, and underline attributes from
 288 // a wxFont's attributes.
 289 void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
 290 #ifdef __WXGTK__
 291     // Ensure that the native font is initialized
 292     int x, y;
 293     GetTextExtent(wxT("X"), &x, &y, NULL, NULL, &font);
 294 #endif
 295     int      size     = font.GetPointSize();
 296     wxString faceName = font.GetFaceName();
 297     bool     bold     = font.GetWeight() == wxBOLD;
 298     bool     italic   = font.GetStyle() != wxNORMAL;
 299     bool     under    = font.GetUnderlined();
 300
 301     // TODO: add encoding/charset mapping
 302     StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
 303 }
 304
 305 // Set all font style attributes at once.
 306 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
 307                                         const wxString& faceName,
 308                                         bool bold, bool italic,
 309                                         bool underline) {
 310     StyleSetSize(styleNum, size);
 311     StyleSetFaceName(styleNum, faceName);
 312     StyleSetBold(styleNum, bold);
 313     StyleSetItalic(styleNum, italic);
 314     StyleSetUnderline(styleNum, underline);
 315
 316     // TODO: add encoding/charset mapping
 317 }
 318
 319
 320 // Perform one of the operations defined by the wxSTC_CMD_* constants.
 321 void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
 322     SendMsg(cmd);
 323 }
 324
 325
 326 // Set the left and right margin in the edit area, measured in pixels.
 327 void wxStyledTextCtrl::SetMargins(int left, int right) {
 328     SetMarginLeft(left);
 329     SetMarginRight(right);
 330 }
 331
 332
 333 // Retrieve the start and end positions of the current selection.
 334 void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
 335     if (startPos != NULL)
 336         *startPos = SendMsg(SCI_GETSELECTIONSTART);
 337     if (endPos != NULL)
 338         *endPos = SendMsg(SCI_GETSELECTIONEND);
 339 }
 340
 341
 342 // Retrieve the point in the window where a position is displayed.
 343 wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
 344     int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
 345     int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
 346     return wxPoint(x, y);
 347 }
 348
 349 // Scroll enough to make the given line visible
 350 void wxStyledTextCtrl::ScrollToLine(int line) {
 351     m_swx->DoScrollToLine(line);
 352 }
 353
 354
 355 // Scroll enough to make the given column visible
 356 void wxStyledTextCtrl::ScrollToColumn(int column) {
 357     m_swx->DoScrollToColumn(column);
 358 }
 359
 360
 361 bool wxStyledTextCtrl::SaveFile(const wxString& filename)
 362 {
 363     wxFile file(filename, wxFile::write);
 364
 365     if (!file.IsOpened())
 366         return false;
 367
 368     bool success = file.Write(GetText(), *wxConvCurrent);
 369
 370     if (success)
 371         SetSavePoint();
 372
 373     return success;
 374 }
 375
 376 bool wxStyledTextCtrl::LoadFile(const wxString& filename)
 377 {
 378     bool success = false;
 379     wxFile file(filename, wxFile::read);
 380
 381     if (file.IsOpened())
 382     {
 383         wxString contents;
 384         // get the file size (assume it is not huge file...)
 385         ssize_t len = (ssize_t)file.Length();
 386
 387         if (len > 0)
 388         {
 389 #if wxUSE_UNICODE
 390             wxMemoryBuffer buffer(len+1);
 391             success = (file.Read(buffer.GetData(), len) == len);
 392             if (success) {
 393                 ((char*)buffer.GetData())[len] = 0;
 394                 contents = wxString(buffer, *wxConvCurrent, len);
 395             }
 396 #else
 397             wxString buffer;
 398             success = (file.Read(wxStringBuffer(buffer, len), len) == len);
 399             contents = buffer;
 400 #endif
 401         }
 402         else
 403         {
 404             if (len == 0)
 405                 success = true;  // empty file is ok
 406             else
 407                 success = false; // len == wxInvalidOffset
 408         }
 409
 410         if (success)
 411         {
 412             SetText(contents);
 413             EmptyUndoBuffer();
 414             SetSavePoint();
 415         }
 416     }
 417
 418     return success;
 419 }
 420
 421
 422 #if wxUSE_DRAG_AND_DROP
 423 wxDragResult wxStyledTextCtrl::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
 424         return m_swx->DoDragOver(x, y, def);
 425 }
 426
 427
 428 bool wxStyledTextCtrl::DoDropText(long x, long y, const wxString& data) {
 429     return m_swx->DoDropText(x, y, data);
 430 }
 431 #endif
 432
 433
 434 void wxStyledTextCtrl::SetUseAntiAliasing(bool useAA) {
 435     m_swx->SetUseAntiAliasing(useAA);
 436 }
 437
 438 bool wxStyledTextCtrl::GetUseAntiAliasing() {
 439     return m_swx->GetUseAntiAliasing();
 440 }
 441
 442 //----------------------------------------------------------------------
 443 // Event handlers
 444
 445 void wxStyledTextCtrl::OnPaint(wxPaintEvent& WXUNUSED(evt)) {
 446     wxPaintDC dc(this);
 447     m_swx->DoPaint(&dc, GetUpdateRegion().GetBox());
 448 }
 449
 450 void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
 451     if (evt.GetOrientation() == wxHORIZONTAL)
 452         m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
 453     else
 454         m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
 455 }
 456
 457 void wxStyledTextCtrl::OnScroll(wxScrollEvent& evt) {
 458     wxScrollBar* sb = wxDynamicCast(evt.GetEventObject(), wxScrollBar);
 459     if (sb) {
 460         if (sb->IsVertical())
 461             m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
 462         else
 463             m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
 464     }
 465 }
 466
 467 void wxStyledTextCtrl::OnSize(wxSizeEvent& WXUNUSED(evt)) {
 468     if (m_swx) {
 469         wxSize sz = GetClientSize();
 470         m_swx->DoSize(sz.x, sz.y);
 471     }
 472 }
 473
 474 void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
 475     SetFocus();
 476     wxPoint pt = evt.GetPosition();
 477     m_swx->DoLeftButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
 478                       evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
 479 }
 480
 481 void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
 482     wxPoint pt = evt.GetPosition();
 483     m_swx->DoLeftButtonMove(Point(pt.x, pt.y));
 484 }
 485
 486 void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
 487     wxPoint pt = evt.GetPosition();
 488     m_swx->DoLeftButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
 489                       evt.ControlDown());
 490 }
 491
 492
 493 void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
 494     wxPoint pt = evt.GetPosition();
 495     m_swx->DoContextMenu(Point(pt.x, pt.y));
 496 }
 497
 498
 499 void wxStyledTextCtrl::OnMouseMiddleUp(wxMouseEvent& evt) {
 500     wxPoint pt = evt.GetPosition();
 501     m_swx->DoMiddleButtonUp(Point(pt.x, pt.y));
 502 }
 503
 504 void wxStyledTextCtrl::OnContextMenu(wxContextMenuEvent& evt) {
 505     wxPoint pt = evt.GetPosition();
 506     ScreenToClient(&pt.x, &pt.y);
 507     /*
 508       Show context menu at event point if it's within the window,
 509       or at caret location if not
 510     */
 511     wxHitTest ht = this->HitTest(pt);
 512     if (ht != wxHT_WINDOW_INSIDE) {
 513         pt = this->PointFromPosition(this->GetCurrentPos());
 514     }
 515     m_swx->DoContextMenu(Point(pt.x, pt.y));
 516 }
 517
 518
 519 void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
 520     m_swx->DoMouseWheel(evt.GetWheelRotation(),
 521                         evt.GetWheelDelta(),
 522                         evt.GetLinesPerAction(),
 523                         evt.ControlDown(),
 524                         evt.IsPageScroll());
 525 }
 526
 527
 528 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
 529     // On (some?) non-US PC keyboards the AltGr key is required to enter some
 530     // common characters.  It comes to us as both Alt and Ctrl down so we need
 531     // to let the char through in that case, otherwise if only ctrl or only
 532     // alt let's skip it.
 533     bool ctrl = evt.ControlDown();
 534 #ifdef __WXMAC__
 535     // On the Mac the Alt key is just a modifier key (like Shift) so we need
 536     // to allow the char events to be processed when Alt is pressed.
 537     // TODO:  Should we check MetaDown instead in this case?
 538     bool alt = false;
 539 #else
 540     bool alt  = evt.AltDown();
 541 #endif
 542     bool skip = ((ctrl || alt) && ! (ctrl && alt));
 543
 544     if (!m_lastKeyDownConsumed && !skip) {
 545 #if wxUSE_UNICODE
 546         int key = evt.GetUnicodeKey();
 547         bool keyOk = true;
 548
 549         // if the unicode key code is not really a unicode character (it may
 550         // be a function key or etc., the platforms appear to always give us a
 551         // small value in this case) then fallback to the ascii key code but
 552         // don't do anything for function keys or etc.
 553         if (key <= 255) {
 554             key = evt.GetKeyCode();
 555             keyOk = (key <= 255);
 556         }
 557         if (keyOk) {
 558             m_swx->DoAddChar(key);
 559             return;
 560         }
 561 #else
 562         int key = evt.GetKeyCode();
 563         if (key <= WXK_START || key > WXK_COMMAND) {
 564             m_swx->DoAddChar(key);
 565             return;
 566         }
 567 #endif
 568     }
 569
 570     evt.Skip();
 571 }
 572
 573
 574 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
 575     int processed = m_swx->DoKeyDown(evt, &m_lastKeyDownConsumed);
 576     if (!processed && !m_lastKeyDownConsumed)
 577         evt.Skip();
 578 }
 579
 580
 581 void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
 582     m_swx->DoLoseFocus();
 583     evt.Skip();
 584 }
 585
 586
 587 void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
 588     m_swx->DoGainFocus();
 589     evt.Skip();
 590 }
 591
 592
 593 void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(evt)) {
 594     m_swx->DoSysColourChange();
 595 }
 596
 597
 598 void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt)) {
 599     // do nothing to help avoid flashing
 600 }
 601
 602
 603
 604 void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
 605     m_swx->DoCommand(evt.GetId());
 606 }
 607
 608
 609 void wxStyledTextCtrl::OnListBox(wxCommandEvent& WXUNUSED(evt)) {
 610     m_swx->DoOnListBox();
 611 }
 612
 613
 614 void wxStyledTextCtrl::OnIdle(wxIdleEvent& evt) {
 615     m_swx->DoOnIdle(evt);
 616 }
 617
 618
 619 wxSize wxStyledTextCtrl::DoGetBestSize() const
 620 {
 621     // What would be the best size for a wxSTC?
 622     // Just give a reasonable minimum until something else can be figured out.
 623     return wxSize(200,100);
 624 }
 625
 626
 627 //----------------------------------------------------------------------
 628 // Turn notifications from Scintilla into events
 629
 630
 631 void wxStyledTextCtrl::NotifyChange() {
 632     wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
 633     evt.SetEventObject(this);
 634     GetEventHandler()->ProcessEvent(evt);
 635 }
 636
 637
 638 static void SetEventText(wxStyledTextEvent& evt, const char* text,
 639                          size_t length) {
 640     if(!text) return;
 641
 642     // The unicode conversion MUST have a null byte to terminate the
 643     // string so move it into a buffer first and give it one.
 644     wxMemoryBuffer buf(length+1);
 645     buf.AppendData((void*)text, length);
 646     buf.AppendByte(0);
 647     evt.SetText(stc2wx(buf));
 648 }
 649
 650
 651 void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
 652     SCNotification& scn = *_scn;
 653     wxStyledTextEvent evt(0, GetId());
 654
 655     evt.SetEventObject(this);
 656     evt.SetPosition(scn.position);
 657     evt.SetKey(scn.ch);
 658     evt.SetModifiers(scn.modifiers);
 659
 660     switch (scn.nmhdr.code) {
 661     case SCN_STYLENEEDED:
 662         evt.SetEventType(wxEVT_STC_STYLENEEDED);
 663         break;
 664
 665     case SCN_CHARADDED:
 666         evt.SetEventType(wxEVT_STC_CHARADDED);
 667         break;
 668
 669     case SCN_SAVEPOINTREACHED:
 670         evt.SetEventType(wxEVT_STC_SAVEPOINTREACHED);
 671         break;
 672
 673     case SCN_SAVEPOINTLEFT:
 674         evt.SetEventType(wxEVT_STC_SAVEPOINTLEFT);
 675         break;
 676
 677     case SCN_MODIFYATTEMPTRO:
 678         evt.SetEventType(wxEVT_STC_ROMODIFYATTEMPT);
 679         break;
 680
 681     case SCN_KEY:
 682         evt.SetEventType(wxEVT_STC_KEY);
 683         break;
 684
 685     case SCN_DOUBLECLICK:
 686         evt.SetEventType(wxEVT_STC_DOUBLECLICK);
 687         break;
 688
 689     case SCN_UPDATEUI:
 690         evt.SetEventType(wxEVT_STC_UPDATEUI);
 691         break;
 692
 693     case SCN_MODIFIED:
 694         evt.SetEventType(wxEVT_STC_MODIFIED);
 695         evt.SetModificationType(scn.modificationType);
 696         SetEventText(evt, scn.text, scn.length);
 697         evt.SetLength(scn.length);
 698         evt.SetLinesAdded(scn.linesAdded);
 699         evt.SetLine(scn.line);
 700         evt.SetFoldLevelNow(scn.foldLevelNow);
 701         evt.SetFoldLevelPrev(scn.foldLevelPrev);
 702         break;
 703
 704     case SCN_MACRORECORD:
 705         evt.SetEventType(wxEVT_STC_MACRORECORD);
 706         evt.SetMessage(scn.message);
 707         evt.SetWParam(scn.wParam);
 708         evt.SetLParam(scn.lParam);
 709         break;
 710
 711     case SCN_MARGINCLICK:
 712         evt.SetEventType(wxEVT_STC_MARGINCLICK);
 713         evt.SetMargin(scn.margin);
 714         break;
 715
 716     case SCN_NEEDSHOWN:
 717         evt.SetEventType(wxEVT_STC_NEEDSHOWN);
 718         evt.SetLength(scn.length);
 719         break;
 720
 721     case SCN_PAINTED:
 722         evt.SetEventType(wxEVT_STC_PAINTED);
 723         break;
 724
 725     case SCN_USERLISTSELECTION:
 726         evt.SetEventType(wxEVT_STC_USERLISTSELECTION);
 727         evt.SetListType(scn.listType);
 728         SetEventText(evt, scn.text, strlen(scn.text));
 729         break;
 730
 731     case SCN_URIDROPPED:
 732         evt.SetEventType(wxEVT_STC_URIDROPPED);
 733         SetEventText(evt, scn.text, strlen(scn.text));
 734         break;
 735
 736     case SCN_DWELLSTART:
 737         evt.SetEventType(wxEVT_STC_DWELLSTART);
 738         evt.SetX(scn.x);
 739         evt.SetY(scn.y);
 740         break;
 741
 742     case SCN_DWELLEND:
 743         evt.SetEventType(wxEVT_STC_DWELLEND);
 744         evt.SetX(scn.x);
 745         evt.SetY(scn.y);
 746         break;
 747
 748     case SCN_ZOOM:
 749         evt.SetEventType(wxEVT_STC_ZOOM);
 750         break;
 751
 752     case SCN_HOTSPOTCLICK:
 753         evt.SetEventType(wxEVT_STC_HOTSPOT_CLICK);
 754         break;
 755
 756     case SCN_HOTSPOTDOUBLECLICK:
 757         evt.SetEventType(wxEVT_STC_HOTSPOT_DCLICK);
 758         break;
 759
 760     case SCN_CALLTIPCLICK:
 761         evt.SetEventType(wxEVT_STC_CALLTIP_CLICK);
 762         break;
 763
 764     default:
 765         return;
 766     }
 767
 768     GetEventHandler()->ProcessEvent(evt);
 769 }
 770
 771
 772 //----------------------------------------------------------------------
 773 //----------------------------------------------------------------------
 774 //----------------------------------------------------------------------
 775
 776 wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
 777     : wxCommandEvent(commandType, id)
 778 {
 779     m_position = 0;
 780     m_key = 0;
 781     m_modifiers = 0;
 782     m_modificationType = 0;
 783     m_length = 0;
 784     m_linesAdded = 0;
 785     m_line = 0;
 786     m_foldLevelNow = 0;
 787     m_foldLevelPrev = 0;
 788     m_margin = 0;
 789     m_message = 0;
 790     m_wParam = 0;
 791     m_lParam = 0;
 792     m_listType = 0;
 793     m_x = 0;
 794     m_y = 0;
 795     m_dragAllowMove = false;
 796 #if wxUSE_DRAG_AND_DROP
 797     m_dragResult = wxDragNone;
 798 #endif
 799 }
 800
 801 bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
 802 bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
 803 bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
 804
 805
 806 wxStyledTextEvent::wxStyledTextEvent(const wxStyledTextEvent& event):
 807   wxCommandEvent(event)
 808 {
 809     m_position =      event.m_position;
 810     m_key =           event.m_key;
 811     m_modifiers =     event.m_modifiers;
 812     m_modificationType = event.m_modificationType;
 813     m_text =          event.m_text;
 814     m_length =        event.m_length;
 815     m_linesAdded =    event.m_linesAdded;
 816     m_line =          event.m_line;
 817     m_foldLevelNow =  event.m_foldLevelNow;
 818     m_foldLevelPrev = event.m_foldLevelPrev;
 819
 820     m_margin =        event.m_margin;
 821
 822     m_message =       event.m_message;
 823     m_wParam =        event.m_wParam;
 824     m_lParam =        event.m_lParam;
 825
 826     m_listType =     event.m_listType;
 827     m_x =            event.m_x;
 828     m_y =            event.m_y;
 829
 830     m_dragText =     event.m_dragText;
 831     m_dragAllowMove =event.m_dragAllowMove;
 832 #if wxUSE_DRAG_AND_DROP
 833     m_dragResult =   event.m_dragResult;
 834 #endif
 835 }
 836
 837 //----------------------------------------------------------------------
 838 //----------------------------------------------------------------------
 839
 840
 841
 842
 843
 844
 845
 846
 847