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