contrib/src/stc/ScintillaWX.cpp

////////////////////////////////////////////////////////////////////////////
// Name:        ScintillaWX.cxx
// Purpose:     A wxWindows implementation of Scintilla.  A class derived
//              from ScintillaBase that uses the "wx platform" defined in
//              PlatformWX.cxx  This class is one end of a bridge between
//              the wx world and the Scintilla world.  It needs a peer
//              object of type wxStyledTextCtrl to function.
//
// Author:      Robin Dunn
//
// Created:     13-Jan-2000
// RCS-ID:      $Id$
// Copyright:   (c) 2000 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#include <ctype.h>

#include "ScintillaWX.h"
#include "wx/stc/stc.h"


//----------------------------------------------------------------------

const int H_SCROLL_MAX  = 4000;
const int H_SCROLL_STEP = 20;
const int H_SCROLL_PAGE = 200;

//----------------------------------------------------------------------
// Helper classes

class wxSTCTimer : public wxTimer {
public:
    wxSTCTimer(ScintillaWX* swx) {
        this->swx = swx;
    }

    void Notify() {
        swx->DoTick();
    }

private:
    ScintillaWX* swx;
};


#if wxUSE_DRAG_AND_DROP
bool wxSTCDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) {
    return swx->DoDropText(x, y, data);
}

wxDragResult  wxSTCDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def) {
    return swx->DoDragEnter(x, y, def);
}

wxDragResult  wxSTCDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def) {
    return swx->DoDragOver(x, y, def);
}

void  wxSTCDropTarget::OnLeave() {
    swx->DoDragLeave();
}
#endif


class wxSTCCallTip : public wxWindow {
public:
    wxSTCCallTip(wxWindow* parent, int ID, CallTip* ct)
        : wxWindow(parent, ID)
        {
            m_ct = ct;
        }

    void OnPaint(wxPaintEvent& evt) {
        wxPaintDC dc(this);
        Surface surfaceWindow;
        surfaceWindow.Init(&dc);
        m_ct->PaintCT(&surfaceWindow);
        surfaceWindow.Release();
    }

    CallTip*    m_ct;
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(wxSTCCallTip, wxWindow)
    EVT_PAINT(wxSTCCallTip::OnPaint)
END_EVENT_TABLE()

//----------------------------------------------------------------------
// Constructor/Destructor


ScintillaWX::ScintillaWX(wxStyledTextCtrl* win) {
    capturedMouse = false;
    wMain = win;
    stc   = win;
    wheelRotation = 0;
    Initialise();
}


ScintillaWX::~ScintillaWX() {
    SetTicking(false);
}

//----------------------------------------------------------------------
// base class virtuals


void ScintillaWX::Initialise() {
    //ScintillaBase::Initialise();
#if wxUSE_DRAG_AND_DROP
    dropTarget = new wxSTCDropTarget;
    dropTarget->SetScintilla(this);
    stc->SetDropTarget(dropTarget);
#endif
}


void ScintillaWX::Finalise() {
    ScintillaBase::Finalise();
}


void ScintillaWX::StartDrag() {
#if wxUSE_DRAG_AND_DROP
    wxString dragText(drag.s, drag.len);

    // Send an event to allow the drag text to be changed
    wxStyledTextEvent evt(wxEVT_STC_START_DRAG, stc->GetId());
    evt.SetEventObject(stc);
    evt.SetDragText(dragText);
    evt.SetDragAllowMove(TRUE);
    evt.SetPosition(wxMin(stc->GetSelectionStart(),
                          stc->GetSelectionEnd()));
    stc->GetEventHandler()->ProcessEvent(evt);
    dragText = evt.GetDragText();

    if (dragText.Length()) {
        wxDropSource        source(stc);
        wxTextDataObject    data(dragText);
        wxDragResult        result;

        source.SetData(data);
        dropWentOutside = TRUE;
        result = source.DoDragDrop(evt.GetDragAllowMove());
        if (result == wxDragMove && dropWentOutside)
            ClearSelection();
        inDragDrop = FALSE;
        SetDragPosition(invalidPosition);
    }
#endif
}


void ScintillaWX::SetTicking(bool on) {
    wxSTCTimer* steTimer;
    if (timer.ticking != on) {
        timer.ticking = on;
        if (timer.ticking) {
            steTimer = new wxSTCTimer(this);
            steTimer->Start(timer.tickSize);
            timer.tickerID = (int)steTimer;
        } else {
            steTimer = (wxSTCTimer*)timer.tickerID;
            steTimer->Stop();
            delete steTimer;
            timer.tickerID = 0;
        }
    }
    timer.ticksToWait = caret.period;
}


void ScintillaWX::SetMouseCapture(bool on) {
    if (on && !capturedMouse)
        stc->CaptureMouse();
    else if (!on && capturedMouse)
        stc->ReleaseMouse();
    capturedMouse = on;
}


bool ScintillaWX::HaveMouseCapture() {
    return capturedMouse;
}


void ScintillaWX::ScrollText(int linesToMove) {
    int dy = vs.lineHeight * (linesToMove);
    stc->ScrollWindow(0, dy);
    stc->Update();
}

void ScintillaWX::SetVerticalScrollPos() {
    if (stc->m_vScrollBar == NULL) {  // Use built-in scrollbar
        stc->SetScrollPos(wxVERTICAL, topLine);
    }
    else { // otherwise use the one that's been given to us
        stc->m_vScrollBar->SetThumbPosition(topLine);
    }
}

void ScintillaWX::SetHorizontalScrollPos() {
    if (stc->m_hScrollBar == NULL) {  // Use built-in scrollbar
        stc->SetScrollPos(wxHORIZONTAL, xOffset);
    }
    else { // otherwise use the one that's been given to us
        stc->m_hScrollBar->SetThumbPosition(xOffset);
    }
}


bool ScintillaWX::ModifyScrollBars(int nMax, int nPage) {
    bool modified = false;

    if (stc->m_vScrollBar == NULL) {  // Use built-in scrollbar
        int  sbMax    = stc->GetScrollRange(wxVERTICAL);
        int  sbThumb  = stc->GetScrollThumb(wxVERTICAL);
        int  sbPos    = stc->GetScrollPos(wxVERTICAL);
        if (sbMax != nMax || sbThumb != nPage) {
            stc->SetScrollbar(wxVERTICAL, sbPos, nPage, nMax);
            modified = true;
        }
    }
    else { // otherwise use the one that's been given to us
        int  sbMax    = stc->m_vScrollBar->GetRange();
        int  sbPage   = stc->m_vScrollBar->GetPageSize();
        int  sbPos    = stc->m_vScrollBar->GetThumbPosition();
        if (sbMax != nMax || sbPage != nPage) {
            stc->m_vScrollBar->SetScrollbar(sbPos, nPage, nMax, nPage);
            modified = true;
        }
    }


    if (horizontalScrollBarVisible) {
        if (stc->m_hScrollBar == NULL) {  // Use built-in scrollbar
            int sbMax    = stc->GetScrollRange(wxHORIZONTAL);
            int sbThumb  = stc->GetScrollThumb(wxHORIZONTAL);
            if ((sbMax != H_SCROLL_MAX) || (sbThumb != H_SCROLL_STEP)) {
                stc->SetScrollbar(wxHORIZONTAL, 0, H_SCROLL_STEP, H_SCROLL_MAX);
                modified = true;
            }
        }
        else { // otherwise use the one that's been given to us
            int  sbMax    = stc->m_hScrollBar->GetRange();
            int  sbPage   = stc->m_hScrollBar->GetPageSize();
            if ((sbMax != H_SCROLL_MAX) || (sbPage != H_SCROLL_STEP)) {
                stc->m_hScrollBar->SetScrollbar(0, H_SCROLL_STEP, H_SCROLL_MAX, H_SCROLL_STEP);
                modified = true;
            }
        }
    }
    return modified;
}


void ScintillaWX::NotifyChange() {
    stc->NotifyChange();
}


void ScintillaWX::NotifyParent(SCNotification scn) {
    stc->NotifyParent(&scn);
}


void ScintillaWX::Copy() {
    if (currentPos != anchor) {
        SelectionText st;
        CopySelectionRange(&st);
        wxTheClipboard->Open();
        wxTheClipboard->SetData(new wxTextDataObject(wxString(st.s, st.len)));
        wxTheClipboard->Close();
    }
}


void ScintillaWX::Paste() {
    pdoc->BeginUndoAction();
    ClearSelection();

    wxTextDataObject data;
    bool gotData;

    wxTheClipboard->Open();
    gotData = wxTheClipboard->GetData(data);
    wxTheClipboard->Close();
    if (gotData) {
        wxString str = data.GetText();
        int      len = str.Length();
        pdoc->InsertString(currentPos, str.c_str(), len);
        SetEmptySelection(currentPos + len);
    }

    pdoc->EndUndoAction();
    NotifyChange();
    Redraw();
}


bool ScintillaWX::CanPaste() {
    bool canPaste;

    wxTheClipboard->Open();
    canPaste = wxTheClipboard->IsSupported( wxDF_TEXT );
    wxTheClipboard->Close();

    return canPaste;
}

void ScintillaWX::CreateCallTipWindow(PRectangle) {
    ct.wCallTip = new wxSTCCallTip(stc, -1, &ct);
    ct.wDraw = ct.wCallTip;
}


void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) {
    if (!label[0])
        popup.GetID()->AppendSeparator();
    else
        popup.GetID()->Append(cmd, label);

    if (!enabled)
        popup.GetID()->Enable(cmd, enabled);
}


void ScintillaWX::ClaimSelection() {

}


long ScintillaWX::DefWndProc(unsigned int /*iMessage*/, unsigned long /*wParam*/, long /*lParam*/) {
    return 0;
}

long ScintillaWX::WndProc(unsigned int iMessage, unsigned long wParam, long lParam) {
//      switch (iMessage) {
//      case EM_CANPASTE:
//          return CanPaste();
//      default:
        return ScintillaBase::WndProc(iMessage, wParam, lParam);
//      }
//      return 0;
}


//----------------------------------------------------------------------
// Event delegates

void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) {

    paintState = painting;
    Surface surfaceWindow;
    surfaceWindow.Init(dc);
    PRectangle rcPaint = PRectangleFromwxRect(rect);
    dc->BeginDrawing();
    Paint(&surfaceWindow, rcPaint);
    dc->EndDrawing();
    surfaceWindow.Release();
    if (paintState == paintAbandoned) {
        // Painting area was insufficient to cover new styling or brace highlight positions
        FullPaint();
    }
    paintState = notPainting;
#ifdef __WXGTK__
    // On wxGTK the editor window paints can overwrite the listbox...
    if (ac.Active())
        ((wxWindow*)ac.lb.GetID())->Refresh(TRUE);
#endif
}


void ScintillaWX::DoHScroll(int type, int pos) {
    int xPos = xOffset;
    if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
        xPos -= H_SCROLL_STEP;
    else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
        xPos += H_SCROLL_STEP;
    else if (type == wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
        xPos -= H_SCROLL_PAGE;
    else if (type == wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN)
        xPos += H_SCROLL_PAGE;
    else if (type == wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
        xPos = 0;
    else if (type == wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
        xPos = H_SCROLL_MAX;
    else if (type == wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
        xPos = pos;

    HorizontalScrollTo(xPos);
}

void ScintillaWX::DoVScroll(int type, int pos) {
    int topLineNew = topLine;
    if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP)
        topLineNew -= 1;
    else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN)
        topLineNew += 1;
    else if (type ==  wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP)
        topLineNew -= LinesToScroll();
    else if (type ==  wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN)
        topLineNew += LinesToScroll();
    else if (type ==  wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP)
        topLineNew = 0;
    else if (type ==  wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM)
        topLineNew = MaxScrollPos();
    else if (type ==   wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK)
        topLineNew = pos;

    ScrollTo(topLineNew);
}


void ScintillaWX::DoMouseWheel(int rotation, int delta, int linesPerAction, int ctrlDown) {
    int topLineNew = topLine;
    int lines;

    if (ctrlDown) {  // Zoom the fonts if Ctrl key down
        if (rotation < 0) {
            KeyCommand(SCI_ZOOMIN);
        }
        else {
            KeyCommand(SCI_ZOOMOUT);
        }
    }
    else { // otherwise just scroll the window
        wheelRotation += rotation;
        lines = wheelRotation / delta;
        wheelRotation -= lines * delta;
        if (lines != 0) {
            lines *= linesPerAction;
            topLineNew -= lines;
            ScrollTo(topLineNew);
        }
    }
}


void ScintillaWX::DoSize(int width, int height) {
    PRectangle rcClient(0,0,width,height);
    SetScrollBarsTo(rcClient);
    DropGraphics();
}

void ScintillaWX::DoLoseFocus(){
    SetFocusState(false);
}

void ScintillaWX::DoGainFocus(){
    SetFocusState(true);
}

void ScintillaWX::DoSysColourChange() {
    InvalidateStyleData();
}

void ScintillaWX::DoButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
    ButtonDown(pt, curTime, shift, ctrl, alt);
}

void ScintillaWX::DoButtonUp(Point pt, unsigned int curTime, bool ctrl) {
    ButtonUp(pt, curTime, ctrl);
}

void ScintillaWX::DoButtonMove(Point pt) {
    ButtonMove(pt);
}


void ScintillaWX::DoAddChar(char ch) {
    AddChar(ch);
}

int  ScintillaWX::DoKeyDown(int key, bool shift, bool ctrl, bool alt, bool* consumed) {
#ifdef __WXGTK__
    // Ctrl chars (A-Z) end up with the wrong keycode on wxGTK...
    if (ctrl && key >= 1 && key <= 26)
        key += 'A' - 1;
#endif

    switch (key) {
    case WXK_DOWN: key = SCK_DOWN; break;
    case WXK_UP: key = SCK_UP; break;
    case WXK_LEFT: key = SCK_LEFT; break;
    case WXK_RIGHT: key = SCK_RIGHT; break;
    case WXK_HOME: key = SCK_HOME; break;
    case WXK_END: key = SCK_END; break;
    case WXK_PRIOR: key = SCK_PRIOR; break;
    case WXK_NEXT: key = SCK_NEXT; break;
    case WXK_DELETE: key = SCK_DELETE; break;
    case WXK_INSERT: key = SCK_INSERT; break;
    case WXK_ESCAPE: key = SCK_ESCAPE; break;
    case WXK_BACK: key = SCK_BACK; break;
    case WXK_TAB: key = SCK_TAB; break;
    case WXK_RETURN: key = SCK_RETURN; break;
    case WXK_ADD:
    case WXK_NUMPAD_ADD:
        key = SCK_ADD; break;
    case WXK_SUBTRACT:
    case WXK_NUMPAD_SUBTRACT:
        key = SCK_SUBTRACT; break;
    case WXK_DIVIDE:
    case WXK_NUMPAD_DIVIDE:
        key = SCK_DIVIDE; break;
    case WXK_CONTROL: key = 0; break;
    case WXK_ALT: key = 0; break;
    case WXK_SHIFT: key = 0; break;
    case WXK_MENU: key = 0; break;
    }

    int rv = KeyDown(key, shift, ctrl, alt, consumed);

    if (key)
        return rv;
    else
        return 1;
}


void ScintillaWX::DoCommand(int ID) {
    Command(ID);
}


void ScintillaWX::DoContextMenu(Point pt) {
    ContextMenu(pt);
}

void ScintillaWX::DoOnListBox() {
    AutoCompleteCompleted();
}

//----------------------------------------------------------------------

#if wxUSE_DRAG_AND_DROP
bool ScintillaWX::DoDropText(long x, long y, const wxString& data) {
    SetDragPosition(invalidPosition);

    // Send an event to allow the drag details to be changed
    wxStyledTextEvent evt(wxEVT_STC_DO_DROP, stc->GetId());
    evt.SetEventObject(stc);
    evt.SetDragResult(dragResult);
    evt.SetX(x);
    evt.SetY(y);
    evt.SetPosition(PositionFromLocation(Point(x,y)));
    evt.SetDragText(data);
    stc->GetEventHandler()->ProcessEvent(evt);

    dragResult = evt.GetDragResult();
    if (dragResult == wxDragMove || dragResult == wxDragCopy) {
        DropAt(evt.GetPosition(),
               evt.GetDragText(),
               dragResult == wxDragMove,
               FALSE); // TODO: rectangular?
        return TRUE;
    }
    return FALSE;
}


wxDragResult ScintillaWX::DoDragEnter(wxCoord x, wxCoord y, wxDragResult def) {
    dragResult = def;
    return dragResult;
}


wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
    SetDragPosition(PositionFromLocation(Point(x, y)));

    // Send an event to allow the drag result to be changed
    wxStyledTextEvent evt(wxEVT_STC_DRAG_OVER, stc->GetId());
    evt.SetEventObject(stc);
    evt.SetDragResult(def);
    evt.SetX(x);
    evt.SetY(y);
    evt.SetPosition(PositionFromLocation(Point(x,y)));
    stc->GetEventHandler()->ProcessEvent(evt);

    dragResult = evt.GetDragResult();
    return dragResult;
}


void ScintillaWX::DoDragLeave() {
    SetDragPosition(invalidPosition);
}
#endif
//----------------------------------------------------------------------

// Redraw all of text area. This paint will not be abandoned.
void ScintillaWX::FullPaint() {
    paintState = painting;
    rcPaint = GetTextRectangle();
    paintingAllText = true;
    wxClientDC dc(stc);
    Surface surfaceWindow;
    surfaceWindow.Init(&dc);
    Paint(&surfaceWindow, rcPaint);
    surfaceWindow.Release();

//     stc->Refresh(FALSE);

    paintState = notPainting;
}


void ScintillaWX::DoScrollToLine(int line) {
    ScrollTo(line);
}


void ScintillaWX::DoScrollToColumn(int column) {
    HorizontalScrollTo(column * vs.spaceWidth);
}


//----------------------------------------------------------------------
//----------------------------------------------------------------------
Commit	Line	Data
	1	////////////////////////////////////////////////////////////////////////////
	2	// Name: ScintillaWX.cxx
	3	// Purpose: A wxWindows 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 <ctype.h>
	18
	19	#include "ScintillaWX.h"
	20	#include "wx/stc/stc.h"
	21
	22
	23	//----------------------------------------------------------------------
	24
	25	const int H_SCROLL_MAX = 4000;
	26	const int H_SCROLL_STEP = 20;
	27	const int H_SCROLL_PAGE = 200;
	28
	29	//----------------------------------------------------------------------
	30	// Helper classes
	31
	32	class wxSTCTimer : public wxTimer {
	33	public:
	34	wxSTCTimer(ScintillaWX* swx) {
	35	this->swx = swx;
	36	}
	37
	38	void Notify() {
	39	swx->DoTick();
	40	}
	41
	42	private:
	43	ScintillaWX* swx;
	44	};
	45
	46
	47	#if wxUSE_DRAG_AND_DROP
	48	bool wxSTCDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) {
	49	return swx->DoDropText(x, y, data);
	50	}
	51
	52	wxDragResult wxSTCDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def) {
	53	return swx->DoDragEnter(x, y, def);
	54	}
	55
	56	wxDragResult wxSTCDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def) {
	57	return swx->DoDragOver(x, y, def);
	58	}
	59
	60	void wxSTCDropTarget::OnLeave() {
	61	swx->DoDragLeave();
	62	}
	63	#endif
	64
	65
	66	class wxSTCCallTip : public wxWindow {
	67	public:
	68	wxSTCCallTip(wxWindow* parent, int ID, CallTip* ct)
	69	: wxWindow(parent, ID)
	70	{
	71	m_ct = ct;
	72	}
	73
	74	void OnPaint(wxPaintEvent& evt) {
	75	wxPaintDC dc(this);
	76	Surface surfaceWindow;
	77	surfaceWindow.Init(&dc);
	78	m_ct->PaintCT(&surfaceWindow);
	79	surfaceWindow.Release();
	80	}
	81
	82	CallTip* m_ct;
	83	DECLARE_EVENT_TABLE()
	84	};
	85
	86	BEGIN_EVENT_TABLE(wxSTCCallTip, wxWindow)
	87	EVT_PAINT(wxSTCCallTip::OnPaint)
	88	END_EVENT_TABLE()
	89
	90	//----------------------------------------------------------------------
	91	// Constructor/Destructor
	92
	93
	94	ScintillaWX::ScintillaWX(wxStyledTextCtrl* win) {
	95	capturedMouse = false;
	96	wMain = win;
	97	stc = win;
	98	wheelRotation = 0;
	99	Initialise();
	100	}
	101
	102
	103	ScintillaWX::~ScintillaWX() {
	104	SetTicking(false);
	105	}
	106
	107	//----------------------------------------------------------------------
	108	// base class virtuals
	109
	110
	111	void ScintillaWX::Initialise() {
	112	//ScintillaBase::Initialise();
	113	#if wxUSE_DRAG_AND_DROP
	114	dropTarget = new wxSTCDropTarget;
	115	dropTarget->SetScintilla(this);
	116	stc->SetDropTarget(dropTarget);
	117	#endif
	118	}
	119
	120
	121	void ScintillaWX::Finalise() {
	122	ScintillaBase::Finalise();
	123	}
	124
	125
	126	void ScintillaWX::StartDrag() {
	127	#if wxUSE_DRAG_AND_DROP
	128	wxString dragText(drag.s, drag.len);
	129
	130	// Send an event to allow the drag text to be changed
	131	wxStyledTextEvent evt(wxEVT_STC_START_DRAG, stc->GetId());
	132	evt.SetEventObject(stc);
	133	evt.SetDragText(dragText);
	134	evt.SetDragAllowMove(TRUE);
	135	evt.SetPosition(wxMin(stc->GetSelectionStart(),
	136	stc->GetSelectionEnd()));
	137	stc->GetEventHandler()->ProcessEvent(evt);
	138	dragText = evt.GetDragText();
	139
	140	if (dragText.Length()) {
	141	wxDropSource source(stc);
	142	wxTextDataObject data(dragText);
	143	wxDragResult result;
	144
	145	source.SetData(data);
	146	dropWentOutside = TRUE;
	147	result = source.DoDragDrop(evt.GetDragAllowMove());
	148	if (result == wxDragMove && dropWentOutside)
	149	ClearSelection();
	150	inDragDrop = FALSE;
	151	SetDragPosition(invalidPosition);
	152	}
	153	#endif
	154	}
	155
	156
	157	void ScintillaWX::SetTicking(bool on) {
	158	wxSTCTimer* steTimer;
	159	if (timer.ticking != on) {
	160	timer.ticking = on;
	161	if (timer.ticking) {
	162	steTimer = new wxSTCTimer(this);
	163	steTimer->Start(timer.tickSize);
	164	timer.tickerID = (int)steTimer;
	165	} else {
	166	steTimer = (wxSTCTimer*)timer.tickerID;
	167	steTimer->Stop();
	168	delete steTimer;
	169	timer.tickerID = 0;
	170	}
	171	}
	172	timer.ticksToWait = caret.period;
	173	}
	174
	175
	176	void ScintillaWX::SetMouseCapture(bool on) {
	177	if (on && !capturedMouse)
	178	stc->CaptureMouse();
	179	else if (!on && capturedMouse)
	180	stc->ReleaseMouse();
	181	capturedMouse = on;
	182	}
	183
	184
	185	bool ScintillaWX::HaveMouseCapture() {
	186	return capturedMouse;
	187	}
	188
	189
	190	void ScintillaWX::ScrollText(int linesToMove) {
	191	int dy = vs.lineHeight * (linesToMove);
	192	stc->ScrollWindow(0, dy);
	193	stc->Update();
	194	}
	195
	196	void ScintillaWX::SetVerticalScrollPos() {
	197	if (stc->m_vScrollBar == NULL) { // Use built-in scrollbar
	198	stc->SetScrollPos(wxVERTICAL, topLine);
	199	}
	200	else { // otherwise use the one that's been given to us
	201	stc->m_vScrollBar->SetThumbPosition(topLine);
	202	}
	203	}
	204
	205	void ScintillaWX::SetHorizontalScrollPos() {
	206	if (stc->m_hScrollBar == NULL) { // Use built-in scrollbar
	207	stc->SetScrollPos(wxHORIZONTAL, xOffset);
	208	}
	209	else { // otherwise use the one that's been given to us
	210	stc->m_hScrollBar->SetThumbPosition(xOffset);
	211	}
	212	}
	213
	214
	215	bool ScintillaWX::ModifyScrollBars(int nMax, int nPage) {
	216	bool modified = false;
	217
	218	if (stc->m_vScrollBar == NULL) { // Use built-in scrollbar
	219	int sbMax = stc->GetScrollRange(wxVERTICAL);
	220	int sbThumb = stc->GetScrollThumb(wxVERTICAL);
	221	int sbPos = stc->GetScrollPos(wxVERTICAL);
	222	if (sbMax != nMax \|\| sbThumb != nPage) {
	223	stc->SetScrollbar(wxVERTICAL, sbPos, nPage, nMax);
	224	modified = true;
	225	}
	226	}
	227	else { // otherwise use the one that's been given to us
	228	int sbMax = stc->m_vScrollBar->GetRange();
	229	int sbPage = stc->m_vScrollBar->GetPageSize();
	230	int sbPos = stc->m_vScrollBar->GetThumbPosition();
	231	if (sbMax != nMax \|\| sbPage != nPage) {
	232	stc->m_vScrollBar->SetScrollbar(sbPos, nPage, nMax, nPage);
	233	modified = true;
	234	}
	235	}
	236
	237
	238	if (horizontalScrollBarVisible) {
	239	if (stc->m_hScrollBar == NULL) { // Use built-in scrollbar
	240	int sbMax = stc->GetScrollRange(wxHORIZONTAL);
	241	int sbThumb = stc->GetScrollThumb(wxHORIZONTAL);
	242	if ((sbMax != H_SCROLL_MAX) \|\| (sbThumb != H_SCROLL_STEP)) {
	243	stc->SetScrollbar(wxHORIZONTAL, 0, H_SCROLL_STEP, H_SCROLL_MAX);
	244	modified = true;
	245	}
	246	}
	247	else { // otherwise use the one that's been given to us
	248	int sbMax = stc->m_hScrollBar->GetRange();
	249	int sbPage = stc->m_hScrollBar->GetPageSize();
	250	if ((sbMax != H_SCROLL_MAX) \|\| (sbPage != H_SCROLL_STEP)) {
	251	stc->m_hScrollBar->SetScrollbar(0, H_SCROLL_STEP, H_SCROLL_MAX, H_SCROLL_STEP);
	252	modified = true;
	253	}
	254	}
	255	}
	256	return modified;
	257	}
	258
	259
	260	void ScintillaWX::NotifyChange() {
	261	stc->NotifyChange();
	262	}
	263
	264
	265	void ScintillaWX::NotifyParent(SCNotification scn) {
	266	stc->NotifyParent(&scn);
	267	}
	268
	269
	270
	271	void ScintillaWX::Copy() {
	272	if (currentPos != anchor) {
	273	SelectionText st;
	274	CopySelectionRange(&st);
	275	wxTheClipboard->Open();
	276	wxTheClipboard->SetData(new wxTextDataObject(wxString(st.s, st.len)));
	277	wxTheClipboard->Close();
	278	}
	279	}
	280
	281
	282	void ScintillaWX::Paste() {
	283	pdoc->BeginUndoAction();
	284	ClearSelection();
	285
	286	wxTextDataObject data;
	287	bool gotData;
	288
	289	wxTheClipboard->Open();
	290	gotData = wxTheClipboard->GetData(data);
	291	wxTheClipboard->Close();
	292	if (gotData) {
	293	wxString str = data.GetText();
	294	int len = str.Length();
	295	pdoc->InsertString(currentPos, str.c_str(), len);
	296	SetEmptySelection(currentPos + len);
	297	}
	298
	299	pdoc->EndUndoAction();
	300	NotifyChange();
	301	Redraw();
	302	}
	303
	304
	305	bool ScintillaWX::CanPaste() {
	306	bool canPaste;
	307
	308	wxTheClipboard->Open();
	309	canPaste = wxTheClipboard->IsSupported( wxDF_TEXT );
	310	wxTheClipboard->Close();
	311
	312	return canPaste;
	313	}
	314
	315	void ScintillaWX::CreateCallTipWindow(PRectangle) {
	316	ct.wCallTip = new wxSTCCallTip(stc, -1, &ct);
	317	ct.wDraw = ct.wCallTip;
	318	}
	319
	320
	321	void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) {
	322	if (!label[0])
	323	popup.GetID()->AppendSeparator();
	324	else
	325	popup.GetID()->Append(cmd, label);
	326
	327	if (!enabled)
	328	popup.GetID()->Enable(cmd, enabled);
	329	}
	330
	331
	332	void ScintillaWX::ClaimSelection() {
	333
	334	}
	335
	336
	337	long ScintillaWX::DefWndProc(unsigned int /iMessage/, unsigned long /wParam/, long /lParam/) {
	338	return 0;
	339	}
	340
	341	long ScintillaWX::WndProc(unsigned int iMessage, unsigned long wParam, long lParam) {
	342	// switch (iMessage) {
	343	// case EM_CANPASTE:
	344	// return CanPaste();
	345	// default:
	346	return ScintillaBase::WndProc(iMessage, wParam, lParam);
	347	// }
	348	// return 0;
	349	}
	350
	351
	352
	353	//----------------------------------------------------------------------
	354	// Event delegates
	355
	356	void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) {
	357
	358	paintState = painting;
	359	Surface surfaceWindow;
	360	surfaceWindow.Init(dc);
	361	PRectangle rcPaint = PRectangleFromwxRect(rect);
	362	dc->BeginDrawing();
	363	Paint(&surfaceWindow, rcPaint);
	364	dc->EndDrawing();
	365	surfaceWindow.Release();
	366	if (paintState == paintAbandoned) {
	367	// Painting area was insufficient to cover new styling or brace highlight positions
	368	FullPaint();
	369	}
	370	paintState = notPainting;
	371	#ifdef __WXGTK__
	372	// On wxGTK the editor window paints can overwrite the listbox...
	373	if (ac.Active())
	374	((wxWindow*)ac.lb.GetID())->Refresh(TRUE);
	375	#endif
	376	}
	377
	378
	379	void ScintillaWX::DoHScroll(int type, int pos) {
	380	int xPos = xOffset;
	381	if (type == wxEVT_SCROLLWIN_LINEUP \|\| type == wxEVT_SCROLL_LINEUP)
	382	xPos -= H_SCROLL_STEP;
	383	else if (type == wxEVT_SCROLLWIN_LINEDOWN \|\| type == wxEVT_SCROLL_LINEDOWN)
	384	xPos += H_SCROLL_STEP;
	385	else if (type == wxEVT_SCROLLWIN_PAGEUP \|\| type == wxEVT_SCROLL_PAGEUP)
	386	xPos -= H_SCROLL_PAGE;
	387	else if (type == wxEVT_SCROLLWIN_PAGEDOWN \|\| type == wxEVT_SCROLL_PAGEDOWN)
	388	xPos += H_SCROLL_PAGE;
	389	else if (type == wxEVT_SCROLLWIN_TOP \|\| type == wxEVT_SCROLL_TOP)
	390	xPos = 0;
	391	else if (type == wxEVT_SCROLLWIN_BOTTOM \|\| type == wxEVT_SCROLL_BOTTOM)
	392	xPos = H_SCROLL_MAX;
	393	else if (type == wxEVT_SCROLLWIN_THUMBTRACK \|\| type == wxEVT_SCROLL_THUMBTRACK)
	394	xPos = pos;
	395
	396	HorizontalScrollTo(xPos);
	397	}
	398
	399	void ScintillaWX::DoVScroll(int type, int pos) {
	400	int topLineNew = topLine;
	401	if (type == wxEVT_SCROLLWIN_LINEUP \|\| type == wxEVT_SCROLL_LINEUP)
	402	topLineNew -= 1;
	403	else if (type == wxEVT_SCROLLWIN_LINEDOWN \|\| type == wxEVT_SCROLL_LINEDOWN)
	404	topLineNew += 1;
	405	else if (type == wxEVT_SCROLLWIN_PAGEUP \|\| type == wxEVT_SCROLL_PAGEUP)
	406	topLineNew -= LinesToScroll();
	407	else if (type == wxEVT_SCROLLWIN_PAGEDOWN \|\| type == wxEVT_SCROLL_PAGEDOWN)
	408	topLineNew += LinesToScroll();
	409	else if (type == wxEVT_SCROLLWIN_TOP \|\| type == wxEVT_SCROLL_TOP)
	410	topLineNew = 0;
	411	else if (type == wxEVT_SCROLLWIN_BOTTOM \|\| type == wxEVT_SCROLL_BOTTOM)
	412	topLineNew = MaxScrollPos();
	413	else if (type == wxEVT_SCROLLWIN_THUMBTRACK \|\| type == wxEVT_SCROLL_THUMBTRACK)
	414	topLineNew = pos;
	415
	416	ScrollTo(topLineNew);
	417	}
	418
	419
	420	void ScintillaWX::DoMouseWheel(int rotation, int delta, int linesPerAction, int ctrlDown) {
	421	int topLineNew = topLine;
	422	int lines;
	423
	424	if (ctrlDown) { // Zoom the fonts if Ctrl key down
	425	if (rotation < 0) {
	426	KeyCommand(SCI_ZOOMIN);
	427	}
	428	else {
	429	KeyCommand(SCI_ZOOMOUT);
	430	}
	431	}
	432	else { // otherwise just scroll the window
	433	wheelRotation += rotation;
	434	lines = wheelRotation / delta;
	435	wheelRotation -= lines * delta;
	436	if (lines != 0) {
	437	lines *= linesPerAction;
	438	topLineNew -= lines;
	439	ScrollTo(topLineNew);
	440	}
	441	}
	442	}
	443
	444
	445	void ScintillaWX::DoSize(int width, int height) {
	446	PRectangle rcClient(0,0,width,height);
	447	SetScrollBarsTo(rcClient);
	448	DropGraphics();
	449	}
	450
	451	void ScintillaWX::DoLoseFocus(){
	452	SetFocusState(false);
	453	}
	454
	455	void ScintillaWX::DoGainFocus(){
	456	SetFocusState(true);
	457	}
	458
	459	void ScintillaWX::DoSysColourChange() {
	460	InvalidateStyleData();
	461	}
	462
	463	void ScintillaWX::DoButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
	464	ButtonDown(pt, curTime, shift, ctrl, alt);
	465	}
	466
	467	void ScintillaWX::DoButtonUp(Point pt, unsigned int curTime, bool ctrl) {
	468	ButtonUp(pt, curTime, ctrl);
	469	}
	470
	471	void ScintillaWX::DoButtonMove(Point pt) {
	472	ButtonMove(pt);
	473	}
	474
	475
	476	void ScintillaWX::DoAddChar(char ch) {
	477	AddChar(ch);
	478	}
	479
	480	int ScintillaWX::DoKeyDown(int key, bool shift, bool ctrl, bool alt, bool* consumed) {
	481	#ifdef __WXGTK__
	482	// Ctrl chars (A-Z) end up with the wrong keycode on wxGTK...
	483	if (ctrl && key >= 1 && key <= 26)
	484	key += 'A' - 1;
	485	#endif
	486
	487	switch (key) {
	488	case WXK_DOWN: key = SCK_DOWN; break;
	489	case WXK_UP: key = SCK_UP; break;
	490	case WXK_LEFT: key = SCK_LEFT; break;
	491	case WXK_RIGHT: key = SCK_RIGHT; break;
	492	case WXK_HOME: key = SCK_HOME; break;
	493	case WXK_END: key = SCK_END; break;
	494	case WXK_PRIOR: key = SCK_PRIOR; break;
	495	case WXK_NEXT: key = SCK_NEXT; break;
	496	case WXK_DELETE: key = SCK_DELETE; break;
	497	case WXK_INSERT: key = SCK_INSERT; break;
	498	case WXK_ESCAPE: key = SCK_ESCAPE; break;
	499	case WXK_BACK: key = SCK_BACK; break;
	500	case WXK_TAB: key = SCK_TAB; break;
	501	case WXK_RETURN: key = SCK_RETURN; break;
	502	case WXK_ADD:
	503	case WXK_NUMPAD_ADD:
	504	key = SCK_ADD; break;
	505	case WXK_SUBTRACT:
	506	case WXK_NUMPAD_SUBTRACT:
	507	key = SCK_SUBTRACT; break;
	508	case WXK_DIVIDE:
	509	case WXK_NUMPAD_DIVIDE:
	510	key = SCK_DIVIDE; break;
	511	case WXK_CONTROL: key = 0; break;
	512	case WXK_ALT: key = 0; break;
	513	case WXK_SHIFT: key = 0; break;
	514	case WXK_MENU: key = 0; break;
	515	}
	516
	517	int rv = KeyDown(key, shift, ctrl, alt, consumed);
	518
	519	if (key)
	520	return rv;
	521	else
	522	return 1;
	523	}
	524
	525
	526	void ScintillaWX::DoCommand(int ID) {
	527	Command(ID);
	528	}
	529
	530
	531	void ScintillaWX::DoContextMenu(Point pt) {
	532	ContextMenu(pt);
	533	}
	534
	535	void ScintillaWX::DoOnListBox() {
	536	AutoCompleteCompleted();
	537	}
	538
	539	//----------------------------------------------------------------------
	540
	541	#if wxUSE_DRAG_AND_DROP
	542	bool ScintillaWX::DoDropText(long x, long y, const wxString& data) {
	543	SetDragPosition(invalidPosition);
	544
	545	// Send an event to allow the drag details to be changed
	546	wxStyledTextEvent evt(wxEVT_STC_DO_DROP, stc->GetId());
	547	evt.SetEventObject(stc);
	548	evt.SetDragResult(dragResult);
	549	evt.SetX(x);
	550	evt.SetY(y);
	551	evt.SetPosition(PositionFromLocation(Point(x,y)));
	552	evt.SetDragText(data);
	553	stc->GetEventHandler()->ProcessEvent(evt);
	554
	555	dragResult = evt.GetDragResult();
	556	if (dragResult == wxDragMove \|\| dragResult == wxDragCopy) {
	557	DropAt(evt.GetPosition(),
	558	evt.GetDragText(),
	559	dragResult == wxDragMove,
	560	FALSE); // TODO: rectangular?
	561	return TRUE;
	562	}
	563	return FALSE;
	564	}
	565
	566
	567	wxDragResult ScintillaWX::DoDragEnter(wxCoord x, wxCoord y, wxDragResult def) {
	568	dragResult = def;
	569	return dragResult;
	570	}
	571
	572
	573	wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
	574	SetDragPosition(PositionFromLocation(Point(x, y)));
	575
	576	// Send an event to allow the drag result to be changed
	577	wxStyledTextEvent evt(wxEVT_STC_DRAG_OVER, stc->GetId());
	578	evt.SetEventObject(stc);
	579	evt.SetDragResult(def);
	580	evt.SetX(x);
	581	evt.SetY(y);
	582	evt.SetPosition(PositionFromLocation(Point(x,y)));
	583	stc->GetEventHandler()->ProcessEvent(evt);
	584
	585	dragResult = evt.GetDragResult();
	586	return dragResult;
	587	}
	588
	589
	590	void ScintillaWX::DoDragLeave() {
	591	SetDragPosition(invalidPosition);
	592	}
	593	#endif
	594	//----------------------------------------------------------------------
	595
	596	// Redraw all of text area. This paint will not be abandoned.
	597	void ScintillaWX::FullPaint() {
	598	paintState = painting;
	599	rcPaint = GetTextRectangle();
	600	paintingAllText = true;
	601	wxClientDC dc(stc);
	602	Surface surfaceWindow;
	603	surfaceWindow.Init(&dc);
	604	Paint(&surfaceWindow, rcPaint);
	605	surfaceWindow.Release();
	606
	607	// stc->Refresh(FALSE);
	608
	609	paintState = notPainting;
	610	}
	611
	612
	613	void ScintillaWX::DoScrollToLine(int line) {
	614	ScrollTo(line);
	615	}
	616
	617
	618	void ScintillaWX::DoScrollToColumn(int column) {
	619	HorizontalScrollTo(column * vs.spaceWidth);
	620	}
	621
	622
	623
	624	//----------------------------------------------------------------------
	625	//----------------------------------------------------------------------