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     ClipChildren(*dc, rcPaint);
 682     Paint(surfaceWindow, rcPaint);
 683
 684     delete surfaceWindow;
 685     if (paintState == paintAbandoned) {
 686         // Painting area was insufficient to cover new styling or brace
 687         // highlight positions
 688         FullPaint();
 689     }
 690     paintState = notPainting;
 691 }
 692
 693
 694 void ScintillaWX::DoHScroll(int type, int pos) {
 695     int xPos = xOffset;
 696     PRectangle rcText = GetTextRectangle();
 697     int pageWidth = rcText.Width() * 2 / 3;
 698     if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
 699         xPos -= H_SCROLL_STEP;
 700     else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
 701         xPos += H_SCROLL_STEP;
 702     else if (type == wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
 703         xPos -= pageWidth;
 704     else if (type == wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN) {
 705         xPos += pageWidth;
 706         if (xPos > scrollWidth - rcText.Width()) {
 707             xPos = scrollWidth - rcText.Width();
 708         }
 709     }
 710     else if (type == wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
 711         xPos = 0;
 712     else if (type == wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
 713         xPos = scrollWidth;
 714     else if (type == wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
 715         xPos = pos;
 716
 717     HorizontalScrollTo(xPos);
 718 }
 719
 720 void ScintillaWX::DoVScroll(int type, int pos) {
 721     int topLineNew = topLine;
 722     if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
 723         topLineNew -= 1;
 724     else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
 725         topLineNew += 1;
 726     else if (type ==  wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
 727         topLineNew -= LinesToScroll();
 728     else if (type ==  wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN)
 729         topLineNew += LinesToScroll();
 730     else if (type ==  wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
 731         topLineNew = 0;
 732     else if (type ==  wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
 733         topLineNew = MaxScrollPos();
 734     else if (type ==   wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
 735         topLineNew = pos;
 736
 737     ScrollTo(topLineNew);
 738 }
 739
 740 void ScintillaWX::DoMouseWheel(int rotation, int delta,
 741                                int linesPerAction, int ctrlDown,
 742                                bool isPageScroll ) {
 743     int topLineNew = topLine;
 744     int lines;
 745
 746     if (ctrlDown) {  // Zoom the fonts if Ctrl key down
 747         if (rotation < 0) {
 748             KeyCommand(SCI_ZOOMIN);
 749         }
 750         else {
 751             KeyCommand(SCI_ZOOMOUT);
 752         }
 753     }
 754     else { // otherwise just scroll the window
 755         if ( !delta )
 756             delta = 120;
 757         wheelRotation += rotation;
 758         lines = wheelRotation / delta;
 759         wheelRotation -= lines * delta;
 760         if (lines != 0) {
 761             if (isPageScroll)
 762                 lines = lines * LinesOnScreen();  // lines is either +1 or -1
 763             else
 764                 lines *= linesPerAction;
 765             topLineNew -= lines;
 766             ScrollTo(topLineNew);
 767         }
 768     }
 769 }
 770
 771
 772 void ScintillaWX::DoSize(int WXUNUSED(width), int WXUNUSED(height)) {
 773     ChangeSize();
 774 }
 775
 776 void ScintillaWX::DoLoseFocus(){
 777     focusEvent = true;
 778     SetFocusState(false);
 779     focusEvent = false;
 780     DestroySystemCaret();
 781 }
 782
 783 void ScintillaWX::DoGainFocus(){
 784     focusEvent = true;
 785     SetFocusState(true);
 786     focusEvent = false;
 787     DestroySystemCaret();
 788     CreateSystemCaret();
 789 }
 790
 791 void ScintillaWX::DoSysColourChange() {
 792     InvalidateStyleData();
 793 }
 794
 795 void ScintillaWX::DoLeftButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
 796     ButtonDown(pt, curTime, shift, ctrl, alt);
 797 }
 798
 799 void ScintillaWX::DoLeftButtonUp(Point pt, unsigned int curTime, bool ctrl) {
 800     ButtonUp(pt, curTime, ctrl);
 801 }
 802
 803 void ScintillaWX::DoLeftButtonMove(Point pt) {
 804     ButtonMove(pt);
 805 }
 806
 807 #ifdef __WXGTK__
 808 void ScintillaWX::DoMiddleButtonUp(Point pt) {
 809     // Set the current position to the mouse click point and
 810     // then paste in the PRIMARY selection, if any.  wxGTK only.
 811     int newPos = PositionFromLocation(pt);
 812     MovePositionTo(newPos, noSel, true);
 813
 814     pdoc->BeginUndoAction();
 815     wxTextDataObject data;
 816     bool gotData = false;
 817     if (wxTheClipboard->Open()) {
 818         wxTheClipboard->UsePrimarySelection(true);
 819         gotData = wxTheClipboard->GetData(data);
 820         wxTheClipboard->UsePrimarySelection(false);
 821         wxTheClipboard->Close();
 822     }
 823     if (gotData) {
 824         wxString   text = wxTextBuffer::Translate(data.GetText(),
 825                                                   wxConvertEOLMode(pdoc->eolMode));
 826         wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
 827         int        len = strlen(buf);
 828         pdoc->InsertString(currentPos, buf, len);
 829         SetEmptySelection(currentPos + len);
 830     }
 831     pdoc->EndUndoAction();
 832     NotifyChange();
 833     Redraw();
 834
 835     ShowCaretAtCurrentPosition();
 836     EnsureCaretVisible();
 837 }
 838 #else
 839 void ScintillaWX::DoMiddleButtonUp(Point WXUNUSED(pt)) {
 840 }
 841 #endif
 842
 843
 844 void ScintillaWX::DoAddChar(int key) {
 845 #if wxUSE_UNICODE
 846     wxChar wszChars[2];
 847     wszChars[0] = (wxChar)key;
 848     wszChars[1] = 0;
 849     wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(wszChars);
 850     AddCharUTF((char*)buf.data(), strlen(buf));
 851 #else
 852     AddChar((char)key);
 853 #endif
 854 }
 855
 856
 857 int  ScintillaWX::DoKeyDown(const wxKeyEvent& evt, bool* consumed)
 858 {
 859     int key = evt.GetKeyCode();
 860     bool shift = evt.ShiftDown(),
 861          ctrl  = evt.ControlDown(),
 862          alt   = evt.AltDown();
 863
 864     if (ctrl && key >= 1 && key <= 26 && key != WXK_BACK)
 865         key += 'A' - 1;
 866
 867     switch (key) {
 868     case WXK_DOWN:              key = SCK_DOWN;     break;
 869     case WXK_UP:                key = SCK_UP;       break;
 870     case WXK_LEFT:              key = SCK_LEFT;     break;
 871     case WXK_RIGHT:             key = SCK_RIGHT;    break;
 872     case WXK_HOME:              key = SCK_HOME;     break;
 873     case WXK_END:               key = SCK_END;      break;
 874     case WXK_PAGEUP:            // fall through
 875     case WXK_PRIOR:             key = SCK_PRIOR;    break;
 876     case WXK_PAGEDOWN:          // fall through
 877     case WXK_NEXT:              key = SCK_NEXT;     break;
 878     case WXK_DELETE:            key = SCK_DELETE;   break;
 879     case WXK_INSERT:            key = SCK_INSERT;   break;
 880     case WXK_ESCAPE:            key = SCK_ESCAPE;   break;
 881     case WXK_BACK:              key = SCK_BACK;     break;
 882     case WXK_TAB:               key = SCK_TAB;      break;
 883     case WXK_NUMPAD_ENTER:      // fall through
 884     case WXK_RETURN:            key = SCK_RETURN;   break;
 885     case WXK_ADD:               // fall through
 886     case WXK_NUMPAD_ADD:        key = SCK_ADD;      break;
 887     case WXK_SUBTRACT:          // fall through
 888     case WXK_NUMPAD_SUBTRACT:   key = SCK_SUBTRACT; break;
 889     case WXK_DIVIDE:            // fall through
 890     case WXK_NUMPAD_DIVIDE:     key = SCK_DIVIDE;   break;
 891     case WXK_CONTROL:           key = 0; break;
 892     case WXK_ALT:               key = 0; break;
 893     case WXK_SHIFT:             key = 0; break;
 894     case WXK_MENU:              key = 0; break;
 895     }
 896
 897 #ifdef __WXMAC__
 898     if ( evt.MetaDown() ) {
 899         // check for a few common Mac Meta-key combos and remap them to Ctrl
 900         // for Scintilla
 901         switch ( key ) {
 902         case 'Z':       // Undo
 903         case 'X':       // Cut
 904         case 'C':       // Copy
 905         case 'V':       // Paste
 906         case 'A':       // Select All
 907             ctrl = true;
 908             break;
 909         }
 910     }
 911 #endif
 912
 913     int rv = KeyDown(key, shift, ctrl, alt, consumed);
 914
 915     if (key)
 916         return rv;
 917     else
 918         return 1;
 919 }
 920
 921
 922 void ScintillaWX::DoCommand(int ID) {
 923     Command(ID);
 924 }
 925
 926
 927 void ScintillaWX::DoContextMenu(Point pt) {
 928     if (displayPopupMenu)
 929         ContextMenu(pt);
 930 }
 931
 932 void ScintillaWX::DoOnListBox() {
 933     AutoCompleteCompleted();
 934 }
 935
 936
 937 void ScintillaWX::DoOnIdle(wxIdleEvent& evt) {
 938
 939     if ( Idle() )
 940         evt.RequestMore();
 941     else
 942         SetIdle(false);
 943 }
 944
 945 //----------------------------------------------------------------------
 946
 947 #if wxUSE_DRAG_AND_DROP
 948 bool ScintillaWX::DoDropText(long x, long y, const wxString& data) {
 949     SetDragPosition(invalidPosition);
 950
 951     wxString text = wxTextBuffer::Translate(data,
 952                                             wxConvertEOLMode(pdoc->eolMode));
 953
 954     // Send an event to allow the drag details to be changed
 955     wxStyledTextEvent evt(wxEVT_STC_DO_DROP, stc->GetId());
 956     evt.SetEventObject(stc);
 957     evt.SetDragResult(dragResult);
 958     evt.SetX(x);
 959     evt.SetY(y);
 960     evt.SetPosition(PositionFromLocation(Point(x,y)));
 961     evt.SetDragText(text);
 962     stc->GetEventHandler()->ProcessEvent(evt);
 963
 964     dragResult = evt.GetDragResult();
 965     if (dragResult == wxDragMove || dragResult == wxDragCopy) {
 966         DropAt(evt.GetPosition(),
 967                wx2stc(evt.GetDragText()),
 968                dragResult == wxDragMove,
 969                false); // TODO: rectangular?
 970         return true;
 971     }
 972     return false;
 973 }
 974
 975
 976 wxDragResult ScintillaWX::DoDragEnter(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxDragResult def) {
 977     dragResult = def;
 978     return dragResult;
 979 }
 980
 981
 982 wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
 983     SetDragPosition(PositionFromLocation(Point(x, y)));
 984
 985     // Send an event to allow the drag result to be changed
 986     wxStyledTextEvent evt(wxEVT_STC_DRAG_OVER, stc->GetId());
 987     evt.SetEventObject(stc);
 988     evt.SetDragResult(def);
 989     evt.SetX(x);
 990     evt.SetY(y);
 991     evt.SetPosition(PositionFromLocation(Point(x,y)));
 992     stc->GetEventHandler()->ProcessEvent(evt);
 993
 994     dragResult = evt.GetDragResult();
 995     return dragResult;
 996 }
 997
 998
 999 void ScintillaWX::DoDragLeave() {
1000     SetDragPosition(invalidPosition);
1001 }
1002 #endif
1003 //----------------------------------------------------------------------
1004
1005 // Force the whole window to be repainted
1006 void ScintillaWX::FullPaint() {
1007 #ifndef __WXMAC__
1008     stc->Refresh(false);
1009 #endif
1010     stc->Update();
1011 }
1012
1013
1014 void ScintillaWX::DoScrollToLine(int line) {
1015     ScrollTo(line);
1016 }
1017
1018
1019 void ScintillaWX::DoScrollToColumn(int column) {
1020     HorizontalScrollTo(column * vs.spaceWidth);
1021 }
1022
1023 // wxGTK doesn't appear to need this explicit clipping code any longer, but I
1024 // will leave it here commented out for a while just in case...
1025 void ScintillaWX::ClipChildren(wxDC& WXUNUSED(dc), PRectangle WXUNUSED(rect))
1026 {
1027 //     wxRegion rgn(wxRectFromPRectangle(rect));
1028 //     if (ac.Active()) {
1029 //         wxRect childRect = ((wxWindow*)ac.lb->GetID())->GetRect();
1030 //         rgn.Subtract(childRect);
1031 //     }
1032 //     if (ct.inCallTipMode) {
1033 //         wxSTCCallTip* tip = (wxSTCCallTip*)ct.wCallTip.GetID();
1034 //         wxRect childRect = tip->GetRect();
1035 // #if wxUSE_POPUPWIN && wxSTC_USE_POPUP
1036 //         childRect.SetPosition(tip->GetMyPosition());
1037 // #endif
1038 //         rgn.Subtract(childRect);
1039 //     }
1040 //     dc.SetClippingRegion(rgn);
1041 }
1042
1043
1044 void ScintillaWX::SetUseAntiAliasing(bool useAA) {
1045     vs.extraFontFlag = useAA;
1046     InvalidateStyleRedraw();
1047 }
1048
1049 bool ScintillaWX::GetUseAntiAliasing() {
1050     return vs.extraFontFlag;
1051 }
1052
1053 //----------------------------------------------------------------------
1054 //----------------------------------------------------------------------