src/stc/ScintillaWX.cpp

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        ScintillaWX.cxx
   3 // Purpose:     A wxWidgets implementation of Scintilla.  A class derived
   4 //              from ScintillaBase that uses the "wx platform" defined in
   5 //              PlatformWX.cxx  This class is one end of a bridge between
   6 //              the wx world and the Scintilla world.  It needs a peer
   7 //              object of type wxStyledTextCtrl to function.
   8 //
   9 // Author:      Robin Dunn
  10 //
  11 // Created:     13-Jan-2000
  12 // RCS-ID:      $Id$
  13 // Copyright:   (c) 2000 by Total Control Software
  14 // Licence:     wxWindows license
  15 /////////////////////////////////////////////////////////////////////////////
  16
  17 #include "wx/wx.h"
  18 #include "wx/textbuf.h"
  19 #include "wx/dataobj.h"
  20 #include "wx/clipbrd.h"
  21 #include "wx/dnd.h"
  22
  23 #include "ScintillaWX.h"
  24 #include "ExternalLexer.h"
  25 #include "wx/stc/stc.h"
  26 #include "PlatWX.h"
  27
  28 #ifdef __WXMSW__
  29     // GetHwndOf()
  30     #include "wx/msw/private.h"
  31 #endif
  32
  33 //----------------------------------------------------------------------
  34 // Helper classes
  35
  36 class wxSTCTimer : public wxTimer {
  37 public:
  38     wxSTCTimer(ScintillaWX* swx) {
  39         this->swx = swx;
  40     }
  41
  42     void Notify() {
  43         swx->DoTick();
  44     }
  45
  46 private:
  47     ScintillaWX* swx;
  48 };
  49
  50
  51 #if wxUSE_DRAG_AND_DROP
  52 bool wxSTCDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) {
  53     return swx->DoDropText(x, y, data);
  54 }
  55
  56 wxDragResult  wxSTCDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def) {
  57     return swx->DoDragEnter(x, y, def);
  58 }
  59
  60 wxDragResult  wxSTCDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def) {
  61     return swx->DoDragOver(x, y, def);
  62 }
  63
  64 void  wxSTCDropTarget::OnLeave() {
  65     swx->DoDragLeave();
  66 }
  67 #endif
  68
  69
  70 #if wxUSE_POPUPWIN && wxSTC_USE_POPUP
  71 #include <wx/popupwin.h>
  72 #define wxSTCCallTipBase wxPopupWindow
  73 #define param2  wxBORDER_NONE  // popup's 2nd param is flags
  74 #else
  75 #define wxSTCCallTipBase wxWindow
  76 #define param2 -1 // wxWindow's 2nd param is ID
  77 #endif
  78
  79 #include <wx/dcbuffer.h>
  80
  81 class wxSTCCallTip : public wxSTCCallTipBase {
  82 public:
  83     wxSTCCallTip(wxWindow* parent, CallTip* ct, ScintillaWX* swx)
  84         : wxSTCCallTipBase(parent, param2),
  85           m_ct(ct), m_swx(swx), m_cx(wxDefaultCoord), m_cy(wxDefaultCoord)
  86         {
  87         }
  88
  89     ~wxSTCCallTip() {
  90 #if wxUSE_POPUPWIN && wxSTC_USE_POPUP && defined(__WXGTK__)
  91         wxRect rect = GetRect();
  92         rect.x = m_cx;
  93         rect.y = m_cy;
  94         GetParent()->Refresh(false, &rect);
  95 #endif
  96     }
  97
  98     bool AcceptsFocus() const { return false; }
  99
 100     void OnPaint(wxPaintEvent& WXUNUSED(evt)) {
 101         wxBufferedPaintDC dc(this);
 102         Surface* surfaceWindow = Surface::Allocate();
 103         surfaceWindow->Init(&dc, m_ct->wDraw.GetID());
 104         m_ct->PaintCT(surfaceWindow);
 105         surfaceWindow->Release();
 106         delete surfaceWindow;
 107     }
 108
 109     void OnFocus(wxFocusEvent& event) {
 110         GetParent()->SetFocus();
 111         event.Skip();
 112     }
 113
 114     void OnLeftDown(wxMouseEvent& event) {
 115         wxPoint pt = event.GetPosition();
 116         Point p(pt.x, pt.y);
 117         m_ct->MouseClick(p);
 118         m_swx->CallTipClick();
 119     }
 120
 121 #if wxUSE_POPUPWIN && wxSTC_USE_POPUP
 122     virtual void DoSetSize(int x, int y,
 123                            int width, int height,
 124                            int sizeFlags = wxSIZE_AUTO) {
 125         if (x != wxDefaultCoord) {
 126             m_cx = x;
 127             GetParent()->ClientToScreen(&x, NULL);
 128         }
 129         if (y != wxDefaultCoord) {
 130             m_cy = y;
 131             GetParent()->ClientToScreen(NULL, &y);
 132         }
 133         wxSTCCallTipBase::DoSetSize(x, y, width, height, sizeFlags);
 134     }
 135 #endif
 136
 137     wxPoint GetMyPosition() {
 138         return wxPoint(m_cx, m_cy);
 139     }
 140
 141 private:
 142     CallTip*      m_ct;
 143     ScintillaWX*  m_swx;
 144     int           m_cx, m_cy;
 145     DECLARE_EVENT_TABLE()
 146 };
 147
 148 BEGIN_EVENT_TABLE(wxSTCCallTip, wxSTCCallTipBase)
 149     EVT_PAINT(wxSTCCallTip::OnPaint)
 150     EVT_SET_FOCUS(wxSTCCallTip::OnFocus)
 151     EVT_LEFT_DOWN(wxSTCCallTip::OnLeftDown)
 152 END_EVENT_TABLE()
 153
 154
 155 //----------------------------------------------------------------------
 156
 157 #if wxUSE_DATAOBJ
 158 static wxTextFileType wxConvertEOLMode(int scintillaMode)
 159 {
 160     wxTextFileType type;
 161
 162     switch (scintillaMode) {
 163         case wxSTC_EOL_CRLF:
 164             type = wxTextFileType_Dos;
 165             break;
 166
 167         case wxSTC_EOL_CR:
 168             type = wxTextFileType_Mac;
 169             break;
 170
 171         case wxSTC_EOL_LF:
 172             type = wxTextFileType_Unix;
 173             break;
 174
 175         default:
 176             type = wxTextBuffer::typeDefault;
 177             break;
 178     }
 179     return type;
 180 }
 181 #endif // wxUSE_DATAOBJ
 182
 183
 184 //----------------------------------------------------------------------
 185 // Constructor/Destructor
 186
 187
 188 ScintillaWX::ScintillaWX(wxStyledTextCtrl* win) {
 189     capturedMouse = false;
 190     focusEvent = false;
 191     wMain = win;
 192     stc   = win;
 193     wheelRotation = 0;
 194     Initialise();
 195 #ifdef __WXMSW__
 196     sysCaretBitmap = 0;
 197     sysCaretWidth = 0;
 198     sysCaretHeight = 0;
 199 #endif
 200 }
 201
 202
 203 ScintillaWX::~ScintillaWX() {
 204     Finalise();
 205 }
 206
 207 //----------------------------------------------------------------------
 208 // base class virtuals
 209
 210
 211 void ScintillaWX::Initialise() {
 212     //ScintillaBase::Initialise();
 213 #if wxUSE_DRAG_AND_DROP
 214     dropTarget = new wxSTCDropTarget;
 215     dropTarget->SetScintilla(this);
 216     stc->SetDropTarget(dropTarget);
 217 #endif
 218 #ifdef __WXMAC__
 219     vs.extraFontFlag = false;  // UseAntiAliasing
 220 #else
 221     vs.extraFontFlag = true;   // UseAntiAliasing
 222 #endif
 223 }
 224
 225
 226 void ScintillaWX::Finalise() {
 227     ScintillaBase::Finalise();
 228     SetTicking(false);
 229     SetIdle(false);
 230     DestroySystemCaret();
 231 }
 232
 233
 234 void ScintillaWX::StartDrag() {
 235 #if wxUSE_DRAG_AND_DROP
 236     wxString dragText = stc2wx(drag.s, drag.len);
 237
 238     // Send an event to allow the drag text to be changed
 239     wxStyledTextEvent evt(wxEVT_STC_START_DRAG, stc->GetId());
 240     evt.SetEventObject(stc);
 241     evt.SetDragText(dragText);
 242     evt.SetDragAllowMove(true);
 243     evt.SetPosition(wxMin(stc->GetSelectionStart(),
 244                           stc->GetSelectionEnd()));
 245     stc->GetEventHandler()->ProcessEvent(evt);
 246     dragText = evt.GetDragText();
 247
 248     if (dragText.Length()) {
 249         wxDropSource        source(stc);
 250         wxTextDataObject    data(dragText);
 251         wxDragResult        result;
 252
 253         source.SetData(data);
 254         dropWentOutside = true;
 255         result = source.DoDragDrop(evt.GetDragAllowMove());
 256         if (result == wxDragMove && dropWentOutside)
 257             ClearSelection();
 258         inDragDrop = false;
 259         SetDragPosition(invalidPosition);
 260     }
 261 #endif
 262 }
 263
 264
 265 bool ScintillaWX::SetIdle(bool on) {
 266     if (idler.state != on) {
 267         // connect or disconnect the EVT_IDLE handler
 268         if (on)
 269             stc->Connect(wxID_ANY, wxEVT_IDLE,
 270                          (wxObjectEventFunction) (wxEventFunction) (wxIdleEventFunction) &wxStyledTextCtrl::OnIdle);
 271         else
 272             stc->Disconnect(wxID_ANY, wxEVT_IDLE,
 273                             (wxObjectEventFunction) (wxEventFunction) (wxIdleEventFunction) &wxStyledTextCtrl::OnIdle);
 274         idler.state = on;
 275     }
 276     return idler.state;
 277 }
 278
 279
 280 void ScintillaWX::SetTicking(bool on) {
 281     wxSTCTimer* steTimer;
 282     if (timer.ticking != on) {
 283         timer.ticking = on;
 284         if (timer.ticking) {
 285             steTimer = new wxSTCTimer(this);
 286             steTimer->Start(timer.tickSize);
 287             timer.tickerID = steTimer;
 288         } else {
 289             steTimer = (wxSTCTimer*)timer.tickerID;
 290             steTimer->Stop();
 291             delete steTimer;
 292             timer.tickerID = 0;
 293         }
 294     }
 295     timer.ticksToWait = caret.period;
 296 }
 297
 298
 299 void ScintillaWX::SetMouseCapture(bool on) {
 300     if (mouseDownCaptures) {
 301         if (on && !capturedMouse)
 302             stc->CaptureMouse();
 303         else if (!on && capturedMouse && stc->HasCapture())
 304             stc->ReleaseMouse();
 305         capturedMouse = on;
 306     }
 307 }
 308
 309
 310 bool ScintillaWX::HaveMouseCapture() {
 311     return capturedMouse;
 312 }
 313
 314
 315 void ScintillaWX::ScrollText(int linesToMove) {
 316     int dy = vs.lineHeight * (linesToMove);
 317     stc->ScrollWindow(0, dy);
 318     stc->Update();
 319 }
 320
 321 void ScintillaWX::SetVerticalScrollPos() {
 322     if (stc->m_vScrollBar == NULL) {  // Use built-in scrollbar
 323         stc->SetScrollPos(wxVERTICAL, topLine);
 324     }
 325     else { // otherwise use the one that's been given to us
 326         stc->m_vScrollBar->SetThumbPosition(topLine);
 327     }
 328 }
 329
 330 void ScintillaWX::SetHorizontalScrollPos() {
 331     if (stc->m_hScrollBar == NULL) {  // Use built-in scrollbar
 332         stc->SetScrollPos(wxHORIZONTAL, xOffset);
 333     }
 334     else { // otherwise use the one that's been given to us
 335         stc->m_hScrollBar->SetThumbPosition(xOffset);
 336     }
 337 }
 338
 339
 340 const int H_SCROLL_STEP = 20;
 341
 342 bool ScintillaWX::ModifyScrollBars(int nMax, int nPage) {
 343     bool modified = false;
 344
 345     int vertEnd = nMax;
 346     if (!verticalScrollBarVisible)
 347         vertEnd = 0;
 348
 349     // Check the vertical scrollbar
 350     if (stc->m_vScrollBar == NULL) {  // Use built-in scrollbar
 351         int  sbMax    = stc->GetScrollRange(wxVERTICAL);
 352         int  sbThumb  = stc->GetScrollThumb(wxVERTICAL);
 353         int  sbPos    = stc->GetScrollPos(wxVERTICAL);
 354         if (sbMax != vertEnd || sbThumb != nPage) {
 355             stc->SetScrollbar(wxVERTICAL, sbPos, nPage, vertEnd+1);
 356             modified = true;
 357         }
 358     }
 359     else { // otherwise use the one that's been given to us
 360         int  sbMax    = stc->m_vScrollBar->GetRange();
 361         int  sbPage   = stc->m_vScrollBar->GetPageSize();
 362         int  sbPos    = stc->m_vScrollBar->GetThumbPosition();
 363         if (sbMax != vertEnd || sbPage != nPage) {
 364             stc->m_vScrollBar->SetScrollbar(sbPos, nPage, vertEnd+1, nPage);
 365             modified = true;
 366         }
 367     }
 368
 369
 370     // Check the horizontal scrollbar
 371     PRectangle rcText = GetTextRectangle();
 372     int horizEnd = scrollWidth;
 373     if (horizEnd < 0)
 374         horizEnd = 0;
 375     if (!horizontalScrollBarVisible || (wrapState != eWrapNone))
 376         horizEnd = 0;
 377     int pageWidth = rcText.Width();
 378
 379     if (stc->m_hScrollBar == NULL) {  // Use built-in scrollbar
 380         int sbMax    = stc->GetScrollRange(wxHORIZONTAL);
 381         int sbThumb  = stc->GetScrollThumb(wxHORIZONTAL);
 382         int sbPos    = stc->GetScrollPos(wxHORIZONTAL);
 383         if ((sbMax != horizEnd) || (sbThumb != pageWidth) || (sbPos != 0)) {
 384             stc->SetScrollbar(wxHORIZONTAL, sbPos, pageWidth, horizEnd);
 385             modified = true;
 386             if (scrollWidth < pageWidth) {
 387                 HorizontalScrollTo(0);
 388             }
 389         }
 390     }
 391     else { // otherwise use the one that's been given to us
 392         int sbMax    = stc->m_hScrollBar->GetRange();
 393         int sbThumb  = stc->m_hScrollBar->GetPageSize();
 394         int sbPos    = stc->m_hScrollBar->GetThumbPosition();
 395         if ((sbMax != horizEnd) || (sbThumb != pageWidth) || (sbPos != 0)) {
 396             stc->m_hScrollBar->SetScrollbar(sbPos, pageWidth, horizEnd, pageWidth);
 397             modified = true;
 398             if (scrollWidth < pageWidth) {
 399                 HorizontalScrollTo(0);
 400             }
 401         }
 402     }
 403
 404     return modified;
 405 }
 406
 407
 408 void ScintillaWX::NotifyChange() {
 409     stc->NotifyChange();
 410 }
 411
 412
 413 void ScintillaWX::NotifyParent(SCNotification scn) {
 414     stc->NotifyParent(&scn);
 415 }
 416
 417
 418 // This method is overloaded from ScintillaBase in order to prevent the
 419 // AutoComplete window from being destroyed when it gets the focus.  There is
 420 // a side effect that the AutoComp will also not be destroyed when switching
 421 // to another window, but I think that is okay.
 422 void ScintillaWX::CancelModes() {
 423     if (! focusEvent)
 424         AutoCompleteCancel();
 425     ct.CallTipCancel();
 426     Editor::CancelModes();
 427 }
 428
 429
 430
 431 void ScintillaWX::Copy() {
 432     if (currentPos != anchor) {
 433         SelectionText st;
 434         CopySelectionRange(&st);
 435         CopyToClipboard(st);
 436     }
 437 }
 438
 439
 440 void ScintillaWX::Paste() {
 441     pdoc->BeginUndoAction();
 442     ClearSelection();
 443
 444 #if wxUSE_DATAOBJ
 445     wxTextDataObject data;
 446     bool gotData = false;
 447
 448     if (wxTheClipboard->Open()) {
 449         wxTheClipboard->UsePrimarySelection(false);
 450         gotData = wxTheClipboard->GetData(data);
 451         wxTheClipboard->Close();
 452     }
 453     if (gotData) {
 454         wxString   text = wxTextBuffer::Translate(data.GetText(),
 455                                                   wxConvertEOLMode(pdoc->eolMode));
 456         wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
 457         int        len = strlen(buf);
 458         pdoc->InsertString(currentPos, buf, len);
 459         SetEmptySelection(currentPos + len);
 460     }
 461 #endif // wxUSE_DATAOBJ
 462
 463     pdoc->EndUndoAction();
 464     NotifyChange();
 465     Redraw();
 466 }
 467
 468
 469 void ScintillaWX::CopyToClipboard(const SelectionText& st) {
 470 #if wxUSE_CLIPBOARD
 471     if (wxTheClipboard->Open()) {
 472         wxTheClipboard->UsePrimarySelection(false);
 473         wxString text = wxTextBuffer::Translate(stc2wx(st.s, st.len-1));
 474         wxTheClipboard->SetData(new wxTextDataObject(text));
 475         wxTheClipboard->Close();
 476     }
 477 #else
 478     wxUnusedVar(st);
 479 #endif // wxUSE_CLIPBOARD
 480 }
 481
 482
 483 bool ScintillaWX::CanPaste() {
 484 #if wxUSE_CLIPBOARD
 485     bool canPaste = false;
 486     bool didOpen;
 487
 488     if (Editor::CanPaste()) {
 489         didOpen = !wxTheClipboard->IsOpened();
 490         if ( didOpen )
 491             wxTheClipboard->Open();
 492
 493         if (wxTheClipboard->IsOpened()) {
 494             wxTheClipboard->UsePrimarySelection(false);
 495             canPaste = wxTheClipboard->IsSupported(wxUSE_UNICODE ? wxDF_UNICODETEXT : wxDF_TEXT);
 496             if (didOpen)
 497                 wxTheClipboard->Close();
 498         }
 499     }
 500     return canPaste;
 501 #else
 502     return false;
 503 #endif // wxUSE_CLIPBOARD
 504 }
 505
 506 void ScintillaWX::CreateCallTipWindow(PRectangle) {
 507     if (! ct.wCallTip.Created() ) {
 508         ct.wCallTip = new wxSTCCallTip(stc, &ct, this);
 509         ct.wDraw = ct.wCallTip;
 510     }
 511 }
 512
 513
 514 void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) {
 515     if (!label[0])
 516         ((wxMenu*)popup.GetID())->AppendSeparator();
 517     else
 518         ((wxMenu*)popup.GetID())->Append(cmd, wxGetTranslation(stc2wx(label)));
 519
 520     if (!enabled)
 521         ((wxMenu*)popup.GetID())->Enable(cmd, enabled);
 522 }
 523
 524
 525 // This is called by the Editor base class whenever something is selected
 526 void ScintillaWX::ClaimSelection() {
 527 #if 0
 528     // Until wxGTK is able to support using both the primary selection and the
 529     // clipboard at the same time I think it causes more problems than it is
 530     // worth to implement this method.  Selecting text should not clear the
 531     // clipboard.  --Robin
 532 #ifdef __WXGTK__
 533     // Put the selected text in the PRIMARY selection
 534     if (currentPos != anchor) {
 535         SelectionText st;
 536         CopySelectionRange(&st);
 537         if (wxTheClipboard->Open()) {
 538             wxTheClipboard->UsePrimarySelection(true);
 539             wxString text = stc2wx(st.s, st.len);
 540             wxTheClipboard->SetData(new wxTextDataObject(text));
 541             wxTheClipboard->UsePrimarySelection(false);
 542             wxTheClipboard->Close();
 543         }
 544     }
 545 #endif
 546 #endif
 547 }
 548
 549
 550 void ScintillaWX::UpdateSystemCaret() {
 551 #ifdef __WXMSW__
 552     if (hasFocus) {
 553         if (HasCaretSizeChanged()) {
 554             DestroySystemCaret();
 555             CreateSystemCaret();
 556         }
 557         Point pos = LocationFromPosition(currentPos);
 558         ::SetCaretPos(pos.x, pos.y);
 559     }
 560 #endif
 561 }
 562
 563
 564 bool ScintillaWX::HasCaretSizeChanged() {
 565 #ifdef __WXMSW__
 566     if (( (0 != vs.caretWidth) && (sysCaretWidth != vs.caretWidth) )
 567         || (0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight)) {
 568         return true;
 569     }
 570 #endif
 571     return false;
 572 }
 573
 574 bool ScintillaWX::CreateSystemCaret() {
 575 #ifdef __WXMSW__
 576     sysCaretWidth = vs.caretWidth;
 577     if (0 == sysCaretWidth) {
 578         sysCaretWidth = 1;
 579     }
 580     sysCaretHeight = vs.lineHeight;
 581     int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) * sysCaretHeight;
 582     char *bits = new char[bitmapSize];
 583     memset(bits, 0, bitmapSize);
 584     sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1,
 585                                     1, reinterpret_cast<BYTE *>(bits));
 586     delete [] bits;
 587     BOOL retval = ::CreateCaret(GetHwndOf(stc), sysCaretBitmap,
 588                                 sysCaretWidth, sysCaretHeight);
 589     ::ShowCaret(GetHwndOf(stc));
 590     return retval != 0;
 591 #else
 592     return false;
 593 #endif
 594 }
 595
 596 bool ScintillaWX::DestroySystemCaret() {
 597 #ifdef __WXMSW__
 598     ::HideCaret(GetHwndOf(stc));
 599     BOOL retval = ::DestroyCaret();
 600     if (sysCaretBitmap) {
 601         ::DeleteObject(sysCaretBitmap);
 602         sysCaretBitmap = 0;
 603     }
 604     return retval != 0;
 605 #else
 606     return false;
 607 #endif
 608 }
 609
 610
 611 //----------------------------------------------------------------------
 612
 613
 614 long ScintillaWX::DefWndProc(unsigned int /*iMessage*/, unsigned long /*wParam*/, long /*lParam*/) {
 615     return 0;
 616 }
 617
 618 long ScintillaWX::WndProc(unsigned int iMessage, unsigned long wParam, long lParam) {
 619       switch (iMessage) {
 620       case SCI_CALLTIPSHOW: {
 621           // NOTE: This is copied here from scintilla/src/ScintillaBase.cxx
 622           // because of the little tweak that needs done below for wxGTK.
 623           // When updating new versions double check that this is still
 624           // needed, and that any new code there is copied here too.
 625           Point pt = LocationFromPosition(wParam);
 626           char* defn = reinterpret_cast<char *>(lParam);
 627           AutoCompleteCancel();
 628           pt.y += vs.lineHeight;
 629           PRectangle rc = ct.CallTipStart(currentPos, pt,
 630                                           defn,
 631                                           vs.styles[STYLE_DEFAULT].fontName,
 632                                           vs.styles[STYLE_DEFAULT].sizeZoomed,
 633                                           CodePage(),
 634                                           vs.styles[STYLE_DEFAULT].characterSet,
 635                                           wMain);
 636           // If the call-tip window would be out of the client
 637           // space, adjust so it displays above the text.
 638           PRectangle rcClient = GetClientRectangle();
 639           if (rc.bottom > rcClient.bottom) {
 640 #ifdef __WXGTK__
 641               int offset = int(vs.lineHeight * 1.25)  + rc.Height();
 642 #else
 643               int offset = vs.lineHeight + rc.Height();
 644 #endif
 645               rc.top -= offset;
 646               rc.bottom -= offset;
 647           }
 648           // Now display the window.
 649           CreateCallTipWindow(rc);
 650           ct.wCallTip.SetPositionRelative(rc, wMain);
 651           ct.wCallTip.Show();
 652           break;
 653       }
 654
 655 #ifdef SCI_LEXER
 656       case SCI_LOADLEXERLIBRARY:
 657             LexerManager::GetInstance()->Load((const char*)lParam);
 658             break;
 659 #endif
 660
 661       default:
 662           return ScintillaBase::WndProc(iMessage, wParam, lParam);
 663       }
 664       return 0;
 665 }
 666
 667
 668
 669 //----------------------------------------------------------------------
 670 // Event delegates
 671
 672 void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) {
 673
 674     paintState = painting;
 675     Surface* surfaceWindow = Surface::Allocate();
 676     surfaceWindow->Init(dc, wMain.GetID());
 677     rcPaint = PRectangleFromwxRect(rect);
 678     PRectangle rcClient = GetClientRectangle();
 679     paintingAllText = rcPaint.Contains(rcClient);
 680
 681     dc->BeginDrawing();
 682     ClipChildren(*dc, rcPaint);
 683     Paint(surfaceWindow, rcPaint);
 684
 685     delete surfaceWindow;
 686     if (paintState == paintAbandoned) {
 687         // Painting area was insufficient to cover new styling or brace
 688         // highlight positions
 689         FullPaint();
 690     }
 691     paintState = notPainting;
 692     dc->EndDrawing();
 693 }
 694
 695
 696 void ScintillaWX::DoHScroll(int type, int pos) {
 697     int xPos = xOffset;
 698     PRectangle rcText = GetTextRectangle();
 699     int pageWidth = rcText.Width() * 2 / 3;
 700     if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
 701         xPos -= H_SCROLL_STEP;
 702     else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
 703         xPos += H_SCROLL_STEP;
 704     else if (type == wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
 705         xPos -= pageWidth;
 706     else if (type == wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN) {
 707         xPos += pageWidth;
 708         if (xPos > scrollWidth - rcText.Width()) {
 709             xPos = scrollWidth - rcText.Width();
 710         }
 711     }
 712     else if (type == wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
 713         xPos = 0;
 714     else if (type == wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
 715         xPos = scrollWidth;
 716     else if (type == wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
 717         xPos = pos;
 718
 719     HorizontalScrollTo(xPos);
 720 }
 721
 722 void ScintillaWX::DoVScroll(int type, int pos) {
 723     int topLineNew = topLine;
 724     if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
 725         topLineNew -= 1;
 726     else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
 727         topLineNew += 1;
 728     else if (type ==  wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
 729         topLineNew -= LinesToScroll();
 730     else if (type ==  wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN)
 731         topLineNew += LinesToScroll();
 732     else if (type ==  wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
 733         topLineNew = 0;
 734     else if (type ==  wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
 735         topLineNew = MaxScrollPos();
 736     else if (type ==   wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
 737         topLineNew = pos;
 738
 739     ScrollTo(topLineNew);
 740 }
 741
 742 void ScintillaWX::DoMouseWheel(int rotation, int delta,
 743                                int linesPerAction, int ctrlDown,
 744                                bool isPageScroll ) {
 745     int topLineNew = topLine;
 746     int lines;
 747
 748     if (ctrlDown) {  // Zoom the fonts if Ctrl key down
 749         if (rotation < 0) {
 750             KeyCommand(SCI_ZOOMIN);
 751         }
 752         else {
 753             KeyCommand(SCI_ZOOMOUT);
 754         }
 755     }
 756     else { // otherwise just scroll the window
 757         if ( !delta )
 758             delta = 120;
 759         wheelRotation += rotation;
 760         lines = wheelRotation / delta;
 761         wheelRotation -= lines * delta;
 762         if (lines != 0) {
 763             if (isPageScroll)
 764                 lines = lines * LinesOnScreen();  // lines is either +1 or -1
 765             else
 766                 lines *= linesPerAction;
 767             topLineNew -= lines;
 768             ScrollTo(topLineNew);
 769         }
 770     }
 771 }
 772
 773
 774 void ScintillaWX::DoSize(int WXUNUSED(width), int WXUNUSED(height)) {
 775     ChangeSize();
 776 }
 777
 778 void ScintillaWX::DoLoseFocus(){
 779     focusEvent = true;
 780     SetFocusState(false);
 781     focusEvent = false;
 782     DestroySystemCaret();
 783 }
 784
 785 void ScintillaWX::DoGainFocus(){
 786     focusEvent = true;
 787     SetFocusState(true);
 788     focusEvent = false;
 789     DestroySystemCaret();
 790     CreateSystemCaret();
 791 }
 792
 793 void ScintillaWX::DoSysColourChange() {
 794     InvalidateStyleData();
 795 }
 796
 797 void ScintillaWX::DoLeftButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
 798     ButtonDown(pt, curTime, shift, ctrl, alt);
 799 }
 800
 801 void ScintillaWX::DoLeftButtonUp(Point pt, unsigned int curTime, bool ctrl) {
 802     ButtonUp(pt, curTime, ctrl);
 803 }
 804
 805 void ScintillaWX::DoLeftButtonMove(Point pt) {
 806     ButtonMove(pt);
 807 }
 808
 809 #ifdef __WXGTK__
 810 void ScintillaWX::DoMiddleButtonUp(Point pt) {
 811     // Set the current position to the mouse click point and
 812     // then paste in the PRIMARY selection, if any.  wxGTK only.
 813     int newPos = PositionFromLocation(pt);
 814     MovePositionTo(newPos, noSel, true);
 815
 816     pdoc->BeginUndoAction();
 817     wxTextDataObject data;
 818     bool gotData = false;
 819     if (wxTheClipboard->Open()) {
 820         wxTheClipboard->UsePrimarySelection(true);
 821         gotData = wxTheClipboard->GetData(data);
 822         wxTheClipboard->UsePrimarySelection(false);
 823         wxTheClipboard->Close();
 824     }
 825     if (gotData) {
 826         wxString   text = wxTextBuffer::Translate(data.GetText(),
 827                                                   wxConvertEOLMode(pdoc->eolMode));
 828         wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
 829         int        len = strlen(buf);
 830         pdoc->InsertString(currentPos, buf, len);
 831         SetEmptySelection(currentPos + len);
 832     }
 833     pdoc->EndUndoAction();
 834     NotifyChange();
 835     Redraw();
 836
 837     ShowCaretAtCurrentPosition();
 838     EnsureCaretVisible();
 839 }
 840 #else
 841 void ScintillaWX::DoMiddleButtonUp(Point WXUNUSED(pt)) {
 842 }
 843 #endif
 844
 845
 846 void ScintillaWX::DoAddChar(int key) {
 847 #if wxUSE_UNICODE
 848     wxChar wszChars[2];
 849     wszChars[0] = (wxChar)key;
 850     wszChars[1] = 0;
 851     wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(wszChars);
 852     AddCharUTF((char*)buf.data(), strlen(buf));
 853 #else
 854     AddChar((char)key);
 855 #endif
 856 }
 857
 858
 859 int  ScintillaWX::DoKeyDown(const wxKeyEvent& evt, bool* consumed)
 860 {
 861     int key = evt.GetKeyCode();
 862     bool shift = evt.ShiftDown(),
 863          ctrl  = evt.ControlDown(),
 864          alt   = evt.AltDown();
 865
 866     if (ctrl && key >= 1 && key <= 26 && key != WXK_BACK)
 867         key += 'A' - 1;
 868
 869     switch (key) {
 870     case WXK_DOWN:              key = SCK_DOWN;     break;
 871     case WXK_UP:                key = SCK_UP;       break;
 872     case WXK_LEFT:              key = SCK_LEFT;     break;
 873     case WXK_RIGHT:             key = SCK_RIGHT;    break;
 874     case WXK_HOME:              key = SCK_HOME;     break;
 875     case WXK_END:               key = SCK_END;      break;
 876     case WXK_PAGEUP:            // fall through
 877     case WXK_PRIOR:             key = SCK_PRIOR;    break;
 878     case WXK_PAGEDOWN:          // fall through
 879     case WXK_NEXT:              key = SCK_NEXT;     break;
 880     case WXK_DELETE:            key = SCK_DELETE;   break;
 881     case WXK_INSERT:            key = SCK_INSERT;   break;
 882     case WXK_ESCAPE:            key = SCK_ESCAPE;   break;
 883     case WXK_BACK:              key = SCK_BACK;     break;
 884     case WXK_TAB:               key = SCK_TAB;      break;
 885     case WXK_NUMPAD_ENTER:      // fall through
 886     case WXK_RETURN:            key = SCK_RETURN;   break;
 887     case WXK_ADD:               // fall through
 888     case WXK_NUMPAD_ADD:        key = SCK_ADD;      break;
 889     case WXK_SUBTRACT:          // fall through
 890     case WXK_NUMPAD_SUBTRACT:   key = SCK_SUBTRACT; break;
 891     case WXK_DIVIDE:            // fall through
 892     case WXK_NUMPAD_DIVIDE:     key = SCK_DIVIDE;   break;
 893     case WXK_CONTROL:           key = 0; break;
 894     case WXK_ALT:               key = 0; break;
 895     case WXK_SHIFT:             key = 0; break;
 896     case WXK_MENU:              key = 0; break;
 897     }
 898
 899 #ifdef __WXMAC__
 900     if ( evt.MetaDown() ) {
 901         // check for a few common Mac Meta-key combos and remap them to Ctrl
 902         // for Scintilla
 903         switch ( key ) {
 904         case 'Z':       // Undo
 905         case 'X':       // Cut
 906         case 'C':       // Copy
 907         case 'V':       // Paste
 908         case 'A':       // Select All
 909             ctrl = true;
 910             break;
 911         }
 912     }
 913 #endif
 914
 915     int rv = KeyDown(key, shift, ctrl, alt, consumed);
 916
 917     if (key)
 918         return rv;
 919     else
 920         return 1;
 921 }
 922
 923
 924 void ScintillaWX::DoCommand(int ID) {
 925     Command(ID);
 926 }
 927
 928
 929 void ScintillaWX::DoContextMenu(Point pt) {
 930     if (displayPopupMenu)
 931         ContextMenu(pt);
 932 }
 933
 934 void ScintillaWX::DoOnListBox() {
 935     AutoCompleteCompleted();
 936 }
 937
 938
 939 void ScintillaWX::DoOnIdle(wxIdleEvent& evt) {
 940
 941     if ( Idle() )
 942         evt.RequestMore();
 943     else
 944         SetIdle(false);
 945 }
 946
 947 //----------------------------------------------------------------------
 948
 949 #if wxUSE_DRAG_AND_DROP
 950 bool ScintillaWX::DoDropText(long x, long y, const wxString& data) {
 951     SetDragPosition(invalidPosition);
 952
 953     wxString text = wxTextBuffer::Translate(data,
 954                                             wxConvertEOLMode(pdoc->eolMode));
 955
 956     // Send an event to allow the drag details to be changed
 957     wxStyledTextEvent evt(wxEVT_STC_DO_DROP, stc->GetId());
 958     evt.SetEventObject(stc);
 959     evt.SetDragResult(dragResult);
 960     evt.SetX(x);
 961     evt.SetY(y);
 962     evt.SetPosition(PositionFromLocation(Point(x,y)));
 963     evt.SetDragText(text);
 964     stc->GetEventHandler()->ProcessEvent(evt);
 965
 966     dragResult = evt.GetDragResult();
 967     if (dragResult == wxDragMove || dragResult == wxDragCopy) {
 968         DropAt(evt.GetPosition(),
 969                wx2stc(evt.GetDragText()),
 970                dragResult == wxDragMove,
 971                false); // TODO: rectangular?
 972         return true;
 973     }
 974     return false;
 975 }
 976
 977
 978 wxDragResult ScintillaWX::DoDragEnter(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxDragResult def) {
 979     dragResult = def;
 980     return dragResult;
 981 }
 982
 983
 984 wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
 985     SetDragPosition(PositionFromLocation(Point(x, y)));
 986
 987     // Send an event to allow the drag result to be changed
 988     wxStyledTextEvent evt(wxEVT_STC_DRAG_OVER, stc->GetId());
 989     evt.SetEventObject(stc);
 990     evt.SetDragResult(def);
 991     evt.SetX(x);
 992     evt.SetY(y);
 993     evt.SetPosition(PositionFromLocation(Point(x,y)));
 994     stc->GetEventHandler()->ProcessEvent(evt);
 995
 996     dragResult = evt.GetDragResult();
 997     return dragResult;
 998 }
 999
1000
1001 void ScintillaWX::DoDragLeave() {
1002     SetDragPosition(invalidPosition);
1003 }
1004 #endif
1005 //----------------------------------------------------------------------
1006
1007 // Force the whole window to be repainted
1008 void ScintillaWX::FullPaint() {
1009 #ifndef __WXMAC__
1010     stc->Refresh(false);
1011 #endif
1012     stc->Update();
1013 }
1014
1015
1016 void ScintillaWX::DoScrollToLine(int line) {
1017     ScrollTo(line);
1018 }
1019
1020
1021 void ScintillaWX::DoScrollToColumn(int column) {
1022     HorizontalScrollTo(column * vs.spaceWidth);
1023 }
1024
1025 // wxGTK doesn't appear to need this explicit clipping code any longer, but I
1026 // will leave it here commented out for a while just in case...
1027 void ScintillaWX::ClipChildren(wxDC& WXUNUSED(dc), PRectangle WXUNUSED(rect))
1028 {
1029 //     wxRegion rgn(wxRectFromPRectangle(rect));
1030 //     if (ac.Active()) {
1031 //         wxRect childRect = ((wxWindow*)ac.lb->GetID())->GetRect();
1032 //         rgn.Subtract(childRect);
1033 //     }
1034 //     if (ct.inCallTipMode) {
1035 //         wxSTCCallTip* tip = (wxSTCCallTip*)ct.wCallTip.GetID();
1036 //         wxRect childRect = tip->GetRect();
1037 // #if wxUSE_POPUPWIN && wxSTC_USE_POPUP
1038 //         childRect.SetPosition(tip->GetMyPosition());
1039 // #endif
1040 //         rgn.Subtract(childRect);
1041 //     }
1042 //     dc.SetClippingRegion(rgn);
1043 }
1044
1045
1046 void ScintillaWX::SetUseAntiAliasing(bool useAA) {
1047     vs.extraFontFlag = useAA;
1048     InvalidateStyleRedraw();
1049 }
1050
1051 bool ScintillaWX::GetUseAntiAliasing() {
1052     return vs.extraFontFlag;
1053 }
1054
1055 //----------------------------------------------------------------------
1056 //----------------------------------------------------------------------