]> git.saurik.com Git - wxWidgets.git/blob - src/stc/stc.cpp
corrected direction when sending events
[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
26 //----------------------------------------------------------------------
27
28 const wxChar* wxSTCNameStr = wxT("stcwindow");
29
30 #ifdef MAKELONG
31 #undef MAKELONG
32 #endif
33
34 #define MAKELONG(a, b) ((a) | ((b) << 16))
35
36
37 static long wxColourAsLong(const wxColour& co) {
38 return (((long)co.Blue() << 16) |
39 ((long)co.Green() << 8) |
40 ((long)co.Red()));
41 }
42
43 static wxColour wxColourFromLong(long c) {
44 wxColour clr;
45 clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
46 return clr;
47 }
48
49
50 static wxColour wxColourFromSpec(const wxString& spec) {
51 // spec should be "#RRGGBB"
52 long red, green, blue;
53 red = green = blue = 0;
54 spec.Mid(1,2).ToLong(&red, 16);
55 spec.Mid(3,2).ToLong(&green, 16);
56 spec.Mid(5,2).ToLong(&blue, 16);
57 return wxColour(red, green, blue);
58 }
59
60 //----------------------------------------------------------------------
61
62 DEFINE_EVENT_TYPE( wxEVT_STC_CHANGE )
63 DEFINE_EVENT_TYPE( wxEVT_STC_STYLENEEDED )
64 DEFINE_EVENT_TYPE( wxEVT_STC_CHARADDED )
65 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTREACHED )
66 DEFINE_EVENT_TYPE( wxEVT_STC_SAVEPOINTLEFT )
67 DEFINE_EVENT_TYPE( wxEVT_STC_ROMODIFYATTEMPT )
68 DEFINE_EVENT_TYPE( wxEVT_STC_KEY )
69 DEFINE_EVENT_TYPE( wxEVT_STC_DOUBLECLICK )
70 DEFINE_EVENT_TYPE( wxEVT_STC_UPDATEUI )
71 DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
72 DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
73 DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
74 DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
75 DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )
76 DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
77 DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
78 DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
79 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLSTART )
80 DEFINE_EVENT_TYPE( wxEVT_STC_DWELLEND )
81 DEFINE_EVENT_TYPE( wxEVT_STC_START_DRAG )
82 DEFINE_EVENT_TYPE( wxEVT_STC_DRAG_OVER )
83 DEFINE_EVENT_TYPE( wxEVT_STC_DO_DROP )
84
85
86 BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
87 EVT_PAINT (wxStyledTextCtrl::OnPaint)
88 EVT_SCROLLWIN (wxStyledTextCtrl::OnScrollWin)
89 EVT_SCROLL (wxStyledTextCtrl::OnScroll)
90 EVT_SIZE (wxStyledTextCtrl::OnSize)
91 EVT_LEFT_DOWN (wxStyledTextCtrl::OnMouseLeftDown)
92 #if defined(__WXMSW__) || defined(__WXMAC__)
93 // Let Scintilla see the double click as a second click
94 EVT_LEFT_DCLICK (wxStyledTextCtrl::OnMouseLeftDown)
95 #endif
96 EVT_MOTION (wxStyledTextCtrl::OnMouseMove)
97 EVT_LEFT_UP (wxStyledTextCtrl::OnMouseLeftUp)
98 #if defined(__WXGTK__) || defined(__WXMAC__)
99 EVT_RIGHT_UP (wxStyledTextCtrl::OnMouseRightUp)
100 #else
101 EVT_CONTEXT_MENU (wxStyledTextCtrl::OnContextMenu)
102 #endif
103 EVT_MOUSEWHEEL (wxStyledTextCtrl::OnMouseWheel)
104 EVT_CHAR (wxStyledTextCtrl::OnChar)
105 EVT_KEY_DOWN (wxStyledTextCtrl::OnKeyDown)
106 EVT_KILL_FOCUS (wxStyledTextCtrl::OnLoseFocus)
107 EVT_SET_FOCUS (wxStyledTextCtrl::OnGainFocus)
108 EVT_SYS_COLOUR_CHANGED (wxStyledTextCtrl::OnSysColourChanged)
109 EVT_ERASE_BACKGROUND (wxStyledTextCtrl::OnEraseBackground)
110 EVT_MENU_RANGE (-1, -1, wxStyledTextCtrl::OnMenu)
111 EVT_LISTBOX_DCLICK (-1, wxStyledTextCtrl::OnListBox)
112 END_EVENT_TABLE()
113
114
115 IMPLEMENT_CLASS(wxStyledTextCtrl, wxControl)
116 IMPLEMENT_DYNAMIC_CLASS(wxStyledTextEvent, wxCommandEvent)
117
118 // forces the linking of the lexer modules
119 int Scintilla_LinkLexers();
120
121 //----------------------------------------------------------------------
122 // Constructor and Destructor
123
124 wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
125 wxWindowID id,
126 const wxPoint& pos,
127 const wxSize& size,
128 long style,
129 const wxString& name) :
130 wxControl(parent, id, pos, size,
131 style | wxVSCROLL | wxHSCROLL | wxWANTS_CHARS | wxCLIP_CHILDREN,
132 wxDefaultValidator, name)
133 {
134 Scintilla_LinkLexers();
135 m_swx = new ScintillaWX(this);
136 m_stopWatch.Start();
137 m_lastKeyDownConsumed = FALSE;
138 m_vScrollBar = NULL;
139 m_hScrollBar = NULL;
140 #if wxUSE_UNICODE
141 // Put Scintilla into unicode (UTF-8) mode
142 SetCodePage(wxSTC_CP_UTF8);
143 #endif
144 }
145
146
147 wxStyledTextCtrl::~wxStyledTextCtrl() {
148 delete m_swx;
149 }
150
151
152 //----------------------------------------------------------------------
153
154 long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
155
156 return m_swx->WndProc(msg, wp, lp);
157 }
158
159
160
161 //----------------------------------------------------------------------
162 // BEGIN generated section. The following code is automatically generated
163 // by gen_iface.py from the contents of Scintilla.iface. Do not edit
164 // this file. Edit stc.cpp.in or gen_iface.py instead and regenerate.
165
166
167 // Add text to the document
168 void wxStyledTextCtrl::AddText(const wxString& text) {
169 wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
170 SendMsg(2001, strlen(buf), (long)(const char*)buf);
171 }
172
173 // Add array of cells to document
174 void wxStyledTextCtrl::AddStyledText(const wxMemoryBuffer& data) {
175 SendMsg(2002, data.GetDataLen(), (long)data.GetData());
176 }
177
178 // Insert string at a position
179 void wxStyledTextCtrl::InsertText(int pos, const wxString& text) {
180 SendMsg(2003, pos, (long)(const char*)wx2stc(text));
181 }
182
183 // Delete all text in the document
184 void wxStyledTextCtrl::ClearAll() {
185 SendMsg(2004, 0, 0);
186 }
187
188 // Set all style bytes to 0, remove all folding information
189 void wxStyledTextCtrl::ClearDocumentStyle() {
190 SendMsg(2005, 0, 0);
191 }
192
193 // The number of characters in the document
194 int wxStyledTextCtrl::GetLength() {
195 return SendMsg(2006, 0, 0);
196 }
197
198 // Returns the character byte at the position
199 int wxStyledTextCtrl::GetCharAt(int pos) {
200 return SendMsg(2007, pos, 0);
201 }
202
203 // Returns the position of the caret
204 int wxStyledTextCtrl::GetCurrentPos() {
205 return SendMsg(2008, 0, 0);
206 }
207
208 // Returns the position of the opposite end of the selection to the caret
209 int wxStyledTextCtrl::GetAnchor() {
210 return SendMsg(2009, 0, 0);
211 }
212
213 // Returns the style byte at the position
214 int wxStyledTextCtrl::GetStyleAt(int pos) {
215 return SendMsg(2010, pos, 0);
216 }
217
218 // Redoes the next action on the undo history
219 void wxStyledTextCtrl::Redo() {
220 SendMsg(2011, 0, 0);
221 }
222
223 // Choose between collecting actions into the undo
224 // history and discarding them.
225 void wxStyledTextCtrl::SetUndoCollection(bool collectUndo) {
226 SendMsg(2012, collectUndo, 0);
227 }
228
229 // Select all the text in the document.
230 void wxStyledTextCtrl::SelectAll() {
231 SendMsg(2013, 0, 0);
232 }
233
234 // Remember the current position in the undo history as the position
235 // at which the document was saved.
236 void wxStyledTextCtrl::SetSavePoint() {
237 SendMsg(2014, 0, 0);
238 }
239
240 // Retrieve a buffer of cells.
241 wxMemoryBuffer wxStyledTextCtrl::GetStyledText(int startPos, int endPos) {
242 wxMemoryBuffer buf;
243 if (endPos < startPos) {
244 int temp = startPos;
245 startPos = endPos;
246 endPos = temp;
247 }
248 int len = endPos - startPos;
249 if (!len) return buf;
250 TextRange tr;
251 tr.lpstrText = (char*)buf.GetWriteBuf(len*2+1);
252 tr.chrg.cpMin = startPos;
253 tr.chrg.cpMax = endPos;
254 len = SendMsg(2015, 0, (long)&tr);
255 buf.UngetWriteBuf(len);
256 return buf;
257 }
258
259 // Are there any redoable actions in the undo history.
260 bool wxStyledTextCtrl::CanRedo() {
261 return SendMsg(2016, 0, 0) != 0;
262 }
263
264 // Retrieve the line number at which a particular marker is located
265 int wxStyledTextCtrl::MarkerLineFromHandle(int handle) {
266 return SendMsg(2017, handle, 0);
267 }
268
269 // Delete a marker.
270 void wxStyledTextCtrl::MarkerDeleteHandle(int handle) {
271 SendMsg(2018, handle, 0);
272 }
273
274 // Is undo history being collected?
275 bool wxStyledTextCtrl::GetUndoCollection() {
276 return SendMsg(2019, 0, 0) != 0;
277 }
278
279 // Are white space characters currently visible?
280 // Returns one of SCWS_* constants.
281 int wxStyledTextCtrl::GetViewWhiteSpace() {
282 return SendMsg(2020, 0, 0);
283 }
284
285 // Make white space characters invisible, always visible or visible outside indentation.
286 void wxStyledTextCtrl::SetViewWhiteSpace(int viewWS) {
287 SendMsg(2021, viewWS, 0);
288 }
289
290 // Find the position from a point within the window.
291 int wxStyledTextCtrl::PositionFromPoint(wxPoint pt) {
292 return SendMsg(2022, pt.x, pt.y);
293 }
294
295 // Find the position from a point within the window but return
296 // INVALID_POSITION if not close to text.
297 int wxStyledTextCtrl::PositionFromPointClose(int x, int y) {
298 return SendMsg(2023, x, y);
299 }
300
301 // Set caret to start of a line and ensure it is visible.
302 void wxStyledTextCtrl::GotoLine(int line) {
303 SendMsg(2024, line, 0);
304 }
305
306 // Set caret to a position and ensure it is visible.
307 void wxStyledTextCtrl::GotoPos(int pos) {
308 SendMsg(2025, pos, 0);
309 }
310
311 // Set the selection anchor to a position. The anchor is the opposite
312 // end of the selection from the caret.
313 void wxStyledTextCtrl::SetAnchor(int posAnchor) {
314 SendMsg(2026, posAnchor, 0);
315 }
316
317 // Retrieve the text of the line containing the caret.
318 // Returns the index of the caret on the line.
319 wxString wxStyledTextCtrl::GetCurLine(int* linePos) {
320 int len = LineLength(GetCurrentLine());
321 if (!len) {
322 if (linePos) *linePos = 0;
323 return wxEmptyString;
324 }
325
326 wxMemoryBuffer mbuf(len+1);
327 char* buf = (char*)mbuf.GetWriteBuf(len+1);
328
329 int pos = SendMsg(2027, len+1, (long)buf);
330 mbuf.UngetWriteBuf(len);
331 mbuf.AppendByte(0);
332 if (linePos) *linePos = pos;
333 return stc2wx(buf);
334 }
335
336 // Retrieve the position of the last correctly styled character.
337 int wxStyledTextCtrl::GetEndStyled() {
338 return SendMsg(2028, 0, 0);
339 }
340
341 // Convert all line endings in the document to one mode.
342 void wxStyledTextCtrl::ConvertEOLs(int eolMode) {
343 SendMsg(2029, eolMode, 0);
344 }
345
346 // Retrieve the current end of line mode - one of CRLF, CR, or LF.
347 int wxStyledTextCtrl::GetEOLMode() {
348 return SendMsg(2030, 0, 0);
349 }
350
351 // Set the current end of line mode.
352 void wxStyledTextCtrl::SetEOLMode(int eolMode) {
353 SendMsg(2031, eolMode, 0);
354 }
355
356 // Set the current styling position to pos and the styling mask to mask.
357 // The styling mask can be used to protect some bits in each styling byte from
358 // modification.
359 void wxStyledTextCtrl::StartStyling(int pos, int mask) {
360 SendMsg(2032, pos, mask);
361 }
362
363 // Change style from current styling position for length characters to a style
364 // and move the current styling position to after this newly styled segment.
365 void wxStyledTextCtrl::SetStyling(int length, int style) {
366 SendMsg(2033, length, style);
367 }
368
369 // Is drawing done first into a buffer or direct to the screen.
370 bool wxStyledTextCtrl::GetBufferedDraw() {
371 return SendMsg(2034, 0, 0) != 0;
372 }
373
374 // If drawing is buffered then each line of text is drawn into a bitmap buffer
375 // before drawing it to the screen to avoid flicker.
376 void wxStyledTextCtrl::SetBufferedDraw(bool buffered) {
377 SendMsg(2035, buffered, 0);
378 }
379
380 // Change the visible size of a tab to be a multiple of the width of a space
381 // character.
382 void wxStyledTextCtrl::SetTabWidth(int tabWidth) {
383 SendMsg(2036, tabWidth, 0);
384 }
385
386 // Retrieve the visible size of a tab.
387 int wxStyledTextCtrl::GetTabWidth() {
388 return SendMsg(2121, 0, 0);
389 }
390
391 // Set the code page used to interpret the bytes of the document as characters.
392 void wxStyledTextCtrl::SetCodePage(int codePage) {
393 #if wxUSE_UNICODE
394 wxASSERT_MSG(codePage == wxSTC_CP_UTF8,
395 wxT("Only wxSTC_CP_UTF8 may be used when wxUSE_UNICODE is on."));
396 #else
397 wxASSERT_MSG(codePage != wxSTC_CP_UTF8,
398 wxT("wxSTC_CP_UTF8 may not be used when wxUSE_UNICODE is off."));
399 #endif
400 SendMsg(2037, codePage);
401 }
402
403 // Set the symbol used for a particular marker number,
404 // and optionally the fore and background colours.
405 void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol,
406 const wxColour& foreground,
407 const wxColour& background) {
408
409 SendMsg(2040, markerNumber, markerSymbol);
410 if (foreground.Ok())
411 MarkerSetForeground(markerNumber, foreground);
412 if (background.Ok())
413 MarkerSetBackground(markerNumber, background);
414 }
415
416 // Set the foreground colour used for a particular marker number.
417 void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour& fore) {
418 SendMsg(2041, markerNumber, wxColourAsLong(fore));
419 }
420
421 // Set the background colour used for a particular marker number.
422 void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour& back) {
423 SendMsg(2042, markerNumber, wxColourAsLong(back));
424 }
425
426 // Add a marker to a line, returning an ID which can be used to find or delete the marker.
427 int wxStyledTextCtrl::MarkerAdd(int line, int markerNumber) {
428 return SendMsg(2043, line, markerNumber);
429 }
430
431 // Delete a marker from a line
432 void wxStyledTextCtrl::MarkerDelete(int line, int markerNumber) {
433 SendMsg(2044, line, markerNumber);
434 }
435
436 // Delete all markers with a particular number from all lines
437 void wxStyledTextCtrl::MarkerDeleteAll(int markerNumber) {
438 SendMsg(2045, markerNumber, 0);
439 }
440
441 // Get a bit mask of all the markers set on a line.
442 int wxStyledTextCtrl::MarkerGet(int line) {
443 return SendMsg(2046, line, 0);
444 }
445
446 // Find the next line after lineStart that includes a marker in mask.
447 int wxStyledTextCtrl::MarkerNext(int lineStart, int markerMask) {
448 return SendMsg(2047, lineStart, markerMask);
449 }
450
451 // Find the previous line before lineStart that includes a marker in mask.
452 int wxStyledTextCtrl::MarkerPrevious(int lineStart, int markerMask) {
453 return SendMsg(2048, lineStart, markerMask);
454 }
455
456 // Set a margin to be either numeric or symbolic.
457 void wxStyledTextCtrl::SetMarginType(int margin, int marginType) {
458 SendMsg(2240, margin, marginType);
459 }
460
461 // Retrieve the type of a margin.
462 int wxStyledTextCtrl::GetMarginType(int margin) {
463 return SendMsg(2241, margin, 0);
464 }
465
466 // Set the width of a margin to a width expressed in pixels.
467 void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) {
468 SendMsg(2242, margin, pixelWidth);
469 }
470
471 // Retrieve the width of a margin in pixels.
472 int wxStyledTextCtrl::GetMarginWidth(int margin) {
473 return SendMsg(2243, margin, 0);
474 }
475
476 // Set a mask that determines which markers are displayed in a margin.
477 void wxStyledTextCtrl::SetMarginMask(int margin, int mask) {
478 SendMsg(2244, margin, mask);
479 }
480
481 // Retrieve the marker mask of a margin.
482 int wxStyledTextCtrl::GetMarginMask(int margin) {
483 return SendMsg(2245, margin, 0);
484 }
485
486 // Make a margin sensitive or insensitive to mouse clicks.
487 void wxStyledTextCtrl::SetMarginSensitive(int margin, bool sensitive) {
488 SendMsg(2246, margin, sensitive);
489 }
490
491 // Retrieve the mouse click sensitivity of a margin.
492 bool wxStyledTextCtrl::GetMarginSensitive(int margin) {
493 return SendMsg(2247, margin, 0) != 0;
494 }
495
496 // Clear all the styles and make equivalent to the global default style.
497 void wxStyledTextCtrl::StyleClearAll() {
498 SendMsg(2050, 0, 0);
499 }
500
501 // Set the foreground colour of a style.
502 void wxStyledTextCtrl::StyleSetForeground(int style, const wxColour& fore) {
503 SendMsg(2051, style, wxColourAsLong(fore));
504 }
505
506 // Set the background colour of a style.
507 void wxStyledTextCtrl::StyleSetBackground(int style, const wxColour& back) {
508 SendMsg(2052, style, wxColourAsLong(back));
509 }
510
511 // Set a style to be bold or not.
512 void wxStyledTextCtrl::StyleSetBold(int style, bool bold) {
513 SendMsg(2053, style, bold);
514 }
515
516 // Set a style to be italic or not.
517 void wxStyledTextCtrl::StyleSetItalic(int style, bool italic) {
518 SendMsg(2054, style, italic);
519 }
520
521 // Set the size of characters of a style.
522 void wxStyledTextCtrl::StyleSetSize(int style, int sizePoints) {
523 SendMsg(2055, style, sizePoints);
524 }
525
526 // Set the font of a style.
527 void wxStyledTextCtrl::StyleSetFaceName(int style, const wxString& fontName) {
528 SendMsg(2056, style, (long)(const char*)wx2stc(fontName));
529 }
530
531 // Set a style to have its end of line filled or not.
532 void wxStyledTextCtrl::StyleSetEOLFilled(int style, bool filled) {
533 SendMsg(2057, style, filled);
534 }
535
536 // Reset the default style to its state at startup
537 void wxStyledTextCtrl::StyleResetDefault() {
538 SendMsg(2058, 0, 0);
539 }
540
541 // Set a style to be underlined or not.
542 void wxStyledTextCtrl::StyleSetUnderline(int style, bool underline) {
543 SendMsg(2059, style, underline);
544 }
545
546 // Set a style to be mixed case, or to force upper or lower case.
547 void wxStyledTextCtrl::StyleSetCase(int style, int caseForce) {
548 SendMsg(2060, style, caseForce);
549 }
550
551 // Set the character set of the font in a style.
552 void wxStyledTextCtrl::StyleSetCharacterSet(int style, int characterSet) {
553 SendMsg(2066, style, characterSet);
554 }
555
556 // Set the foreground colour of the selection and whether to use this setting.
557 void wxStyledTextCtrl::SetSelForeground(bool useSetting, const wxColour& fore) {
558 SendMsg(2067, useSetting, wxColourAsLong(fore));
559 }
560
561 // Set the background colour of the selection and whether to use this setting.
562 void wxStyledTextCtrl::SetSelBackground(bool useSetting, const wxColour& back) {
563 SendMsg(2068, useSetting, wxColourAsLong(back));
564 }
565
566 // Set the foreground colour of the caret.
567 void wxStyledTextCtrl::SetCaretForeground(const wxColour& fore) {
568 SendMsg(2069, wxColourAsLong(fore), 0);
569 }
570
571 // When key+modifier combination km is pressed perform msg.
572 void wxStyledTextCtrl::CmdKeyAssign(int key, int modifiers, int cmd) {
573 SendMsg(2070, MAKELONG(key, modifiers), cmd);
574 }
575
576 // When key+modifier combination km do nothing.
577 void wxStyledTextCtrl::CmdKeyClear(int key, int modifiers) {
578 SendMsg(2071, MAKELONG(key, modifiers));
579 }
580
581 // Drop all key mappings.
582 void wxStyledTextCtrl::CmdKeyClearAll() {
583 SendMsg(2072, 0, 0);
584 }
585
586 // Set the styles for a segment of the document.
587 void wxStyledTextCtrl::SetStyleBytes(int length, char* styleBytes) {
588 SendMsg(2073, length, (long)styleBytes);
589 }
590
591 // Set a style to be visible or not.
592 void wxStyledTextCtrl::StyleSetVisible(int style, bool visible) {
593 SendMsg(2074, style, visible);
594 }
595
596 // Get the time in milliseconds that the caret is on and off.
597 int wxStyledTextCtrl::GetCaretPeriod() {
598 return SendMsg(2075, 0, 0);
599 }
600
601 // Get the time in milliseconds that the caret is on and off. 0 = steady on.
602 void wxStyledTextCtrl::SetCaretPeriod(int periodMilliseconds) {
603 SendMsg(2076, periodMilliseconds, 0);
604 }
605
606 // Set the set of characters making up words for when moving or selecting
607 // by word.
608 void wxStyledTextCtrl::SetWordChars(const wxString& characters) {
609 SendMsg(2077, 0, (long)(const char*)wx2stc(characters));
610 }
611
612 // Start a sequence of actions that is undone and redone as a unit.
613 // May be nested.
614 void wxStyledTextCtrl::BeginUndoAction() {
615 SendMsg(2078, 0, 0);
616 }
617
618 // End a sequence of actions that is undone and redone as a unit.
619 void wxStyledTextCtrl::EndUndoAction() {
620 SendMsg(2079, 0, 0);
621 }
622
623 // Set an indicator to plain, squiggle or TT.
624 void wxStyledTextCtrl::IndicatorSetStyle(int indic, int style) {
625 SendMsg(2080, indic, style);
626 }
627
628 // Retrieve the style of an indicator.
629 int wxStyledTextCtrl::IndicatorGetStyle(int indic) {
630 return SendMsg(2081, indic, 0);
631 }
632
633 // Set the foreground colour of an indicator.
634 void wxStyledTextCtrl::IndicatorSetForeground(int indic, const wxColour& fore) {
635 SendMsg(2082, indic, wxColourAsLong(fore));
636 }
637
638 // Retrieve the foreground colour of an indicator.
639 wxColour wxStyledTextCtrl::IndicatorGetForeground(int indic) {
640 long c = SendMsg(2083, indic, 0);
641 return wxColourFromLong(c);
642 }
643
644 // Divide each styling byte into lexical class bits (default:5) and indicator
645 // bits (default:3). If a lexer requires more than 32 lexical states, then this
646 // is used to expand the possible states.
647 void wxStyledTextCtrl::SetStyleBits(int bits) {
648 SendMsg(2090, bits, 0);
649 }
650
651 // Retrieve number of bits in style bytes used to hold the lexical state.
652 int wxStyledTextCtrl::GetStyleBits() {
653 return SendMsg(2091, 0, 0);
654 }
655
656 // Used to hold extra styling information for each line.
657 void wxStyledTextCtrl::SetLineState(int line, int state) {
658 SendMsg(2092, line, state);
659 }
660
661 // Retrieve the extra styling information for a line.
662 int wxStyledTextCtrl::GetLineState(int line) {
663 return SendMsg(2093, line, 0);
664 }
665
666 // Retrieve the last line number that has line state.
667 int wxStyledTextCtrl::GetMaxLineState() {
668 return SendMsg(2094, 0, 0);
669 }
670
671 // Is the background of the line containing the caret in a different colour?
672 bool wxStyledTextCtrl::GetCaretLineVisible() {
673 return SendMsg(2095, 0, 0) != 0;
674 }
675
676 // Dsplay the background of the line containing the caret in a different colour.
677 void wxStyledTextCtrl::SetCaretLineVisible(bool show) {
678 SendMsg(2096, show, 0);
679 }
680
681 // Get the colour of the background of the line containing the caret.
682 wxColour wxStyledTextCtrl::GetCaretLineBack() {
683 long c = SendMsg(2097, 0, 0);
684 return wxColourFromLong(c);
685 }
686
687 // Set the colour of the background of the line containing the caret.
688 void wxStyledTextCtrl::SetCaretLineBack(const wxColour& back) {
689 SendMsg(2098, wxColourAsLong(back), 0);
690 }
691
692 // Set a style to be changeable or not (read only).
693 // Experimental feature, currently buggy.
694 void wxStyledTextCtrl::StyleSetChangeable(int style, bool changeable) {
695 SendMsg(2099, style, changeable);
696 }
697
698 // Display a auto-completion list.
699 // The lenEntered parameter indicates how many characters before
700 // the caret should be used to provide context.
701 void wxStyledTextCtrl::AutoCompShow(int lenEntered, const wxString& itemList) {
702 SendMsg(2100, lenEntered, (long)(const char*)wx2stc(itemList));
703 }
704
705 // Remove the auto-completion list from the screen.
706 void wxStyledTextCtrl::AutoCompCancel() {
707 SendMsg(2101, 0, 0);
708 }
709
710 // Is there an auto-completion list visible?
711 bool wxStyledTextCtrl::AutoCompActive() {
712 return SendMsg(2102, 0, 0) != 0;
713 }
714
715 // Retrieve the position of the caret when the auto-completion list was
716 // displayed.
717 int wxStyledTextCtrl::AutoCompPosStart() {
718 return SendMsg(2103, 0, 0);
719 }
720
721 // User has selected an item so remove the list and insert the selection.
722 void wxStyledTextCtrl::AutoCompComplete() {
723 SendMsg(2104, 0, 0);
724 }
725
726 // Define a set of character that when typed cancel the auto-completion list.
727 void wxStyledTextCtrl::AutoCompStops(const wxString& characterSet) {
728 SendMsg(2105, 0, (long)(const char*)wx2stc(characterSet));
729 }
730
731 // Change the separator character in the string setting up an auto-completion
732 // list. Default is space but can be changed if items contain space.
733 void wxStyledTextCtrl::AutoCompSetSeparator(int separatorCharacter) {
734 SendMsg(2106, separatorCharacter, 0);
735 }
736
737 // Retrieve the auto-completion list separator character.
738 int wxStyledTextCtrl::AutoCompGetSeparator() {
739 return SendMsg(2107, 0, 0);
740 }
741
742 // Select the item in the auto-completion list that starts with a string.
743 void wxStyledTextCtrl::AutoCompSelect(const wxString& text) {
744 SendMsg(2108, 0, (long)(const char*)wx2stc(text));
745 }
746
747 // Should the auto-completion list be cancelled if the user backspaces to a
748 // position before where the box was created.
749 void wxStyledTextCtrl::AutoCompSetCancelAtStart(bool cancel) {
750 SendMsg(2110, cancel, 0);
751 }
752
753 // Retrieve whether auto-completion cancelled by backspacing before start.
754 bool wxStyledTextCtrl::AutoCompGetCancelAtStart() {
755 return SendMsg(2111, 0, 0) != 0;
756 }
757
758 // Define a set of characters that when typed will cause the autocompletion to
759 // choose the selected item.
760 void wxStyledTextCtrl::AutoCompSetFillUps(const wxString& characterSet) {
761 SendMsg(2112, 0, (long)(const char*)wx2stc(characterSet));
762 }
763
764 // Should a single item auto-completion list automatically choose the item.
765 void wxStyledTextCtrl::AutoCompSetChooseSingle(bool chooseSingle) {
766 SendMsg(2113, chooseSingle, 0);
767 }
768
769 // Retrieve whether a single item auto-completion list automatically choose the item.
770 bool wxStyledTextCtrl::AutoCompGetChooseSingle() {
771 return SendMsg(2114, 0, 0) != 0;
772 }
773
774 // Set whether case is significant when performing auto-completion searches.
775 void wxStyledTextCtrl::AutoCompSetIgnoreCase(bool ignoreCase) {
776 SendMsg(2115, ignoreCase, 0);
777 }
778
779 // Retrieve state of ignore case flag.
780 bool wxStyledTextCtrl::AutoCompGetIgnoreCase() {
781 return SendMsg(2116, 0, 0) != 0;
782 }
783
784 // Display a list of strings and send notification when user chooses one.
785 void wxStyledTextCtrl::UserListShow(int listType, const wxString& itemList) {
786 SendMsg(2117, listType, (long)(const char*)wx2stc(itemList));
787 }
788
789 // Set whether or not autocompletion is hidden automatically when nothing matches
790 void wxStyledTextCtrl::AutoCompSetAutoHide(bool autoHide) {
791 SendMsg(2118, autoHide, 0);
792 }
793
794 // Retrieve whether or not autocompletion is hidden automatically when nothing matches
795 bool wxStyledTextCtrl::AutoCompGetAutoHide() {
796 return SendMsg(2119, 0, 0) != 0;
797 }
798
799 // Set whether or not autocompletion deletes any word characters after the inserted text upon completion
800 void wxStyledTextCtrl::AutoCompSetDropRestOfWord(bool dropRestOfWord) {
801 SendMsg(2270, dropRestOfWord, 0);
802 }
803
804 // Retrieve whether or not autocompletion deletes any word characters after the inserted text upon completion
805 bool wxStyledTextCtrl::AutoCompGetDropRestOfWord() {
806 return SendMsg(2271, 0, 0) != 0;
807 }
808
809 // Set the number of spaces used for one level of indentation.
810 void wxStyledTextCtrl::SetIndent(int indentSize) {
811 SendMsg(2122, indentSize, 0);
812 }
813
814 // Retrieve indentation size.
815 int wxStyledTextCtrl::GetIndent() {
816 return SendMsg(2123, 0, 0);
817 }
818
819 // Indentation will only use space characters if useTabs is false, otherwise
820 // it will use a combination of tabs and spaces.
821 void wxStyledTextCtrl::SetUseTabs(bool useTabs) {
822 SendMsg(2124, useTabs, 0);
823 }
824
825 // Retrieve whether tabs will be used in indentation.
826 bool wxStyledTextCtrl::GetUseTabs() {
827 return SendMsg(2125, 0, 0) != 0;
828 }
829
830 // Change the indentation of a line to a number of columns.
831 void wxStyledTextCtrl::SetLineIndentation(int line, int indentSize) {
832 SendMsg(2126, line, indentSize);
833 }
834
835 // Retrieve the number of columns that a line is indented.
836 int wxStyledTextCtrl::GetLineIndentation(int line) {
837 return SendMsg(2127, line, 0);
838 }
839
840 // Retrieve the position before the first non indentation character on a line.
841 int wxStyledTextCtrl::GetLineIndentPosition(int line) {
842 return SendMsg(2128, line, 0);
843 }
844
845 // Retrieve the column number of a position, taking tab width into account.
846 int wxStyledTextCtrl::GetColumn(int pos) {
847 return SendMsg(2129, pos, 0);
848 }
849
850 // Show or hide the horizontal scroll bar.
851 void wxStyledTextCtrl::SetUseHorizontalScrollBar(bool show) {
852 SendMsg(2130, show, 0);
853 }
854
855 // Is the horizontal scroll bar visible?
856 bool wxStyledTextCtrl::GetUseHorizontalScrollBar() {
857 return SendMsg(2131, 0, 0) != 0;
858 }
859
860 // Show or hide indentation guides.
861 void wxStyledTextCtrl::SetIndentationGuides(bool show) {
862 SendMsg(2132, show, 0);
863 }
864
865 // Are the indentation guides visible?
866 bool wxStyledTextCtrl::GetIndentationGuides() {
867 return SendMsg(2133, 0, 0) != 0;
868 }
869
870 // Set the highlighted indentation guide column.
871 // 0 = no highlighted guide.
872 void wxStyledTextCtrl::SetHighlightGuide(int column) {
873 SendMsg(2134, column, 0);
874 }
875
876 // Get the highlighted indentation guide column.
877 int wxStyledTextCtrl::GetHighlightGuide() {
878 return SendMsg(2135, 0, 0);
879 }
880
881 // Get the position after the last visible characters on a line.
882 int wxStyledTextCtrl::GetLineEndPosition(int line) {
883 return SendMsg(2136, line, 0);
884 }
885
886 // Get the code page used to interpret the bytes of the document as characters.
887 int wxStyledTextCtrl::GetCodePage() {
888 return SendMsg(2137, 0, 0);
889 }
890
891 // Get the foreground colour of the caret.
892 wxColour wxStyledTextCtrl::GetCaretForeground() {
893 long c = SendMsg(2138, 0, 0);
894 return wxColourFromLong(c);
895 }
896
897 // In read-only mode?
898 bool wxStyledTextCtrl::GetReadOnly() {
899 return SendMsg(2140, 0, 0) != 0;
900 }
901
902 // Sets the position of the caret.
903 void wxStyledTextCtrl::SetCurrentPos(int pos) {
904 SendMsg(2141, pos, 0);
905 }
906
907 // Sets the position that starts the selection - this becomes the anchor.
908 void wxStyledTextCtrl::SetSelectionStart(int pos) {
909 SendMsg(2142, pos, 0);
910 }
911
912 // Returns the position at the start of the selection.
913 int wxStyledTextCtrl::GetSelectionStart() {
914 return SendMsg(2143, 0, 0);
915 }
916
917 // Sets the position that ends the selection - this becomes the currentPosition.
918 void wxStyledTextCtrl::SetSelectionEnd(int pos) {
919 SendMsg(2144, pos, 0);
920 }
921
922 // Returns the position at the end of the selection.
923 int wxStyledTextCtrl::GetSelectionEnd() {
924 return SendMsg(2145, 0, 0);
925 }
926
927 // Sets the print magnification added to the point size of each style for printing.
928 void wxStyledTextCtrl::SetPrintMagnification(int magnification) {
929 SendMsg(2146, magnification, 0);
930 }
931
932 // Returns the print magnification.
933 int wxStyledTextCtrl::GetPrintMagnification() {
934 return SendMsg(2147, 0, 0);
935 }
936
937 // Modify colours when printing for clearer printed text.
938 void wxStyledTextCtrl::SetPrintColourMode(int mode) {
939 SendMsg(2148, mode, 0);
940 }
941
942 // Returns the print colour mode.
943 int wxStyledTextCtrl::GetPrintColourMode() {
944 return SendMsg(2149, 0, 0);
945 }
946
947 // Find some text in the document.
948 int wxStyledTextCtrl::FindText(int minPos, int maxPos,
949 const wxString& text,
950 bool caseSensitive, bool wholeWord) {
951 TextToFind ft;
952 int flags = 0;
953
954 flags |= caseSensitive ? SCFIND_MATCHCASE : 0;
955 flags |= wholeWord ? SCFIND_WHOLEWORD : 0;
956 ft.chrg.cpMin = minPos;
957 ft.chrg.cpMax = maxPos;
958 ft.lpstrText = (char*)(const char*)wx2stc(text);
959
960 return SendMsg(2150, flags, (long)&ft);
961 }
962
963 // On Windows will draw the document into a display context such as a printer.
964 int wxStyledTextCtrl::FormatRange(bool doDraw,
965 int startPos,
966 int endPos,
967 wxDC* draw,
968 wxDC* target, // Why does it use two? Can they be the same?
969 wxRect renderRect,
970 wxRect pageRect) {
971 RangeToFormat fr;
972
973 if (endPos < startPos) {
974 int temp = startPos;
975 startPos = endPos;
976 endPos = temp;
977 }
978 fr.hdc = draw;
979 fr.hdcTarget = target;
980 fr.rc.top = renderRect.GetTop();
981 fr.rc.left = renderRect.GetLeft();
982 fr.rc.right = renderRect.GetRight();
983 fr.rc.bottom = renderRect.GetBottom();
984 fr.rcPage.top = pageRect.GetTop();
985 fr.rcPage.left = pageRect.GetLeft();
986 fr.rcPage.right = pageRect.GetRight();
987 fr.rcPage.bottom = pageRect.GetBottom();
988 fr.chrg.cpMin = startPos;
989 fr.chrg.cpMax = endPos;
990
991 return SendMsg(2151, doDraw, (long)&fr);
992 }
993
994 // Retrieve the line at the top of the display.
995 int wxStyledTextCtrl::GetFirstVisibleLine() {
996 return SendMsg(2152, 0, 0);
997 }
998
999 // Retrieve the contents of a line.
1000 wxString wxStyledTextCtrl::GetLine(int line) {
1001 int len = LineLength(line);
1002 if (!len) return wxEmptyString;
1003
1004 wxMemoryBuffer mbuf(len+1);
1005 char* buf = (char*)mbuf.GetWriteBuf(len+1);
1006 SendMsg(2153, line, (long)buf);
1007 mbuf.UngetWriteBuf(len);
1008 mbuf.AppendByte(0);
1009 return stc2wx(buf);
1010 }
1011
1012 // Returns the number of lines in the document. There is always at least one.
1013 int wxStyledTextCtrl::GetLineCount() {
1014 return SendMsg(2154, 0, 0);
1015 }
1016
1017 // Sets the size in pixels of the left margin.
1018 void wxStyledTextCtrl::SetMarginLeft(int pixelWidth) {
1019 SendMsg(2155, 0, pixelWidth);
1020 }
1021
1022 // Returns the size in pixels of the left margin.
1023 int wxStyledTextCtrl::GetMarginLeft() {
1024 return SendMsg(2156, 0, 0);
1025 }
1026
1027 // Sets the size in pixels of the right margin.
1028 void wxStyledTextCtrl::SetMarginRight(int pixelWidth) {
1029 SendMsg(2157, 0, pixelWidth);
1030 }
1031
1032 // Returns the size in pixels of the right margin.
1033 int wxStyledTextCtrl::GetMarginRight() {
1034 return SendMsg(2158, 0, 0);
1035 }
1036
1037 // Is the document different from when it was last saved?
1038 bool wxStyledTextCtrl::GetModify() {
1039 return SendMsg(2159, 0, 0) != 0;
1040 }
1041
1042 // Select a range of text.
1043 void wxStyledTextCtrl::SetSelection(int start, int end) {
1044 SendMsg(2160, start, end);
1045 }
1046
1047 // Retrieve the selected text.
1048 wxString wxStyledTextCtrl::GetSelectedText() {
1049 int start;
1050 int end;
1051
1052 GetSelection(&start, &end);
1053 int len = end - start;
1054 if (!len) return wxEmptyString;
1055
1056 wxMemoryBuffer mbuf(len+1);
1057 char* buf = (char*)mbuf.GetWriteBuf(len+1);
1058 SendMsg(2161, 0, (long)buf);
1059 mbuf.UngetWriteBuf(len);
1060 mbuf.AppendByte(0);
1061 return stc2wx(buf);
1062 }
1063
1064 // Retrieve a range of text.
1065 wxString wxStyledTextCtrl::GetTextRange(int startPos, int endPos) {
1066 if (endPos < startPos) {
1067 int temp = startPos;
1068 startPos = endPos;
1069 endPos = temp;
1070 }
1071 int len = endPos - startPos;
1072 if (!len) return wxEmptyString;
1073 wxMemoryBuffer mbuf(len+1);
1074 char* buf = (char*)mbuf.GetWriteBuf(len);
1075 TextRange tr;
1076 tr.lpstrText = buf;
1077 tr.chrg.cpMin = startPos;
1078 tr.chrg.cpMax = endPos;
1079 SendMsg(2162, 0, (long)&tr);
1080 mbuf.UngetWriteBuf(len);
1081 mbuf.AppendByte(0);
1082 return stc2wx(buf);
1083 }
1084
1085 // Draw the selection in normal style or with selection highlighted.
1086 void wxStyledTextCtrl::HideSelection(bool normal) {
1087 SendMsg(2163, normal, 0);
1088 }
1089
1090 // Retrieve the line containing a position.
1091 int wxStyledTextCtrl::LineFromPosition(int pos) {
1092 return SendMsg(2166, pos, 0);
1093 }
1094
1095 // Retrieve the position at the start of a line.
1096 int wxStyledTextCtrl::PositionFromLine(int line) {
1097 return SendMsg(2167, line, 0);
1098 }
1099
1100 // Scroll horizontally and vertically.
1101 void wxStyledTextCtrl::LineScroll(int columns, int lines) {
1102 SendMsg(2168, columns, lines);
1103 }
1104
1105 // Ensure the caret is visible.
1106 void wxStyledTextCtrl::EnsureCaretVisible() {
1107 SendMsg(2169, 0, 0);
1108 }
1109
1110 // Replace the selected text with the argument text.
1111 void wxStyledTextCtrl::ReplaceSelection(const wxString& text) {
1112 SendMsg(2170, 0, (long)(const char*)wx2stc(text));
1113 }
1114
1115 // Set to read only or read write.
1116 void wxStyledTextCtrl::SetReadOnly(bool readOnly) {
1117 SendMsg(2171, readOnly, 0);
1118 }
1119
1120 // Will a paste succeed?
1121 bool wxStyledTextCtrl::CanPaste() {
1122 return SendMsg(2173, 0, 0) != 0;
1123 }
1124
1125 // Are there any undoable actions in the undo history.
1126 bool wxStyledTextCtrl::CanUndo() {
1127 return SendMsg(2174, 0, 0) != 0;
1128 }
1129
1130 // Delete the undo history.
1131 void wxStyledTextCtrl::EmptyUndoBuffer() {
1132 SendMsg(2175, 0, 0);
1133 }
1134
1135 // Undo one action in the undo history.
1136 void wxStyledTextCtrl::Undo() {
1137 SendMsg(2176, 0, 0);
1138 }
1139
1140 // Cut the selection to the clipboard.
1141 void wxStyledTextCtrl::Cut() {
1142 SendMsg(2177, 0, 0);
1143 }
1144
1145 // Copy the selection to the clipboard.
1146 void wxStyledTextCtrl::Copy() {
1147 SendMsg(2178, 0, 0);
1148 }
1149
1150 // Paste the contents of the clipboard into the document replacing the selection.
1151 void wxStyledTextCtrl::Paste() {
1152 SendMsg(2179, 0, 0);
1153 }
1154
1155 // Clear the selection.
1156 void wxStyledTextCtrl::Clear() {
1157 SendMsg(2180, 0, 0);
1158 }
1159
1160 // Replace the contents of the document with the argument text.
1161 void wxStyledTextCtrl::SetText(const wxString& text) {
1162 SendMsg(2181, 0, (long)(const char*)wx2stc(text));
1163 }
1164
1165 // Retrieve all the text in the document.
1166 wxString wxStyledTextCtrl::GetText() {
1167 int len = GetTextLength();
1168 wxMemoryBuffer mbuf(len+1); // leave room for the null...
1169 char* buf = (char*)mbuf.GetWriteBuf(len+1);
1170 SendMsg(2182, len+1, (long)buf);
1171 mbuf.UngetWriteBuf(len);
1172 mbuf.AppendByte(0);
1173 return stc2wx(buf);
1174 }
1175
1176 // Retrieve the number of characters in the document.
1177 int wxStyledTextCtrl::GetTextLength() {
1178 return SendMsg(2183, 0, 0);
1179 }
1180
1181 // Set to overtype (true) or insert mode
1182 void wxStyledTextCtrl::SetOvertype(bool overtype) {
1183 SendMsg(2186, overtype, 0);
1184 }
1185
1186 // Returns true if overtype mode is active otherwise false is returned.
1187 bool wxStyledTextCtrl::GetOvertype() {
1188 return SendMsg(2187, 0, 0) != 0;
1189 }
1190
1191 // Set the width of the insert mode caret
1192 void wxStyledTextCtrl::SetCaretWidth(int pixelWidth) {
1193 SendMsg(2188, pixelWidth, 0);
1194 }
1195
1196 // Returns the width of the insert mode caret
1197 int wxStyledTextCtrl::GetCaretWidth() {
1198 return SendMsg(2189, 0, 0);
1199 }
1200
1201 // Sets the position that starts the target which is used for updating the
1202 // document without affecting the scroll position.
1203 void wxStyledTextCtrl::SetTargetStart(int pos) {
1204 SendMsg(2190, pos, 0);
1205 }
1206
1207 // Get the position that starts the target.
1208 int wxStyledTextCtrl::GetTargetStart() {
1209 return SendMsg(2191, 0, 0);
1210 }
1211
1212 // Sets the position that ends the target which is used for updating the
1213 // document without affecting the scroll position.
1214 void wxStyledTextCtrl::SetTargetEnd(int pos) {
1215 SendMsg(2192, pos, 0);
1216 }
1217
1218 // Get the position that ends the target.
1219 int wxStyledTextCtrl::GetTargetEnd() {
1220 return SendMsg(2193, 0, 0);
1221 }
1222
1223 // Replace the target text with the argument text.
1224 // Text is counted so it can contain nulls.
1225 // Returns the length of the replacement text.
1226
1227 int wxStyledTextCtrl::ReplaceTarget(const wxString& text) {
1228 wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1229 return SendMsg(2194, strlen(buf), (long)(const char*)buf);
1230 }
1231
1232 // Replace the target text with the argument text after \d processing.
1233 // Text is counted so it can contain nulls.
1234 // Looks for \d where d is between 1 and 9 and replaces these with the strings
1235 // matched in the last search operation which were surrounded by \( and \).
1236 // Returns the length of the replacement text including any change
1237 // caused by processing the \d patterns.
1238
1239 int wxStyledTextCtrl::ReplaceTargetRE(const wxString& text) {
1240 wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1241 return SendMsg(2195, strlen(buf), (long)(const char*)buf);
1242 }
1243
1244 // Search for a counted string in the target and set the target to the found
1245 // range. Text is counted so it can contain nulls.
1246 // Returns length of range or -1 for failure in which case target is not moved.
1247
1248 int wxStyledTextCtrl::SearchInTarget(const wxString& text) {
1249 wxWX2MBbuf buf = (wxWX2MBbuf)wx2stc(text);
1250 return SendMsg(2197, strlen(buf), (long)(const char*)buf);
1251 }
1252
1253 // Set the search flags used by SearchInTarget
1254 void wxStyledTextCtrl::SetSearchFlags(int flags) {
1255 SendMsg(2198, flags, 0);
1256 }
1257
1258 // Get the search flags used by SearchInTarget
1259 int wxStyledTextCtrl::GetSearchFlags() {
1260 return SendMsg(2199, 0, 0);
1261 }
1262
1263 // Show a call tip containing a definition near position pos.
1264 void wxStyledTextCtrl::CallTipShow(int pos, const wxString& definition) {
1265 SendMsg(2200, pos, (long)(const char*)wx2stc(definition));
1266 }
1267
1268 // Remove the call tip from the screen.
1269 void wxStyledTextCtrl::CallTipCancel() {
1270 SendMsg(2201, 0, 0);
1271 }
1272
1273 // Is there an active call tip?
1274 bool wxStyledTextCtrl::CallTipActive() {
1275 return SendMsg(2202, 0, 0) != 0;
1276 }
1277
1278 // Retrieve the position where the caret was before displaying the call tip.
1279 int wxStyledTextCtrl::CallTipPosAtStart() {
1280 return SendMsg(2203, 0, 0);
1281 }
1282
1283 // Highlight a segment of the definition.
1284 void wxStyledTextCtrl::CallTipSetHighlight(int start, int end) {
1285 SendMsg(2204, start, end);
1286 }
1287
1288 // Set the background colour for the call tip.
1289 void wxStyledTextCtrl::CallTipSetBackground(const wxColour& back) {
1290 SendMsg(2205, wxColourAsLong(back), 0);
1291 }
1292
1293 // Find the display line of a document line taking hidden lines into account.
1294 int wxStyledTextCtrl::VisibleFromDocLine(int line) {
1295 return SendMsg(2220, line, 0);
1296 }
1297
1298 // Find the document line of a display line taking hidden lines into account.
1299 int wxStyledTextCtrl::DocLineFromVisible(int lineDisplay) {
1300 return SendMsg(2221, lineDisplay, 0);
1301 }
1302
1303 // Set the fold level of a line.
1304 // This encodes an integer level along with flags indicating whether the
1305 // line is a header and whether it is effectively white space.
1306 void wxStyledTextCtrl::SetFoldLevel(int line, int level) {
1307 SendMsg(2222, line, level);
1308 }
1309
1310 // Retrieve the fold level of a line.
1311 int wxStyledTextCtrl::GetFoldLevel(int line) {
1312 return SendMsg(2223, line, 0);
1313 }
1314
1315 // Find the last child line of a header line.
1316 int wxStyledTextCtrl::GetLastChild(int line, int level) {
1317 return SendMsg(2224, line, level);
1318 }
1319
1320 // Find the parent line of a child line.
1321 int wxStyledTextCtrl::GetFoldParent(int line) {
1322 return SendMsg(2225, line, 0);
1323 }
1324
1325 // Make a range of lines visible.
1326 void wxStyledTextCtrl::ShowLines(int lineStart, int lineEnd) {
1327 SendMsg(2226, lineStart, lineEnd);
1328 }
1329
1330 // Make a range of lines invisible.
1331 void wxStyledTextCtrl::HideLines(int lineStart, int lineEnd) {
1332 SendMsg(2227, lineStart, lineEnd);
1333 }
1334
1335 // Is a line visible?
1336 bool wxStyledTextCtrl::GetLineVisible(int line) {
1337 return SendMsg(2228, line, 0) != 0;
1338 }
1339
1340 // Show the children of a header line.
1341 void wxStyledTextCtrl::SetFoldExpanded(int line, bool expanded) {
1342 SendMsg(2229, line, expanded);
1343 }
1344
1345 // Is a header line expanded?
1346 bool wxStyledTextCtrl::GetFoldExpanded(int line) {
1347 return SendMsg(2230, line, 0) != 0;
1348 }
1349
1350 // Switch a header line between expanded and contracted.
1351 void wxStyledTextCtrl::ToggleFold(int line) {
1352 SendMsg(2231, line, 0);
1353 }
1354
1355 // Ensure a particular line is visible by expanding any header line hiding it.
1356 void wxStyledTextCtrl::EnsureVisible(int line) {
1357 SendMsg(2232, line, 0);
1358 }
1359
1360 // Set some debugging options for folding
1361 void wxStyledTextCtrl::SetFoldFlags(int flags) {
1362 SendMsg(2233, flags, 0);
1363 }
1364
1365 // Ensure a particular line is visible by expanding any header line hiding it.
1366 // Use the currently set visibility policy to determine which range to display.
1367 void wxStyledTextCtrl::EnsureVisibleEnforcePolicy(int line) {
1368 SendMsg(2234, line, 0);
1369 }
1370
1371 // Sets whether a tab pressed when caret is within indentation indents
1372 void wxStyledTextCtrl::SetTabIndents(bool tabIndents) {
1373 SendMsg(2260, tabIndents, 0);
1374 }
1375
1376 // Does a tab pressed when caret is within indentation indent?
1377 bool wxStyledTextCtrl::GetTabIndents() {
1378 return SendMsg(2261, 0, 0) != 0;
1379 }
1380
1381 // Sets whether a backspace pressed when caret is within indentation unindents
1382 void wxStyledTextCtrl::SetBackSpaceUnIndents(bool bsUnIndents) {
1383 SendMsg(2262, bsUnIndents, 0);
1384 }
1385
1386 // Does a backspace pressed when caret is within indentation unindent?
1387 bool wxStyledTextCtrl::GetBackSpaceUnIndents() {
1388 return SendMsg(2263, 0, 0) != 0;
1389 }
1390
1391 // Sets the time the mouse must sit still to generate a mouse dwell event
1392 void wxStyledTextCtrl::SetMouseDwellTime(int periodMilliseconds) {
1393 SendMsg(2264, periodMilliseconds, 0);
1394 }
1395
1396 // Retrieve the time the mouse must sit still to generate a mouse dwell event
1397 int wxStyledTextCtrl::GetMouseDwellTime() {
1398 return SendMsg(2265, 0, 0);
1399 }
1400
1401 // Get position of start of word
1402 int wxStyledTextCtrl::WordStartPosition(int pos, bool onlyWordCharacters) {
1403 return SendMsg(2266, pos, onlyWordCharacters);
1404 }
1405
1406 // Get position of end of word
1407 int wxStyledTextCtrl::WordEndPosition(int pos, bool onlyWordCharacters) {
1408 return SendMsg(2267, pos, onlyWordCharacters);
1409 }
1410
1411 // Sets whether text is word wrapped
1412 void wxStyledTextCtrl::SetWrapMode(int mode) {
1413 SendMsg(2268, mode, 0);
1414 }
1415
1416 // Retrieve whether text is word wrapped
1417 int wxStyledTextCtrl::GetWrapMode() {
1418 return SendMsg(2269, 0, 0);
1419 }
1420
1421 // Sets the degree of caching of layout information
1422 void wxStyledTextCtrl::SetLayoutCache(int mode) {
1423 SendMsg(2272, mode, 0);
1424 }
1425
1426 // Retrieve the degree of caching of layout information
1427 int wxStyledTextCtrl::GetLayoutCache() {
1428 return SendMsg(2273, 0, 0);
1429 }
1430
1431 // Move the caret inside current view if it's not there already
1432 void wxStyledTextCtrl::MoveCaretInsideView() {
1433 SendMsg(2401, 0, 0);
1434 }
1435
1436 // How many characters are on a line, not including end of line characters.
1437 int wxStyledTextCtrl::LineLength(int line) {
1438 return SendMsg(2350, line, 0);
1439 }
1440
1441 // Highlight the characters at two positions.
1442 void wxStyledTextCtrl::BraceHighlight(int pos1, int pos2) {
1443 SendMsg(2351, pos1, pos2);
1444 }
1445
1446 // Highlight the character at a position indicating there is no matching brace.
1447 void wxStyledTextCtrl::BraceBadLight(int pos) {
1448 SendMsg(2352, pos, 0);
1449 }
1450
1451 // Find the position of a matching brace or INVALID_POSITION if no match.
1452 int wxStyledTextCtrl::BraceMatch(int pos) {
1453 return SendMsg(2353, pos, 0);
1454 }
1455
1456 // Are the end of line characters visible.
1457 bool wxStyledTextCtrl::GetViewEOL() {
1458 return SendMsg(2355, 0, 0) != 0;
1459 }
1460
1461 // Make the end of line characters visible or invisible
1462 void wxStyledTextCtrl::SetViewEOL(bool visible) {
1463 SendMsg(2356, visible, 0);
1464 }
1465
1466 // Retrieve a pointer to the document object.
1467 void* wxStyledTextCtrl::GetDocPointer() {
1468 return (void*)SendMsg(2357);
1469 }
1470
1471 // Change the document object used.
1472 void wxStyledTextCtrl::SetDocPointer(void* docPointer) {
1473 SendMsg(2358, 0, (long)docPointer);
1474 }
1475
1476 // Set which document modification events are sent to the container.
1477 void wxStyledTextCtrl::SetModEventMask(int mask) {
1478 SendMsg(2359, mask, 0);
1479 }
1480
1481 // Retrieve the column number which text should be kept within.
1482 int wxStyledTextCtrl::GetEdgeColumn() {
1483 return SendMsg(2360, 0, 0);
1484 }
1485
1486 // Set the column number of the edge.
1487 // If text goes past the edge then it is highlighted.
1488 void wxStyledTextCtrl::SetEdgeColumn(int column) {
1489 SendMsg(2361, column, 0);
1490 }
1491
1492 // Retrieve the edge highlight mode.
1493 int wxStyledTextCtrl::GetEdgeMode() {
1494 return SendMsg(2362, 0, 0);
1495 }
1496
1497 // The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
1498 // goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
1499 void wxStyledTextCtrl::SetEdgeMode(int mode) {
1500 SendMsg(2363, mode, 0);
1501 }
1502
1503 // Retrieve the colour used in edge indication.
1504 wxColour wxStyledTextCtrl::GetEdgeColour() {
1505 long c = SendMsg(2364, 0, 0);
1506 return wxColourFromLong(c);
1507 }
1508
1509 // Change the colour used in edge indication.
1510 void wxStyledTextCtrl::SetEdgeColour(const wxColour& edgeColour) {
1511 SendMsg(2365, wxColourAsLong(edgeColour), 0);
1512 }
1513
1514 // Sets the current caret position to be the search anchor.
1515 void wxStyledTextCtrl::SearchAnchor() {
1516 SendMsg(2366, 0, 0);
1517 }
1518
1519 // Find some text starting at the search anchor.
1520 // Does not ensure the selection is visible.
1521 int wxStyledTextCtrl::SearchNext(int flags, const wxString& text) {
1522 return SendMsg(2367, flags, (long)(const char*)wx2stc(text));
1523 }
1524
1525 // Find some text starting at the search anchor and moving backwards.
1526 // Does not ensure the selection is visible.
1527 int wxStyledTextCtrl::SearchPrev(int flags, const wxString& text) {
1528 return SendMsg(2368, flags, (long)(const char*)wx2stc(text));
1529 }
1530
1531 // Set the way the line the caret is on is kept visible.
1532 void wxStyledTextCtrl::SetCaretPolicy(int caretPolicy, int caretSlop) {
1533 SendMsg(2369, caretPolicy, caretSlop);
1534 }
1535
1536 // Retrieves the number of lines completely visible.
1537 int wxStyledTextCtrl::LinesOnScreen() {
1538 return SendMsg(2370, 0, 0);
1539 }
1540
1541 // Set whether a pop up menu is displayed automatically when the user presses
1542 // the wrong mouse button.
1543 void wxStyledTextCtrl::UsePopUp(bool allowPopUp) {
1544 SendMsg(2371, allowPopUp, 0);
1545 }
1546
1547 // Is the selection a rectangular. The alternative is the more common stream selection.
1548 bool wxStyledTextCtrl::SelectionIsRectangle() {
1549 return SendMsg(2372, 0, 0) != 0;
1550 }
1551
1552 // Set the zoom level. This number of points is added to the size of all fonts.
1553 // It may be positive to magnify or negative to reduce.
1554 void wxStyledTextCtrl::SetZoom(int zoom) {
1555 SendMsg(2373, zoom, 0);
1556 }
1557
1558 // Retrieve the zoom level.
1559 int wxStyledTextCtrl::GetZoom() {
1560 return SendMsg(2374, 0, 0);
1561 }
1562
1563 // Create a new document object.
1564 // Starts with reference count of 1 and not selected into editor.
1565 void* wxStyledTextCtrl::CreateDocument() {
1566 return (void*)SendMsg(2375);
1567 }
1568
1569 // Extend life of document.
1570 void wxStyledTextCtrl::AddRefDocument(void* docPointer) {
1571 SendMsg(2376, (long)docPointer);
1572 }
1573
1574 // Release a reference to the document, deleting document if it fades to black.
1575 void wxStyledTextCtrl::ReleaseDocument(void* docPointer) {
1576 SendMsg(2377, (long)docPointer);
1577 }
1578
1579 // Get which document modification events are sent to the container.
1580 int wxStyledTextCtrl::GetModEventMask() {
1581 return SendMsg(2378, 0, 0);
1582 }
1583
1584 // Change internal focus flag
1585 void wxStyledTextCtrl::SetSTCFocus(bool focus) {
1586 SendMsg(2380, focus, 0);
1587 }
1588
1589 // Get internal focus flag
1590 bool wxStyledTextCtrl::GetSTCFocus() {
1591 return SendMsg(2381, 0, 0) != 0;
1592 }
1593
1594 // Change error status - 0 = OK
1595 void wxStyledTextCtrl::SetStatus(int statusCode) {
1596 SendMsg(2382, statusCode, 0);
1597 }
1598
1599 // Get error status
1600 int wxStyledTextCtrl::GetStatus() {
1601 return SendMsg(2383, 0, 0);
1602 }
1603
1604 // Set whether the mouse is captured when its button is pressed
1605 void wxStyledTextCtrl::SetMouseDownCaptures(bool captures) {
1606 SendMsg(2384, captures, 0);
1607 }
1608
1609 // Get whether mouse gets captured
1610 bool wxStyledTextCtrl::GetMouseDownCaptures() {
1611 return SendMsg(2385, 0, 0) != 0;
1612 }
1613
1614 // Sets the cursor to one of the SC_CURSOR* values
1615 void wxStyledTextCtrl::SetCursor(int cursorType) {
1616 SendMsg(2386, cursorType, 0);
1617 }
1618
1619 // Get cursor type
1620 int wxStyledTextCtrl::GetCursor() {
1621 return SendMsg(2387, 0, 0);
1622 }
1623
1624 // Change the way control characters are displayed:
1625 // If symbol is < 32, keep the drawn way, else, use the given character
1626 void wxStyledTextCtrl::SetControlCharSymbol(int symbol) {
1627 SendMsg(2388, symbol, 0);
1628 }
1629
1630 // Get the way control characters are displayed
1631 int wxStyledTextCtrl::GetControlCharSymbol() {
1632 return SendMsg(2389, 0, 0);
1633 }
1634
1635 // Move to the previous change in capitalistion
1636 void wxStyledTextCtrl::WordPartLeft() {
1637 SendMsg(2390, 0, 0);
1638 }
1639
1640 // Move to the previous change in capitalistion extending selection to new caret position.
1641 void wxStyledTextCtrl::WordPartLeftExtend() {
1642 SendMsg(2391, 0, 0);
1643 }
1644
1645 // Move to the change next in capitalistion
1646 void wxStyledTextCtrl::WordPartRight() {
1647 SendMsg(2392, 0, 0);
1648 }
1649
1650 // Move to the next change in capitalistion extending selection to new caret position.
1651 void wxStyledTextCtrl::WordPartRightExtend() {
1652 SendMsg(2393, 0, 0);
1653 }
1654
1655 // Set the way the display area is determined when a particular line is to be moved to.
1656 void wxStyledTextCtrl::SetVisiblePolicy(int visiblePolicy, int visibleSlop) {
1657 SendMsg(2394, visiblePolicy, visibleSlop);
1658 }
1659
1660 // Delete back from the current position to the start of the line
1661 void wxStyledTextCtrl::DelLineLeft() {
1662 SendMsg(2395, 0, 0);
1663 }
1664
1665 // Delete forwards from the current position to the end of the line
1666 void wxStyledTextCtrl::DelLineRight() {
1667 SendMsg(2396, 0, 0);
1668 }
1669
1670 // Get and Set the xOffset (ie, horizonal scroll position)
1671 void wxStyledTextCtrl::SetXOffset(int newOffset) {
1672 SendMsg(2397, newOffset, 0);
1673 }
1674 int wxStyledTextCtrl::GetXOffset() {
1675 return SendMsg(2398, 0, 0);
1676 }
1677
1678 // Start notifying the container of all key presses and commands.
1679 void wxStyledTextCtrl::StartRecord() {
1680 SendMsg(3001, 0, 0);
1681 }
1682
1683 // Stop notifying the container of all key presses and commands.
1684 void wxStyledTextCtrl::StopRecord() {
1685 SendMsg(3002, 0, 0);
1686 }
1687
1688 // Set the lexing language of the document.
1689 void wxStyledTextCtrl::SetLexer(int lexer) {
1690 SendMsg(4001, lexer, 0);
1691 }
1692
1693 // Retrieve the lexing language of the document.
1694 int wxStyledTextCtrl::GetLexer() {
1695 return SendMsg(4002, 0, 0);
1696 }
1697
1698 // Colourise a segment of the document using the current lexing language.
1699 void wxStyledTextCtrl::Colourise(int start, int end) {
1700 SendMsg(4003, start, end);
1701 }
1702
1703 // Set up a value that may be used by a lexer for some optional feature.
1704 void wxStyledTextCtrl::SetProperty(const wxString& key, const wxString& value) {
1705 SendMsg(4004, (long)(const char*)wx2stc(key), (long)(const char*)wx2stc(value));
1706 }
1707
1708 // Set up the key words used by the lexer.
1709 void wxStyledTextCtrl::SetKeyWords(int keywordSet, const wxString& keyWords) {
1710 SendMsg(4005, keywordSet, (long)(const char*)wx2stc(keyWords));
1711 }
1712
1713 // Set the lexing language of the document based on string name.
1714 void wxStyledTextCtrl::SetLexerLanguage(const wxString& language) {
1715 SendMsg(4006, 0, (long)(const char*)wx2stc(language));
1716 }
1717
1718 // END of generated section
1719 //----------------------------------------------------------------------
1720
1721
1722 // Returns the line number of the line with the caret.
1723 int wxStyledTextCtrl::GetCurrentLine() {
1724 int line = LineFromPosition(GetCurrentPos());
1725 return line;
1726 }
1727
1728
1729 // Extract style settings from a spec-string which is composed of one or
1730 // more of the following comma separated elements:
1731 //
1732 // bold turns on bold
1733 // italic turns on italics
1734 // fore:#RRGGBB sets the foreground colour
1735 // back:#RRGGBB sets the background colour
1736 // face:[facename] sets the font face name to use
1737 // size:[num] sets the font size in points
1738 // eol turns on eol filling
1739 // underline turns on underlining
1740 //
1741 void wxStyledTextCtrl::StyleSetSpec(int styleNum, const wxString& spec) {
1742
1743 wxStringTokenizer tkz(spec, wxT(","));
1744 while (tkz.HasMoreTokens()) {
1745 wxString token = tkz.GetNextToken();
1746
1747 wxString option = token.BeforeFirst(':');
1748 wxString val = token.AfterFirst(':');
1749
1750 if (option == wxT("bold"))
1751 StyleSetBold(styleNum, true);
1752
1753 else if (option == wxT("italic"))
1754 StyleSetItalic(styleNum, true);
1755
1756 else if (option == wxT("underline"))
1757 StyleSetUnderline(styleNum, true);
1758
1759 else if (option == wxT("eol"))
1760 StyleSetEOLFilled(styleNum, true);
1761
1762 else if (option == wxT("size")) {
1763 long points;
1764 if (val.ToLong(&points))
1765 StyleSetSize(styleNum, points);
1766 }
1767
1768 else if (option == wxT("face"))
1769 StyleSetFaceName(styleNum, val);
1770
1771 else if (option == wxT("fore"))
1772 StyleSetForeground(styleNum, wxColourFromSpec(val));
1773
1774 else if (option == wxT("back"))
1775 StyleSetBackground(styleNum, wxColourFromSpec(val));
1776 }
1777 }
1778
1779
1780 // Set style size, face, bold, italic, and underline attributes from
1781 // a wxFont's attributes.
1782 void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
1783 int size = font.GetPointSize();
1784 wxString faceName = font.GetFaceName();
1785 bool bold = font.GetWeight() == wxBOLD;
1786 bool italic = font.GetStyle() != wxNORMAL;
1787 bool under = font.GetUnderlined();
1788
1789 // TODO: add encoding/charset mapping
1790 StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
1791 }
1792
1793 // Set all font style attributes at once.
1794 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
1795 const wxString& faceName,
1796 bool bold, bool italic,
1797 bool underline) {
1798 StyleSetSize(styleNum, size);
1799 StyleSetFaceName(styleNum, faceName);
1800 StyleSetBold(styleNum, bold);
1801 StyleSetItalic(styleNum, italic);
1802 StyleSetUnderline(styleNum, underline);
1803
1804 // TODO: add encoding/charset mapping
1805 }
1806
1807
1808 // Perform one of the operations defined by the wxSTC_CMD_* constants.
1809 void wxStyledTextCtrl::CmdKeyExecute(int cmd) {
1810 SendMsg(cmd);
1811 }
1812
1813
1814 // Set the left and right margin in the edit area, measured in pixels.
1815 void wxStyledTextCtrl::SetMargins(int left, int right) {
1816 SetMarginLeft(left);
1817 SetMarginRight(right);
1818 }
1819
1820
1821 // Retrieve the start and end positions of the current selection.
1822 void wxStyledTextCtrl::GetSelection(int* startPos, int* endPos) {
1823 if (startPos != NULL)
1824 *startPos = SendMsg(SCI_GETSELECTIONSTART);
1825 if (endPos != NULL)
1826 *endPos = SendMsg(SCI_GETSELECTIONEND);
1827 }
1828
1829
1830 // Retrieve the point in the window where a position is displayed.
1831 wxPoint wxStyledTextCtrl::PointFromPosition(int pos) {
1832 int x = SendMsg(SCI_POINTXFROMPOSITION, 0, pos);
1833 int y = SendMsg(SCI_POINTYFROMPOSITION, 0, pos);
1834 return wxPoint(x, y);
1835 }
1836
1837 // Scroll enough to make the given line visible
1838 void wxStyledTextCtrl::ScrollToLine(int line) {
1839 m_swx->DoScrollToLine(line);
1840 }
1841
1842
1843 // Scroll enough to make the given column visible
1844 void wxStyledTextCtrl::ScrollToColumn(int column) {
1845 m_swx->DoScrollToColumn(column);
1846 }
1847
1848
1849
1850 //----------------------------------------------------------------------
1851 // Event handlers
1852
1853 void wxStyledTextCtrl::OnPaint(wxPaintEvent& evt) {
1854 wxPaintDC dc(this);
1855 wxRegion region = GetUpdateRegion();
1856
1857 m_swx->DoPaint(&dc, region.GetBox());
1858 }
1859
1860 void wxStyledTextCtrl::OnScrollWin(wxScrollWinEvent& evt) {
1861 if (evt.GetOrientation() == wxHORIZONTAL)
1862 m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
1863 else
1864 m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
1865 }
1866
1867 void wxStyledTextCtrl::OnScroll(wxScrollEvent& evt) {
1868 wxScrollBar* sb = wxDynamicCast(evt.GetEventObject(), wxScrollBar);
1869 if (sb) {
1870 if (sb->IsVertical())
1871 m_swx->DoVScroll(evt.GetEventType(), evt.GetPosition());
1872 else
1873 m_swx->DoHScroll(evt.GetEventType(), evt.GetPosition());
1874 }
1875 }
1876
1877 void wxStyledTextCtrl::OnSize(wxSizeEvent& evt) {
1878 wxSize sz = GetClientSize();
1879 m_swx->DoSize(sz.x, sz.y);
1880 Refresh(FALSE);
1881 }
1882
1883 void wxStyledTextCtrl::OnMouseLeftDown(wxMouseEvent& evt) {
1884 wxPoint pt = evt.GetPosition();
1885 m_swx->DoButtonDown(Point(pt.x, pt.y), m_stopWatch.Time(),
1886 evt.ShiftDown(), evt.ControlDown(), evt.AltDown());
1887 }
1888
1889 void wxStyledTextCtrl::OnMouseMove(wxMouseEvent& evt) {
1890 wxPoint pt = evt.GetPosition();
1891 m_swx->DoButtonMove(Point(pt.x, pt.y));
1892 }
1893
1894 void wxStyledTextCtrl::OnMouseLeftUp(wxMouseEvent& evt) {
1895 wxPoint pt = evt.GetPosition();
1896 m_swx->DoButtonUp(Point(pt.x, pt.y), m_stopWatch.Time(),
1897 evt.ControlDown());
1898 }
1899
1900
1901 void wxStyledTextCtrl::OnMouseRightUp(wxMouseEvent& evt) {
1902 wxPoint pt = evt.GetPosition();
1903 m_swx->DoContextMenu(Point(pt.x, pt.y));
1904 }
1905
1906
1907 void wxStyledTextCtrl::OnContextMenu(wxContextMenuEvent& evt) {
1908 wxPoint pt = evt.GetPosition();
1909 ScreenToClient(&pt.x, &pt.y);
1910 m_swx->DoContextMenu(Point(pt.x, pt.y));
1911 }
1912
1913
1914 void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
1915 m_swx->DoMouseWheel(evt.GetWheelRotation(),
1916 evt.GetWheelDelta(),
1917 evt.GetLinesPerAction(),
1918 evt.ControlDown());
1919 }
1920
1921
1922 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
1923 int key = evt.GetKeyCode();
1924
1925 // On (some?) non-US keyboards the AltGr key is required to enter some
1926 // common characters. It comes to us as both Alt and Ctrl down so we need
1927 // to let the char through in that case, otherwise if only ctrl or only
1928 // alt let's skip it.
1929 bool ctrl = evt.ControlDown();
1930 bool alt = evt.AltDown();
1931 bool skip = ((ctrl || alt) && ! (ctrl && alt));
1932
1933 // printf("OnChar key:%d consumed:%d ctrl:%d alt:%d skip:%d\n",
1934 // key, m_lastKeyDownConsumed, ctrl, alt, skip);
1935
1936 if (key <= WXK_START && /*key >= 32 &&*/ !m_lastKeyDownConsumed && !skip) {
1937 m_swx->DoAddChar(key);
1938 return;
1939 }
1940 evt.Skip();
1941 }
1942
1943
1944 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
1945 int key = evt.GetKeyCode();
1946 bool shift = evt.ShiftDown(),
1947 ctrl = evt.ControlDown(),
1948 alt = evt.AltDown();
1949
1950 int processed = m_swx->DoKeyDown(key, shift, ctrl, alt, &m_lastKeyDownConsumed);
1951
1952 // printf("KeyDn key:%d shift:%d ctrl:%d alt:%d processed:%d consumed:%d\n",
1953 // key, shift, ctrl, alt, processed, m_lastKeyDownConsumed);
1954
1955 if (!processed && !m_lastKeyDownConsumed)
1956 evt.Skip();
1957 }
1958
1959
1960 void wxStyledTextCtrl::OnLoseFocus(wxFocusEvent& evt) {
1961 m_swx->DoLoseFocus();
1962 }
1963
1964
1965 void wxStyledTextCtrl::OnGainFocus(wxFocusEvent& evt) {
1966 m_swx->DoGainFocus();
1967 }
1968
1969
1970 void wxStyledTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& evt) {
1971 m_swx->DoSysColourChange();
1972 }
1973
1974
1975 void wxStyledTextCtrl::OnEraseBackground(wxEraseEvent& evt) {
1976 // do nothing to help avoid flashing
1977 }
1978
1979
1980
1981 void wxStyledTextCtrl::OnMenu(wxCommandEvent& evt) {
1982 m_swx->DoCommand(evt.GetId());
1983 }
1984
1985
1986 void wxStyledTextCtrl::OnListBox(wxCommandEvent& evt) {
1987 m_swx->DoOnListBox();
1988 }
1989
1990
1991 //----------------------------------------------------------------------
1992 // Turn notifications from Scintilla into events
1993
1994
1995 void wxStyledTextCtrl::NotifyChange() {
1996 wxStyledTextEvent evt(wxEVT_STC_CHANGE, GetId());
1997 evt.SetEventObject(this);
1998 GetEventHandler()->ProcessEvent(evt);
1999 }
2000
2001 void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
2002 SCNotification& scn = *_scn;
2003 wxStyledTextEvent evt(0, GetId());
2004
2005 evt.SetEventObject(this);
2006 evt.SetPosition(scn.position);
2007 evt.SetKey(scn.ch);
2008 evt.SetModifiers(scn.modifiers);
2009
2010 switch (scn.nmhdr.code) {
2011 case SCN_STYLENEEDED:
2012 evt.SetEventType(wxEVT_STC_STYLENEEDED);
2013 break;
2014
2015 case SCN_CHARADDED:
2016 evt.SetEventType(wxEVT_STC_CHARADDED);
2017 break;
2018
2019 case SCN_SAVEPOINTREACHED:
2020 evt.SetEventType(wxEVT_STC_SAVEPOINTREACHED);
2021 break;
2022
2023 case SCN_SAVEPOINTLEFT:
2024 evt.SetEventType(wxEVT_STC_SAVEPOINTLEFT);
2025 break;
2026
2027 case SCN_MODIFYATTEMPTRO:
2028 evt.SetEventType(wxEVT_STC_ROMODIFYATTEMPT);
2029 break;
2030
2031 case SCN_KEY:
2032 evt.SetEventType(wxEVT_STC_KEY);
2033 break;
2034
2035 case SCN_DOUBLECLICK:
2036 evt.SetEventType(wxEVT_STC_DOUBLECLICK);
2037 break;
2038
2039 case SCN_UPDATEUI:
2040 evt.SetEventType(wxEVT_STC_UPDATEUI);
2041 break;
2042
2043 case SCN_MODIFIED:
2044 evt.SetEventType(wxEVT_STC_MODIFIED);
2045 evt.SetModificationType(scn.modificationType);
2046 if (scn.text) {
2047 // The unicode conversion MUST have a null byte to terminate the
2048 // string so move it into a buffer first and give it one.
2049 wxMemoryBuffer buf(scn.length+1);
2050 buf.AppendData((void*)scn.text, scn.length);
2051 buf.AppendByte(0);
2052 evt.SetText(stc2wx(buf));
2053 }
2054 evt.SetLength(scn.length);
2055 evt.SetLinesAdded(scn.linesAdded);
2056 evt.SetLine(scn.line);
2057 evt.SetFoldLevelNow(scn.foldLevelNow);
2058 evt.SetFoldLevelPrev(scn.foldLevelPrev);
2059 break;
2060
2061 case SCN_MACRORECORD:
2062 evt.SetEventType(wxEVT_STC_MACRORECORD);
2063 evt.SetMessage(scn.message);
2064 evt.SetWParam(scn.wParam);
2065 evt.SetLParam(scn.lParam);
2066 break;
2067
2068 case SCN_MARGINCLICK:
2069 evt.SetEventType(wxEVT_STC_MARGINCLICK);
2070 evt.SetMargin(scn.margin);
2071 break;
2072
2073 case SCN_NEEDSHOWN:
2074 evt.SetEventType(wxEVT_STC_NEEDSHOWN);
2075 evt.SetLength(scn.length);
2076 break;
2077
2078 case SCN_PAINTED:
2079 evt.SetEventType(wxEVT_STC_PAINTED);
2080 break;
2081
2082 case SCN_USERLISTSELECTION:
2083 evt.SetEventType(wxEVT_STC_USERLISTSELECTION);
2084 evt.SetListType(scn.listType);
2085 evt.SetText(scn.text);
2086 break;
2087
2088 case SCN_URIDROPPED:
2089 evt.SetEventType(wxEVT_STC_URIDROPPED);
2090 evt.SetText(scn.text);
2091 break;
2092
2093 case SCN_DWELLSTART:
2094 evt.SetEventType(wxEVT_STC_DWELLSTART);
2095 evt.SetX(scn.x);
2096 evt.SetY(scn.y);
2097 break;
2098
2099 case SCN_DWELLEND:
2100 evt.SetEventType(wxEVT_STC_DWELLEND);
2101 evt.SetX(scn.x);
2102 evt.SetY(scn.y);
2103 break;
2104
2105 default:
2106 return;
2107 }
2108
2109 GetEventHandler()->ProcessEvent(evt);
2110 }
2111
2112
2113 //----------------------------------------------------------------------
2114 //----------------------------------------------------------------------
2115 //----------------------------------------------------------------------
2116
2117 wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
2118 : wxCommandEvent(commandType, id)
2119 {
2120 m_position = 0;
2121 m_key = 0;
2122 m_modifiers = 0;
2123 m_modificationType = 0;
2124 m_length = 0;
2125 m_linesAdded = 0;
2126 m_line = 0;
2127 m_foldLevelNow = 0;
2128 m_foldLevelPrev = 0;
2129 m_margin = 0;
2130 m_message = 0;
2131 m_wParam = 0;
2132 m_lParam = 0;
2133 m_listType = 0;
2134 m_x = 0;
2135 m_y = 0;
2136 m_dragAllowMove = FALSE;
2137 m_dragResult = wxDragNone;
2138 }
2139
2140 bool wxStyledTextEvent::GetShift() const { return (m_modifiers & SCI_SHIFT) != 0; }
2141 bool wxStyledTextEvent::GetControl() const { return (m_modifiers & SCI_CTRL) != 0; }
2142 bool wxStyledTextEvent::GetAlt() const { return (m_modifiers & SCI_ALT) != 0; }
2143
2144
2145 wxStyledTextEvent::wxStyledTextEvent(const wxStyledTextEvent& event):
2146 wxCommandEvent(event)
2147 {
2148 m_position = event.m_position;
2149 m_key = event.m_key;
2150 m_modifiers = event.m_modifiers;
2151 m_modificationType = event.m_modificationType;
2152 m_text = event.m_text;
2153 m_length = event.m_length;
2154 m_linesAdded = event.m_linesAdded;
2155 m_line = event.m_line;
2156 m_foldLevelNow = event.m_foldLevelNow;
2157 m_foldLevelPrev = event.m_foldLevelPrev;
2158
2159 m_margin = event.m_margin;
2160
2161 m_message = event.m_message;
2162 m_wParam = event.m_wParam;
2163 m_lParam = event.m_lParam;
2164
2165 m_listType = event.m_listType;
2166 m_x = event.m_x;
2167 m_y = event.m_y;
2168
2169 m_dragText = event.m_dragText;
2170 m_dragAllowMove =event.m_dragAllowMove;
2171 m_dragResult = event.m_dragResult;
2172 }
2173
2174 //----------------------------------------------------------------------
2175 //----------------------------------------------------------------------
2176
2177
2178
2179
2180
2181
2182
2183
2184