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