]> git.saurik.com Git - wxWidgets.git/blob - src/stc/stc.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxFrame's m_mainWidget didn't have themes.
[wxWidgets.git] / src / stc / stc.cpp
1 ////////////////////////////////////////////////////////////////////////////
2 // Name: stc.cpp
3 // Purpose: A wxWindows implementation of Scintilla. This class is the
4 // one meant to be used directly by wx applications. It does not
5 // derive directly from the Scintilla classes, but instead
6 // delegates most things to the real Scintilla class.
7 // This allows the use of Scintilla without polluting the
8 // namespace with all the classes and identifiers from Scintilla.
9 //
10 // Author: Robin Dunn
11 //
12 // Created: 13-Jan-2000
13 // RCS-ID: $Id$
14 // Copyright: (c) 2000 by Total Control Software
15 // Licence: wxWindows license
16 /////////////////////////////////////////////////////////////////////////////
17
18 #include <ctype.h>
19
20 #include "wx/stc/stc.h"
21 #include "ScintillaWX.h"
22
23 #include <wx/tokenzr.h>
24
25 // The following code forces a reference to all of the Scintilla lexers.
26 // If we don't do something like this, then the linker tends to "optimize"
27 // them away. (eric@sourcegear.com)
28
29 static int wxForceScintillaLexers(void)
30 {
31 extern LexerModule lmCPP;
32 extern LexerModule lmHTML;
33 extern LexerModule lmXML;
34 extern LexerModule lmProps;
35 extern LexerModule lmErrorList;
36 extern LexerModule lmMake;
37 extern LexerModule lmBatch;
38 extern LexerModule lmPerl;
39 extern LexerModule lmPython;
40 extern LexerModule lmSQL;
41 extern LexerModule lmVB;
42 extern LexerModule lmLua;
43
44 if (
45 &lmCPP
46 && &lmHTML
47 && &lmXML
48 && &lmProps
49 && &lmErrorList
50 && &lmMake
51 && &lmBatch
52 && &lmPerl
53 && &lmPython
54 && &lmSQL
55 && &lmVB
56 && &lmLua
57 )
58 {
59 return 1;
60 }
61 }
62
63 //----------------------------------------------------------------------
64
65 const wxChar* wxSTCNameStr = "stcwindow";
66
67 BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
68 EVT_PAINT (wxStyledTextCtrl::OnPaint)
69 EVT_SCROLLWIN (wxStyledTextCtrl::OnScrollWin)
70 EVT_SIZE (wxStyledTextCtrl::OnSize)
71 EVT_LEFT_DOWN (wxStyledTextCtrl::OnMouseLeftDown)
72 EVT_MOTION (wxStyledTextCtrl::OnMouseMove)
73 EVT_LEFT_UP (wxStyledTextCtrl::OnMouseLeftUp)
74 EVT_RIGHT_UP (wxStyledTextCtrl::OnMouseRightUp)
75 EVT_CHAR (wxStyledTextCtrl::OnChar)
76 EVT_KEY_DOWN (wxStyledTextCtrl::OnKeyDown)
77 EVT_KILL_FOCUS (wxStyledTextCtrl::OnLoseFocus)
78 EVT_SET_FOCUS (wxStyledTextCtrl::OnGainFocus)
79 EVT_SYS_COLOUR_CHANGED (wxStyledTextCtrl::OnSysColourChanged)
80 EVT_ERASE_BACKGROUND (wxStyledTextCtrl::OnEraseBackground)
81 EVT_MENU_RANGE (-1, -1, wxStyledTextCtrl::OnMenu)
82 EVT_LISTBOX_DCLICK (-1, wxStyledTextCtrl::OnListBox)
83 END_EVENT_TABLE()
84
85
86 IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
87 IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
88
89 //----------------------------------------------------------------------
90 // Constructor and Destructor
91
92 wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
93 wxWindowID id,
94 const wxPoint& pos,
95 const wxSize& size,
96 long style,
97 const wxString& name) :
98 wxControl(parent, id, pos, size,
99 style | wxVSCROLL | wxHSCROLL | wxWANTS_CHARS,
100 wxDefaultValidator, name)
101 {
102 m_swx = new ScintillaWX(this);
103 // m_keywords = new WordList;
104 m_stopWatch.Start();
105 m_readOnly = false;
106 m_undoType = wxSTC_UndoCollectAutoStart;
107 }
108
109
110 wxStyledTextCtrl::~wxStyledTextCtrl() {
111 delete m_swx;
112 // delete m_keywords;
113 }
114
115
116 //----------------------------------------------------------------------
117
118 long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
119
120 return m_swx->WndProc(msg, wp, lp);
121 }
122
123
124 //----------------------------------------------------------------------
125 // Text retrieval and modification
126
127 wxString wxStyledTextCtrl::GetText() {
128 wxString text;
129 int len = GetTextLength();
130 char* buff = text.GetWriteBuf(len+1);
131
132 SendMsg(SCI_GETTEXT, len, (long)buff);
133 buff[len] = 0;
134 text.UngetWriteBuf();
135 return text;
136 }
137
138
139 bool wxStyledTextCtrl::SetText(const wxString& text) {
140 return SendMsg(SCI_SETTEXT, 0, (long)text.c_str()) != 0;
141 }
142
143
144 wxString wxStyledTextCtrl::GetLine(int line) {
145 wxString text;
146 int len = GetLineLength(line);
147 char* buff = text.GetWriteBuf(len+1);
148
149 SendMsg(SCI_GETLINE, line, (long)buff);
150 buff[len] = 0;
151 text.UngetWriteBuf();
152 return text;
153 }
154
155
156 void wxStyledTextCtrl::ReplaceSelection(const wxString& text) {
157 SendMsg(SCI_REPLACESEL, 0, (long)text.c_str());
158 }
159
160
161 void wxStyledTextCtrl::SetReadOnly(bool readOnly) {
162 SendMsg(SCI_SETREADONLY, (long)readOnly);
163 m_readOnly = readOnly;
164 }
165
166
167 bool wxStyledTextCtrl::GetReadOnly() {
168 // TODO: need support in Scintilla to do this right,
169 // until then we'll track it ourselves
170 return m_readOnly;
171 }
172
173
174 void wxStyledTextCtrl::GetTextRange(int startPos, int endPos, char* buff) {
175 TextRange tr;
176 tr.lpstrText = buff;
177 tr.chrg.cpMin = startPos;
178 tr.chrg.cpMax = endPos;
179 SendMsg(SCI_GETTEXTRANGE, 0, (long)&tr);
180 }
181
182
183 wxString wxStyledTextCtrl::GetTextRange(int startPos, int endPos) {
184 wxString text;
185 int len = endPos - startPos;
186 char* buff = text.GetWriteBuf(len+1);
187 GetTextRange(startPos, endPos, buff);
188 text.UngetWriteBuf();
189 return text;
190 }
191
192
193 void wxStyledTextCtrl::GetStyledTextRange(int startPos, int endPos, char* buff) {
194 TextRange tr;
195 tr.lpstrText = buff;
196 tr.chrg.cpMin = startPos;
197 tr.chrg.cpMax = endPos;
198 SendMsg(SCI_GETSTYLEDTEXT, 0, (long)&tr);
199 }
200
201
202 wxString wxStyledTextCtrl::GetStyledTextRange(int startPos, int endPos) {
203 wxString text;
204 int len = endPos - startPos;
205 char* buff = text.GetWriteBuf(len*2+1);
206 GetStyledTextRange(startPos, endPos, buff);
207 text.UngetWriteBuf(len*2);
208 return text;
209 }
210
211
212 void wxStyledTextCtrl::AddText(const wxString& text) {
213 SendMsg(SCI_ADDTEXT, text.Len(), (long)text.c_str());
214 }
215
216
217 void wxStyledTextCtrl::AddStyledText(const wxString& text) {
218 SendMsg(SCI_ADDSTYLEDTEXT, text.Len(), (long)text.c_str());
219 }
220
221
222 void wxStyledTextCtrl::InsertText(int pos, const wxString& text) {
223 SendMsg(SCI_INSERTTEXT, pos, (long)text.c_str());
224 }
225
226
227 void wxStyledTextCtrl::ClearAll() {
228 SendMsg(SCI_CLEARALL);
229 }
230
231
232 char wxStyledTextCtrl::GetCharAt(int pos) {
233 return SendMsg(SCI_GETCHARAT, pos);
234 }
235
236
237 char wxStyledTextCtrl::GetStyleAt(int pos) {
238 return SendMsg(SCI_GETSTYLEAT, pos);
239 }
240
241
242 void wxStyledTextCtrl::SetStyleBits(int bits) {
243 SendMsg(SCI_SETSTYLEBITS, bits);
244 }
245
246
247 int wxStyledTextCtrl::GetStyleBits() {
248 return SendMsg(SCI_GETSTYLEBITS);
249 }
250
251
252 //----------------------------------------------------------------------
253 // Clipboard
254
255
256 void wxStyledTextCtrl::Cut() {
257 SendMsg(SCI_CUT);
258 }
259
260
261 void wxStyledTextCtrl::Copy() {
262 SendMsg(SCI_COPY);
263 }
264
265
266 void wxStyledTextCtrl::Paste() {
267 SendMsg(SCI_PASTE);
268 }
269
270
271 bool wxStyledTextCtrl::CanPaste() {
272 return SendMsg(SCI_CANPASTE) != 0;
273 }
274
275
276 void wxStyledTextCtrl::ClearClipbrd() {
277 SendMsg(SCI_CLEAR);
278 }
279
280
281
282 //----------------------------------------------------------------------
283 // Undo and Redo
284
285 void wxStyledTextCtrl::Undo() {
286 SendMsg(SCI_UNDO);
287 }
288
289
290 bool wxStyledTextCtrl::CanUndo() {
291 return SendMsg(SCI_CANUNDO) != 0;
292 }
293
294
295 void wxStyledTextCtrl::EmptyUndoBuffer() {
296 SendMsg(SCI_EMPTYUNDOBUFFER);
297 }
298
299
300 void wxStyledTextCtrl::Redo() {
301 SendMsg(SCI_REDO);
302 }
303
304
305 bool wxStyledTextCtrl::CanRedo() {
306 return SendMsg(SCI_CANREDO) != 0;
307 }
308
309
310 void wxStyledTextCtrl::SetUndoCollection(wxSTC_UndoType type) {
311 SendMsg(SCI_SETUNDOCOLLECTION, type);
312 m_undoType = type;
313 }
314
315
316 wxSTC_UndoType wxStyledTextCtrl::GetUndoCollection() {
317 // TODO: need support in Scintilla to do this right,
318 // until then we'll track it ourselves
319 return m_undoType;
320 }
321
322
323 void wxStyledTextCtrl::BeginUndoAction() {
324 SendMsg(SCI_BEGINUNDOACTION);
325 }
326
327
328 void wxStyledTextCtrl::EndUndoAction() {
329 SendMsg(SCI_ENDUNDOACTION);
330 }
331
332
333
334
335 //----------------------------------------------------------------------
336 // Selection and information
337
338
339 void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
340 // SendMsg(EM_GETSEL, (long)startPos, (long)endPos);
341 *startPos = SendMsg(SCI_GETSELECTIONSTART);
342 *endPos = SendMsg(SCI_GETSELECTIONEND);
343 }
344
345
346 void wxStyledTextCtrl::SetSelection(int startPos, int endPos) {
347 SendMsg(SCI_SETSEL, startPos, endPos);
348 }
349
350
351 wxString wxStyledTextCtrl::GetSelectedText() {
352 wxString text;
353 int start;
354 int end;
355
356 GetSelection(&start, &end);
357 int len = end - start;
358 char* buff = text.GetWriteBuf(len+1);
359
360 SendMsg(SCI_GETSELTEXT, 0, (long)buff);
361 text.UngetWriteBuf();
362 return text;
363 }
364
365
366 void wxStyledTextCtrl::HideSelection(bool hide) {
367 SendMsg(SCI_HIDESELECTION, hide);
368 }
369
370
371 bool wxStyledTextCtrl::GetHideSelection() {
372 return m_swx->GetHideSelection();
373 }
374
375
376 int wxStyledTextCtrl::GetTextLength() {
377 return SendMsg(SCI_GETTEXTLENGTH);
378 }
379
380
381 int wxStyledTextCtrl::GetFirstVisibleLine() {
382 return SendMsg(SCI_GETFIRSTVISIBLELINE);
383 }
384
385
386 int wxStyledTextCtrl::GetLineCount() {
387 return SendMsg(SCI_GETLINECOUNT);
388 }
389
390
391 bool wxStyledTextCtrl::GetModified() {
392 return SendMsg(SCI_GETMODIFY) != 0;
393 }
394
395
396 int wxStyledTextCtrl::GetLineFromPos(int pos) {
397 return SendMsg(SCI_LINEFROMPOSITION, pos);
398 }
399
400
401 int wxStyledTextCtrl::GetLineStartPos(int line) {
402 return SendMsg(SCI_POSITIONFROMLINE, line);
403 }
404
405
406 int wxStyledTextCtrl::GetLineLength(int line) {
407 return SendMsg(SCI_LINELENGTH, line);
408 }
409
410
411 int wxStyledTextCtrl::GetCurrentLine() {
412 int line = GetLineFromPos(GetCurrentPos());
413 return line;
414 }
415
416
417 wxString wxStyledTextCtrl::GetCurrentLineText(int* linePos) {
418 wxString text;
419 int len = GetLineLength(GetCurrentLine());
420 char* buff = text.GetWriteBuf(len+1);
421
422 int pos = SendMsg(SCI_GETCURLINE, len, (long)buff);
423 text.UngetWriteBuf();
424
425 if (linePos)
426 *linePos = pos;
427
428 return text;
429 }
430
431
432 int wxStyledTextCtrl::PositionFromPoint(wxPoint pt) {
433 return SendMsg(SCI_POSITIONFROMPOINT, pt.x, pt.y);
434 }
435
436
437 wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
438 int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
439 int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
440 return wxPoint(x, y);
441 }
442
443
444 int wxStyledTextCtrl::GetCurrentPos() {
445 return SendMsg(SCI_GETCURRENTPOS);
446 }
447
448
449 int wxStyledTextCtrl::GetAnchor() {
450 return SendMsg(SCI_GETANCHOR);
451 }
452
453
454 void wxStyledTextCtrl::SelectAll() {
455 SendMsg(SCI_SELECTALL);
456 }
457
458
459 void wxStyledTextCtrl::SetCurrentPosition(int pos) {
460 SendMsg(SCI_GOTOPOS, pos);
461 }
462
463
464 void wxStyledTextCtrl::SetAnchor(int pos) {
465 SendMsg(SCI_SETANCHOR, pos);
466 }
467
468
469 void wxStyledTextCtrl::GotoPos(int pos) {
470 SendMsg(SCI_GOTOPOS, pos);
471 }
472
473
474 void wxStyledTextCtrl::GotoLine(int line) {
475 SendMsg(SCI_GOTOLINE, line);
476 }
477
478
479 void wxStyledTextCtrl::ChangePosition(int delta, bool extendSelection) {
480 // TODO: Is documented but doesn't seem to be implemented
481 //SendMsg(SCI_CHANGEPOSITION, delta, extendSelection);
482 }
483
484
485 void wxStyledTextCtrl::PageMove(int cmdKey, bool extendSelection) {
486 // TODO: Is documented but doesn't seem to be implemented
487 //SendMsg(SCI_PAGEMOVE, cmdKey, extendSelection);
488 }
489
490
491 void wxStyledTextCtrl::ScrollBy(int columnDelta, int lineDelta) {
492 SendMsg(SCI_LINESCROLL, columnDelta, lineDelta);
493 }
494
495 void wxStyledTextCtrl::ScrollToLine(int line) {
496 m_swx->DoScrollToLine(line);
497 }
498
499
500 void wxStyledTextCtrl::ScrollToColumn(int column) {
501 m_swx->DoScrollToColumn(column);
502 }
503
504
505 void wxStyledTextCtrl::EnsureCaretVisible() {
506 SendMsg(SCI_SCROLLCARET);
507 }
508
509
510 void wxStyledTextCtrl::SetCaretPolicy(int policy, int slop) {
511 SendMsg(SCI_SETCARETPOLICY, policy, slop);
512 }
513
514
515 int wxStyledTextCtrl::GetLinesOnScreen() {
516 return SendMsg(SCI_LINESONSCREEN);
517 }
518
519
520 bool wxStyledTextCtrl::IsSelectionRectangle() {
521 return SendMsg(SCI_SELECTIONISRECTANGLE) != 0;
522 }
523
524
525 void wxStyledTextCtrl::SetUseHorizontalScrollBar(bool use) {
526 SendMsg(SCI_SETHSCROLLBAR, use);
527 }
528
529
530 bool wxStyledTextCtrl::GetUseHorizontalScrollBar() {
531 return SendMsg(SCI_GETHSCROLLBAR) != 0;
532 }
533
534
535
536
537
538 //----------------------------------------------------------------------
539 // Searching
540
541 int wxStyledTextCtrl::FindText(int minPos, int maxPos,
542 const wxString& text,
543 bool caseSensitive, bool wholeWord) {
544 TextToFind ft;
545 int flags = 0;
546
547 flags |= caseSensitive ? SCFIND_MATCHCASE : 0;
548 flags |= wholeWord ? SCFIND_WHOLEWORD : 0;
549 ft.chrg.cpMin = minPos;
550 ft.chrg.cpMax = maxPos;
551 ft.lpstrText = (char*)text.c_str();
552
553 return SendMsg(SCI_FINDTEXT, flags, (long)&ft);
554 }
555
556
557 void wxStyledTextCtrl::SearchAnchor() {
558 SendMsg(SCI_SEARCHANCHOR);
559 }
560
561
562 int wxStyledTextCtrl::SearchNext(const wxString& text, bool caseSensitive, bool wholeWord) {
563 int flags = 0;
564 flags |= caseSensitive ? SCFIND_MATCHCASE : 0;
565 flags |= wholeWord ? SCFIND_WHOLEWORD : 0;
566
567 return SendMsg(SCI_SEARCHNEXT, flags, (long)text.c_str());
568 }
569
570
571 int wxStyledTextCtrl::SearchPrev(const wxString& text, bool caseSensitive, bool wholeWord) {
572 int flags = 0;
573 flags |= caseSensitive ? SCFIND_MATCHCASE : 0;
574 flags |= wholeWord ? SCFIND_WHOLEWORD : 0;
575
576 return SendMsg(SCI_SEARCHPREV, flags, (long)text.c_str());
577 }
578
579 //----------------------------------------------------------------------
580 // Visible whitespace
581
582
583 bool wxStyledTextCtrl::GetViewWhitespace() {
584 return SendMsg(SCI_GETVIEWWS) != 0;
585 }
586
587
588 void wxStyledTextCtrl::SetViewWhitespace(bool visible) {
589 SendMsg(SCI_SETVIEWWS, visible);
590 }
591
592
593
594 //----------------------------------------------------------------------
595 // Line endings
596
597 wxSTC_EOL wxStyledTextCtrl::GetEOLMode() {
598 return (wxSTC_EOL)SendMsg(SCI_GETEOLMODE);
599 }
600
601
602 void wxStyledTextCtrl::SetEOLMode(wxSTC_EOL mode) {
603 SendMsg(SCI_SETEOLMODE, mode);
604 }
605
606
607 bool wxStyledTextCtrl::GetViewEOL() {
608 return SendMsg(SCI_GETVIEWEOL) != 0;
609 }
610
611
612 void wxStyledTextCtrl::SetViewEOL(bool visible) {
613 SendMsg(SCI_SETVIEWEOL, visible);
614 }
615
616 void wxStyledTextCtrl::ConvertEOL(wxSTC_EOL mode) {
617 SendMsg(SCI_CONVERTEOLS, mode);
618 }
619
620 //----------------------------------------------------------------------
621 // Styling
622
623 int wxStyledTextCtrl::GetEndStyled() {
624 return SendMsg(SCI_GETENDSTYLED);
625 }
626
627
628 void wxStyledTextCtrl::StartStyling(int pos, int mask) {
629 SendMsg(SCI_STARTSTYLING, pos, mask);
630 }
631
632
633 void wxStyledTextCtrl::SetStyleFor(int length, int style) {
634 SendMsg(SCI_SETSTYLING, length, style);
635 }
636
637
638 void wxStyledTextCtrl::SetStyleBytes(int length, char* styleBytes) {
639 SendMsg(SCI_SETSTYLINGEX, length, (long)styleBytes);
640 }
641
642
643 void wxStyledTextCtrl::SetLineState(int line, int value) {
644 SendMsg(SCI_SETLINESTATE, line, value);
645 }
646
647
648 int wxStyledTextCtrl::GetLineState(int line) {
649 return SendMsg(SCI_GETLINESTATE, line);
650 }
651
652
653 //----------------------------------------------------------------------
654 // Style Definition
655
656
657 static long wxColourAsLong(const wxColour& co) {
658 return (((long)co.Blue() << 16) |
659 ((long)co.Green() << 8) |
660 ((long)co.Red()));
661 }
662
663 static wxColour wxColourFromLong(long c) {
664 wxColour clr;
665 clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
666 return clr;
667 }
668
669
670 static wxColour wxColourFromSpec(const wxString& spec) {
671 // spec should be #RRGGBB
672 char* junk;
673 int red = strtol(spec.Mid(1,2), &junk, 16);
674 int green = strtol(spec.Mid(3,2), &junk, 16);
675 int blue = strtol(spec.Mid(5,2), &junk, 16);
676 return wxColour(red, green, blue);
677 }
678
679
680 void wxStyledTextCtrl::StyleClearAll() {
681 SendMsg(SCI_STYLECLEARALL);
682 }
683
684
685 void wxStyledTextCtrl::StyleResetDefault() {
686 SendMsg(SCI_STYLERESETDEFAULT);
687 }
688
689
690
691 // Extract style settings from a spec-string which is composed of one or
692 // more of the following comma separated elements:
693 //
694 // bold turns on bold
695 // italic turns on italics
696 // fore:#RRGGBB sets the foreground colour
697 // back:#RRGGBB sets the background colour
698 // face:[facename] sets the font face name to use
699 // size:[num] sets the font size in points
700 // eol turns on eol filling
701 // underline turns on underlining
702 //
703
704 void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
705
706 wxStringTokenizer tkz(spec, ",");
707 while (tkz.HasMoreTokens()) {
708 wxString token = tkz.GetNextToken();
709
710 wxString option = token.BeforeFirst(':');
711 wxString val = token.AfterFirst(':');
712
713 if (option == "bold")
714 StyleSetBold(styleNum, true);
715
716 else if (option == "italic")
717 StyleSetItalic(styleNum, true);
718
719 else if (option == "underline")
720 StyleSetUnderline(styleNum, true);
721
722 else if (option == "eol")
723 StyleSetEOLFilled(styleNum, true);
724
725 else if (option == "size") {
726 long points;
727 if (val.ToLong(&points))
728 StyleSetSize(styleNum, points);
729 }
730
731 else if (option == "face")
732 StyleSetFaceName(styleNum, val);
733
734 else if (option == "fore")
735 StyleSetForeground(styleNum, wxColourFromSpec(val));
736
737 else if (option == "back")
738 StyleSetBackground(styleNum, wxColourFromSpec(val));
739 }
740 }
741
742
743 void wxStyledTextCtrl::StyleSetForeground(int styleNum, const wxColour& colour) {
744 SendMsg(SCI_STYLESETFORE, styleNum, wxColourAsLong(colour));
745 }
746
747
748 void wxStyledTextCtrl::StyleSetBackground(int styleNum, const wxColour& colour) {
749 SendMsg(SCI_STYLESETBACK, styleNum, wxColourAsLong(colour));
750 }
751
752
753 void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
754 int size = font.GetPointSize();
755 wxString faceName = font.GetFaceName();
756 bool bold = font.GetWeight() == wxBOLD;
757 bool italic = font.GetStyle() != wxNORMAL;
758 bool under = font.GetUnderlined();
759
760 StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
761 }
762
763
764 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
765 const wxString& faceName,
766 bool bold, bool italic,
767 bool underline) {
768 StyleSetSize(styleNum, size);
769 StyleSetFaceName(styleNum, faceName);
770 StyleSetBold(styleNum, bold);
771 StyleSetItalic(styleNum, italic);
772 StyleSetUnderline(styleNum, underline);
773 }
774
775
776 void wxStyledTextCtrl::StyleSetBold(int styleNum, bool bold) {
777 SendMsg(SCI_STYLESETBOLD, styleNum, bold);
778 }
779
780
781 void wxStyledTextCtrl::StyleSetItalic(int styleNum, bool italic) {
782 SendMsg(SCI_STYLESETITALIC, styleNum, italic);
783 }
784
785
786 void wxStyledTextCtrl::StyleSetFaceName(int styleNum, const wxString& faceName) {
787 SendMsg(SCI_STYLESETFONT, styleNum, (long)faceName.c_str());
788 }
789
790
791 void wxStyledTextCtrl::StyleSetSize(int styleNum, int pointSize) {
792 SendMsg(SCI_STYLESETSIZE, styleNum, pointSize);
793 }
794
795
796 void wxStyledTextCtrl::StyleSetEOLFilled(int styleNum, bool fillEOL) {
797 SendMsg(SCI_STYLESETEOLFILLED, styleNum, fillEOL);
798 }
799
800
801 void wxStyledTextCtrl::StyleSetUnderline(int styleNum, bool underline) {
802 SendMsg(SCI_STYLESETUNDERLINE, styleNum, underline);
803 }
804
805
806 //----------------------------------------------------------------------
807 // Margins in the edit area
808
809 int wxStyledTextCtrl::GetLeftMargin() {
810 return SendMsg(SCI_GETMARGINLEFT);
811 }
812
813
814 int wxStyledTextCtrl::GetRightMargin() {
815 return SendMsg(SCI_GETMARGINRIGHT);
816 }
817
818
819 void wxStyledTextCtrl::SetMargins(int left, int right) {
820 int flag = 0;
821
822 if (right != -1) {
823 SendMsg(SCI_SETMARGINRIGHT, 0, right);
824 }
825 if (left != -1) {
826 SendMsg(SCI_SETMARGINLEFT, 0, left);
827 }
828 }
829
830
831 //----------------------------------------------------------------------
832 // Margins for selection, markers, etc.
833
834 void wxStyledTextCtrl::SetMarginType(int margin, int type) {
835 SendMsg(SCI_SETMARGINTYPEN, margin, type);
836 }
837
838
839 int wxStyledTextCtrl::GetMarginType(int margin) {
840 return SendMsg(SCI_GETMARGINTYPEN, margin);
841 }
842
843
844 void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) {
845 SendMsg(SCI_SETMARGINWIDTHN, margin, pixelWidth);
846 }
847
848
849 int wxStyledTextCtrl::GetMarginWidth(int margin) {
850 return SendMsg(SCI_GETMARGINWIDTHN, margin);
851 }
852
853
854 void wxStyledTextCtrl::SetMarginMask(int margin, int mask) {
855 SendMsg(SCI_SETMARGINMASKN, margin, mask);
856 }
857
858
859 int wxStyledTextCtrl::GetMarginMask(int margin) {
860 return SendMsg(SCI_GETMARGINMASKN, margin);
861 }
862
863
864 void wxStyledTextCtrl::SetMarginSensitive(int margin, bool sensitive) {
865 SendMsg(SCI_SETMARGINSENSITIVEN, margin, sensitive);
866 }
867
868
869 bool wxStyledTextCtrl::GetMarginSensitive(int margin) {
870 return SendMsg(SCI_GETMARGINSENSITIVEN, margin) != 0;
871 }
872
873
874
875
876 //----------------------------------------------------------------------
877 // Selection and Caret styles
878
879
880 void wxStyledTextCtrl::SetSelectionForeground(const wxColour& colour) {
881 SendMsg(SCI_SETSELFORE, 0, wxColourAsLong(colour));
882 }
883
884
885 void wxStyledTextCtrl::SetSelectionBackground(const wxColour& colour) {
886 SendMsg(SCI_SETSELBACK, 0, wxColourAsLong(colour));
887 }
888
889
890 void wxStyledTextCtrl::SetCaretForeground(const wxColour& colour) {
891 SendMsg(SCI_SETCARETFORE, wxColourAsLong(colour));
892 }
893
894
895 int wxStyledTextCtrl::GetCaretPeriod() {
896 return SendMsg(SCI_GETCARETPERIOD);
897 }
898
899
900 void wxStyledTextCtrl::SetCaretPeriod(int milliseconds) {
901 SendMsg(SCI_SETCARETPERIOD, milliseconds);
902 }
903
904
905
906 //----------------------------------------------------------------------
907 // Other settings
908
909
910 void wxStyledTextCtrl::SetBufferedDraw(bool isBuffered) {
911 SendMsg(SCI_SETBUFFEREDDRAW, isBuffered);
912 }
913
914
915 void wxStyledTextCtrl::SetTabWidth(int numChars) {
916 SendMsg(SCI_SETTABWIDTH, numChars);
917 }
918
919
920 void wxStyledTextCtrl::SetIndent(int numChars) {
921 SendMsg(SCI_SETINDENT, numChars);
922 }
923
924
925 void wxStyledTextCtrl::SetUseTabs(bool usetabs) {
926 SendMsg(SCI_SETUSETABS, usetabs);
927 }
928
929
930 void wxStyledTextCtrl::SetLineIndentation(int line, int indentation) {
931 SendMsg(SCI_SETLINEINDENTATION, line, indentation);
932 }
933
934
935 int wxStyledTextCtrl:: GetLineIndentation(int line) {
936 return SendMsg(SCI_GETLINEINDENTATION, line);
937 }
938
939
940 int wxStyledTextCtrl::GetLineIndentationPos(int line) {
941 return SendMsg(SCI_GETLINEINDENTPOSITION, line);
942 }
943
944
945 void wxStyledTextCtrl::SetWordChars(const wxString& wordChars) {
946 SendMsg(SCI_SETTABWIDTH, 0, (long)wordChars.c_str());
947 }
948
949
950 void wxStyledTextCtrl::SetUsePop(bool usepopup) {
951 SendMsg(SCI_USEPOPUP, usepopup);
952 }
953
954
955 //----------------------------------------------------------------------
956 // Brace highlighting
957
958
959 void wxStyledTextCtrl::BraceHighlight(int pos1, int pos2) {
960 SendMsg(SCI_BRACEHIGHLIGHT, pos1, pos2);
961 }
962
963
964 void wxStyledTextCtrl::BraceBadlight(int pos) {
965 SendMsg(SCI_BRACEBADLIGHT, pos);
966 }
967
968
969 int wxStyledTextCtrl::BraceMatch(int pos, int maxReStyle) {
970 return SendMsg(SCI_BRACEMATCH, pos, maxReStyle);
971 }
972
973
974
975 //----------------------------------------------------------------------
976 // Markers
977
978 void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol,
979 const wxColour& foreground,
980 const wxColour& background) {
981 MarkerSetType(markerNumber, markerSymbol);
982 MarkerSetForeground(markerNumber, foreground);
983 MarkerSetBackground(markerNumber, background);
984 }
985
986
987 void wxStyledTextCtrl::MarkerSetType(int markerNumber, int markerSymbol) {
988 SendMsg(SCI_MARKERDEFINE, markerNumber, markerSymbol);
989 }
990
991
992 void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour& colour) {
993 SendMsg(SCI_MARKERSETFORE, markerNumber, wxColourAsLong(colour));
994 }
995
996
997 void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour& colour) {
998 SendMsg(SCI_MARKERSETBACK, markerNumber, wxColourAsLong(colour));
999 }
1000
1001
1002 int wxStyledTextCtrl::MarkerAdd(int line, int markerNumber) {
1003 return SendMsg(SCI_MARKERADD, line, markerNumber);
1004 }
1005
1006
1007 void wxStyledTextCtrl::MarkerDelete(int line, int markerNumber) {
1008 SendMsg(SCI_MARKERDELETE, line, markerNumber);
1009 }
1010
1011
1012 void wxStyledTextCtrl::MarkerDeleteAll(int markerNumber) {
1013 SendMsg(SCI_MARKERDELETEALL, markerNumber);
1014 }
1015
1016
1017 int wxStyledTextCtrl::MarkerGet(int line) {
1018 return SendMsg(SCI_MARKERGET);
1019 }
1020
1021
1022 int wxStyledTextCtrl::MarkerGetNextLine(int lineStart, int markerMask) {
1023 return SendMsg(SCI_MARKERNEXT, lineStart, markerMask);
1024 }
1025
1026
1027 int wxStyledTextCtrl::MarkerGetPrevLine(int lineStart, int markerMask) {
1028 // return SendMsg(SCI_MARKERPREV, lineStart, markerMask);
1029 return 0;
1030 }
1031
1032
1033 int wxStyledTextCtrl::MarkerLineFromHandle(int handle) {
1034 return SendMsg(SCI_MARKERLINEFROMHANDLE, handle);
1035 }
1036
1037
1038 void wxStyledTextCtrl::MarkerDeleteHandle(int handle) {
1039 SendMsg(SCI_MARKERDELETEHANDLE, handle);
1040 }
1041
1042
1043
1044 //----------------------------------------------------------------------
1045 // Indicators
1046
1047
1048 void wxStyledTextCtrl::IndicatorSetStyle(int indicNum, int indicStyle) {
1049 SendMsg(SCI_INDICSETSTYLE, indicNum, indicStyle);
1050 }
1051
1052
1053 int wxStyledTextCtrl::IndicatorGetStyle(int indicNum) {
1054 return SendMsg(SCI_INDICGETSTYLE, indicNum);
1055 }
1056
1057
1058 void wxStyledTextCtrl::IndicatorSetColour(int indicNum, const wxColour& colour) {
1059 SendMsg(SCI_INDICSETFORE, indicNum, wxColourAsLong(colour));
1060 }
1061
1062
1063
1064 //----------------------------------------------------------------------
1065 // Auto completion
1066
1067
1068 void wxStyledTextCtrl::AutoCompShow(const wxString& listOfWords) {
1069 SendMsg(SCI_AUTOCSHOW, 0, (long)listOfWords.c_str());
1070 }
1071
1072
1073 void wxStyledTextCtrl::AutoCompCancel() {
1074 SendMsg(SCI_AUTOCCANCEL);
1075 }
1076
1077
1078 bool wxStyledTextCtrl::AutoCompActive() {
1079 return SendMsg(SCI_AUTOCACTIVE) != 0;
1080 }
1081
1082
1083 int wxStyledTextCtrl::AutoCompPosAtStart() {
1084 return SendMsg(SCI_AUTOCPOSSTART);
1085 }
1086
1087
1088 void wxStyledTextCtrl::AutoCompComplete() {
1089 SendMsg(SCI_AUTOCCOMPLETE);
1090 }
1091
1092
1093 void wxStyledTextCtrl::AutoCompStopChars(const wxString& stopChars) {
1094 SendMsg(SCI_AUTOCSHOW, 0, (long)stopChars.c_str());
1095 }
1096
1097
1098 void wxStyledTextCtrl::AutoCompSetSeparator(char separator) {
1099 SendMsg(SCI_AUTOCSETSEPARATOR, separator);
1100 }
1101
1102
1103 char wxStyledTextCtrl::AutoCompGetSeparator() {
1104 return SendMsg(SCI_AUTOCGETSEPARATOR);
1105 }
1106
1107
1108 void wxStyledTextCtrl::AutoCompSelect(const wxString& stringtoselect) {
1109 SendMsg(SCI_AUTOCSELECT, (long)stringtoselect.c_str());
1110 }
1111
1112
1113 //----------------------------------------------------------------------
1114 // Call tips
1115
1116 void wxStyledTextCtrl::CallTipShow(int pos, const wxString& text) {
1117 SendMsg(SCI_CALLTIPSHOW, pos, (long)text.c_str());
1118 }
1119
1120
1121 void wxStyledTextCtrl::CallTipCancel() {
1122 SendMsg(SCI_CALLTIPCANCEL);
1123 }
1124
1125
1126 bool wxStyledTextCtrl::CallTipActive() {
1127 return SendMsg(SCI_CALLTIPACTIVE) != 0;
1128 }
1129
1130
1131 int wxStyledTextCtrl::CallTipPosAtStart() {
1132 return SendMsg(SCI_CALLTIPPOSSTART);
1133 }
1134
1135
1136 void wxStyledTextCtrl::CallTipSetHighlight(int start, int end) {
1137 SendMsg(SCI_CALLTIPSETHLT, start, end);
1138 }
1139
1140
1141 void wxStyledTextCtrl::CallTipSetBackground(const wxColour& colour) {
1142 SendMsg(SCI_CALLTIPSETBACK, wxColourAsLong(colour));
1143 }
1144
1145
1146 //----------------------------------------------------------------------
1147 // Key bindings
1148
1149 #define MAKELONG(a, b) ((a) | ((b) << 16))
1150
1151 void wxStyledTextCtrl::CmdKeyAssign(int key, int modifiers, int cmd) {
1152 SendMsg(SCI_ASSIGNCMDKEY, MAKELONG(key, modifiers), cmd);
1153 }
1154
1155
1156 void wxStyledTextCtrl::CmdKeyClear(int key, int modifiers) {
1157 SendMsg(SCI_CLEARCMDKEY, MAKELONG(key, modifiers));
1158 }
1159
1160
1161 void wxStyledTextCtrl::CmdKeyClearAll() {
1162 SendMsg(SCI_CLEARALLCMDKEYS);
1163 }
1164
1165
1166 void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
1167 SendMsg(cmd);
1168 }
1169
1170
1171
1172 //----------------------------------------------------------------------
1173 // Print formatting
1174
1175 int
1176 wxStyledTextCtrl::FormatRange(bool doDraw,
1177 int startPos,
1178 int endPos,
1179 wxDC* draw,
1180 wxDC* target, // Why does it use two? Can they be the same?
1181 wxRect renderRect,
1182 wxRect pageRect) {
1183 RangeToFormat fr;
1184
1185 fr.hdc = draw;
1186 fr.hdcTarget = target;
1187 fr.rc.top = renderRect.GetTop();
1188 fr.rc.left = renderRect.GetLeft();
1189 fr.rc.right = renderRect.GetRight();
1190 fr.rc.bottom = renderRect.GetBottom();
1191 fr.rcPage.top = pageRect.GetTop();
1192 fr.rcPage.left = pageRect.GetLeft();
1193 fr.rcPage.right = pageRect.GetRight();
1194 fr.rcPage.bottom = pageRect.GetBottom();
1195 fr.chrg.cpMin = startPos;
1196 fr.chrg.cpMax = endPos;
1197
1198 return SendMsg(SCI_FORMATRANGE, doDraw, (long)&fr);
1199 }
1200
1201
1202 //----------------------------------------------------------------------
1203 // Document Sharing
1204
1205 void* wxStyledTextCtrl::GetDocument() {
1206 return (void*)SendMsg(SCI_GETDOCPOINTER);
1207 }
1208
1209
1210 void wxStyledTextCtrl::SetDocument(void* document) {
1211 SendMsg(SCI_SETDOCPOINTER, 0, (long)document);
1212 }
1213
1214
1215 //----------------------------------------------------------------------
1216 // Folding
1217
1218 int wxStyledTextCtrl::VisibleFromDocLine(int docLine) {
1219 return SendMsg(SCI_VISIBLEFROMDOCLINE, docLine);
1220 }
1221
1222
1223 int wxStyledTextCtrl::DocLineFromVisible(int displayLine) {
1224 return SendMsg(SCI_DOCLINEFROMVISIBLE, displayLine);
1225 }
1226
1227
1228 int wxStyledTextCtrl::SetFoldLevel(int line, int level) {
1229 return SendMsg(SCI_SETFOLDLEVEL, line, level);
1230 }
1231
1232
1233 int wxStyledTextCtrl::GetFoldLevel(int line) {
1234 return SendMsg(SCI_GETFOLDLEVEL, line);
1235 }
1236
1237
1238 int wxStyledTextCtrl::GetLastChild(int line, int level) {
1239 return SendMsg(SCI_GETLASTCHILD, line, level);
1240 }
1241
1242
1243 int wxStyledTextCtrl::GetFoldParent(int line) {
1244 return SendMsg(SCI_GETFOLDPARENT, line);
1245 }
1246
1247
1248 void wxStyledTextCtrl::ShowLines(int lineStart, int lineEnd) {
1249 SendMsg(SCI_SHOWLINES, lineStart, lineEnd);
1250 }
1251
1252
1253 void wxStyledTextCtrl::HideLines(int lineStart, int lineEnd) {
1254 SendMsg(SCI_HIDELINES, lineStart, lineEnd);
1255 }
1256
1257
1258 bool wxStyledTextCtrl::GetLineVisible(int line) {
1259 return SendMsg(SCI_GETLINEVISIBLE, line) != 0;
1260 }
1261
1262
1263 void wxStyledTextCtrl::SetFoldExpanded(int line, bool expanded) {
1264 SendMsg(SCI_SETFOLDEXPANDED, line, expanded);
1265 }
1266
1267
1268 bool wxStyledTextCtrl::GetFoldExpanded(int line) {
1269 return SendMsg(SCI_GETFOLDEXPANDED, line) != 0;
1270 }
1271
1272
1273 void wxStyledTextCtrl::ToggleFold(int line) {
1274 SendMsg(SCI_TOGGLEFOLD, line);
1275 }
1276
1277
1278 void wxStyledTextCtrl::EnsureVisible(int line) {
1279 SendMsg(SCI_ENSUREVISIBLE, line);
1280 }
1281
1282
1283 void wxStyledTextCtrl::SetFoldFlags(int flags) {
1284 SendMsg(SCI_SETFOLDFLAGS, flags);
1285 }
1286
1287
1288 //----------------------------------------------------------------------
1289 // Zooming
1290
1291 void wxStyledTextCtrl::ZoomIn() {
1292 SendMsg(SCI_ZOOMIN);
1293 }
1294
1295
1296 void wxStyledTextCtrl::ZoomOut() {
1297 SendMsg(SCI_ZOOMOUT);
1298 }
1299
1300
1301 void wxStyledTextCtrl::SetZoom(int zoom) {
1302 SendMsg(SCI_SETZOOM, zoom);
1303 }
1304
1305
1306 int wxStyledTextCtrl::GetZoom() {
1307 return SendMsg(SCI_GETZOOM);
1308 }
1309
1310 //----------------------------------------------------------------------
1311 // Long Lines
1312
1313 int wxStyledTextCtrl::GetEdgeColumn() {
1314 return SendMsg(SCI_GETEDGECOLUMN);
1315 }
1316
1317 void wxStyledTextCtrl::SetEdgeColumn(int column) {
1318 SendMsg(SCI_SETEDGECOLUMN, column);
1319 }
1320
1321 wxSTC_EDGE wxStyledTextCtrl::GetEdgeMode() {
1322 return (wxSTC_EDGE) SendMsg(SCI_GETEDGEMODE);
1323 }
1324
1325 void wxStyledTextCtrl::SetEdgeMode(wxSTC_EDGE mode){
1326 SendMsg(SCI_SETEDGEMODE, mode);
1327 }
1328
1329 wxColour wxStyledTextCtrl::GetEdgeColour() {
1330 long c = SendMsg(SCI_GETEDGECOLOUR);
1331 return wxColourFromLong(c);
1332 }
1333
1334 void wxStyledTextCtrl::SetEdgeColour(const wxColour& colour) {
1335 SendMsg(SCI_SETEDGECOLOUR, wxColourAsLong(colour));
1336 }
1337
1338
1339 //----------------------------------------------------------------------
1340 // Lexer
1341
1342 void wxStyledTextCtrl::SetLexer(wxSTC_LEX lexer) {
1343 SendMsg(SCI_SETLEXER, lexer);
1344 }
1345
1346
1347 wxSTC_LEX wxStyledTextCtrl::GetLexer() {
1348 return (wxSTC_LEX)SendMsg(SCI_GETLEXER);
1349 }
1350
1351
1352 void wxStyledTextCtrl::Colourise(int start, int end) {
1353 SendMsg(SCI_COLOURISE, start, end);
1354 }
1355
1356
1357 void wxStyledTextCtrl::SetProperty(const wxString& key, const wxString& value) {
1358 SendMsg(SCI_SETPROPERTY, (long)key.c_str(), (long)value.c_str());
1359 }
1360
1361
1362 void wxStyledTextCtrl::SetKeywords(int keywordSet, const wxString& keywordList) {
1363 SendMsg(SCI_SETKEYWORDS, keywordSet, (long)keywordList.c_str());
1364 }
1365
1366
1367
1368 //----------------------------------------------------------------------
1369 // Event mask for Modified Event
1370
1371 void wxStyledTextCtrl::SetModEventMask(int mask) {
1372 SendMsg(SCI_SETMODEVENTMASK, mask);
1373 }
1374
1375
1376 //int wxStyledTextCtrl::GetModEventMask() {
1377 // return SendMsg(SCI_GETMODEVENTMASK);
1378 //}
1379
1380 //----------------------------------------------------------------------
1381 // Event handlers
1382
1383 void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
1384 wxPaintDC dc(this);
1385 wxRegion region = GetUpdateRegion();
1386
1387 m_swx->DoPaint(&dc, region.GetBox());
1388 }
1389
1390 void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
1391 if (evt.GetOrientation() == wxHORIZONTAL)
1392 m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
1393 else
1394 m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
1395 }
1396
1397 void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
1398 wxSize sz = GetClientSize();
1399 m_swx->DoSize(sz.x, sz.y);
1400 }
1401
1402 void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
1403 wxPoint pt = evt.GetPosition();
1404 m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
1405 evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
1406 }
1407
1408 void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
1409 wxPoint pt = evt.GetPosition();
1410 m_swx->DoButtonMove(Point(pt.x, pt.y));
1411 }
1412
1413 void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
1414 wxPoint pt = evt.GetPosition();
1415 m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
1416 evt.ControlDown());
1417 }
1418
1419
1420 void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
1421 wxPoint pt = evt.GetPosition();
1422 m_swx->DoContextMenu(Point(pt.x, pt.y));
1423 }
1424
1425 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
1426 long key = evt.KeyCode();
1427 if ((key > WXK_ESCAPE) &&
1428 (key != WXK_DELETE) && (key < 255) &&
1429 !evt.ControlDown() && !evt.AltDown()) {
1430
1431 m_swx->DoAddChar(key);
1432 }
1433 else {
1434 evt.Skip();
1435 }
1436 }
1437
1438 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
1439 long key = evt.KeyCode();
1440 key = toupper(key);
1441 int processed = m_swx->DoKeyDown(key, evt.ShiftDown(),
1442 evt.ControlDown(), evt.AltDown());
1443 if (! processed)
1444 evt.Skip();
1445 }
1446
1447 void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
1448 m_swx->DoLoseFocus();
1449 }
1450
1451 void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
1452 m_swx->DoGainFocus();
1453 }
1454
1455 void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
1456 m_swx->DoSysColourChange();
1457 }
1458
1459 void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
1460 // do nothing to help avoid flashing
1461 }
1462
1463
1464
1465 void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
1466 m_swx->DoCommand(evt.GetId());
1467 }
1468
1469
1470 void wxStyledTextCtrl::OnListBox(wxCommandEvent& evt) {
1471 m_swx->DoOnListBox();
1472 }
1473
1474
1475 //----------------------------------------------------------------------
1476 // Turn notifications from Scintilla into events
1477
1478
1479 void wxStyledTextCtrl::NotifyChange() {
1480 wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
1481 GetEventHandler()->ProcessEvent(evt);
1482 }
1483
1484 void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
1485 SCNotification& scn = *_scn;
1486 int eventType = 0;
1487 switch (scn.nmhdr.code) {
1488 case SCN_STYLENEEDED:
1489 eventType = wxEVT_STC_STYLENEEDED;
1490 break;
1491 case SCN_CHARADDED:
1492 eventType = wxEVT_STC_CHARADDED;
1493 break;
1494 case SCN_UPDATEUI:
1495 eventType = wxEVT_STC_UPDATEUI;
1496 break;
1497 case SCN_SAVEPOINTREACHED:
1498 eventType = wxEVT_STC_SAVEPOINTREACHED;
1499 break;
1500 case SCN_SAVEPOINTLEFT:
1501 eventType = wxEVT_STC_SAVEPOINTLEFT;
1502 break;
1503 case SCN_MODIFYATTEMPTRO:
1504 eventType = wxEVT_STC_ROMODIFYATTEMPT;
1505 break;
1506 case SCN_DOUBLECLICK:
1507 eventType = wxEVT_STC_DOUBLECLICK;
1508 break;
1509 case SCN_MODIFIED:
1510 eventType = wxEVT_STC_MODIFIED;
1511 break;
1512 case SCN_KEY:
1513 eventType = wxEVT_STC_KEY;
1514 break;
1515 case SCN_MACRORECORD:
1516 eventType = wxEVT_STC_MACRORECORD;
1517 break;
1518 case SCN_MARGINCLICK:
1519 eventType = wxEVT_STC_MARGINCLICK;
1520 break;
1521 case SCN_NEEDSHOWN:
1522 eventType = wxEVT_STC_NEEDSHOWN;
1523 break;
1524 }
1525 if (eventType) {
1526 wxStyledTextEvent evt(eventType, GetId());
1527 evt.SetPosition(scn.position);
1528 evt.SetKey(scn.ch);
1529 evt.SetModifiers(scn.modifiers);
1530 if (eventType == wxEVT_STC_MODIFIED) {
1531 evt.SetModificationType(scn.modificationType);
1532 if (scn.text)
1533 evt.SetText(wxString(scn.text, scn.length));
1534 evt.SetLength(scn.length);
1535 evt.SetLinesAdded(scn.linesAdded);
1536 evt.SetLine(scn.line);
1537 evt.SetFoldLevelNow(scn.foldLevelNow);
1538 evt.SetFoldLevelPrev(scn.foldLevelPrev);
1539 }
1540 if (eventType == wxEVT_STC_MARGINCLICK)
1541 evt.SetMargin(scn.margin);
1542 if (eventType == wxEVT_STC_MACRORECORD) {
1543 evt.SetMessage(scn.message);
1544 evt.SetWParam(scn.wParam);
1545 evt.SetLParam(scn.lParam);
1546 }
1547
1548 GetEventHandler()->ProcessEvent(evt);
1549 }
1550 }
1551
1552
1553
1554 //----------------------------------------------------------------------
1555 //----------------------------------------------------------------------
1556 //----------------------------------------------------------------------
1557
1558 wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
1559 : wxCommandEvent(commandType, id)
1560 {
1561 m_position = 0;
1562 m_key = 0;
1563 m_modifiers = 0;
1564 m_modificationType = 0;
1565 m_length = 0;
1566 m_linesAdded = 0;
1567 m_line = 0;
1568 m_foldLevelNow = 0;
1569 m_foldLevelPrev = 0;
1570 m_margin = 0;
1571 m_message = 0;
1572 m_wParam = 0;
1573 m_lParam = 0;
1574
1575
1576 }
1577
1578 bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
1579 bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
1580 bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
1581
1582 void wxStyledTextEvent::CopyObject(wxObject& obj) const {
1583 wxCommandEvent::CopyObject(obj);
1584
1585 wxStyledTextEvent* o = (wxStyledTextEvent*)&obj;
1586 o->m_position = m_position;
1587 o->m_key = m_key;
1588 o->m_modifiers = m_modifiers;
1589 o->m_modificationType = m_modificationType;
1590 o->m_text = m_text;
1591 o->m_length = m_length;
1592 o->m_linesAdded = m_linesAdded;
1593 o->m_line = m_line;
1594 o->m_foldLevelNow = m_foldLevelNow;
1595 o->m_foldLevelPrev = m_foldLevelPrev;
1596
1597 o->m_margin = m_margin;
1598
1599 o->m_message = m_message;
1600 o->m_wParam = m_wParam;
1601 o->m_lParam = m_lParam;
1602
1603
1604
1605 }
1606
1607 //----------------------------------------------------------------------
1608 //----------------------------------------------------------------------
1609
wxWidgets (Impactor)