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