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