]> git.saurik.com Git - wxWidgets.git/blob - src/richtext/richtextctrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Skeleton for generic Drag code
[wxWidgets.git] / src / richtext / richtextctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/richtext/richeditctrl.cpp
3 // Purpose: A rich edit control
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 2005-09-30
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_RICHTEXT
20
21 #include "wx/richtext/richtextctrl.h"
22 #include "wx/richtext/richtextstyles.h"
23
24 #ifndef WX_PRECOMP
25 #include "wx/wx.h"
26 #include "wx/settings.h"
27 #endif
28
29 #include "wx/textfile.h"
30 #include "wx/ffile.h"
31 #include "wx/filename.h"
32 #include "wx/dcbuffer.h"
33 #include "wx/arrimpl.cpp"
34 #include "wx/fontenum.h"
35 #include "wx/accel.h"
36
37 // DLL options compatibility check:
38 #include "wx/app.h"
39 WX_CHECK_BUILD_OPTIONS("wxRichTextCtrl")
40
41 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, wxRichTextEvent )
42 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, wxRichTextEvent )
43 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK, wxRichTextEvent )
44 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, wxRichTextEvent )
45 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_RETURN, wxRichTextEvent )
46 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_CHARACTER, wxRichTextEvent )
47 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_DELETE, wxRichTextEvent )
48
49 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, wxRichTextEvent )
50 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, wxRichTextEvent )
51 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, wxRichTextEvent )
52 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, wxRichTextEvent )
53
54 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED, wxRichTextEvent )
55 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED, wxRichTextEvent )
56 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED, wxRichTextEvent )
57 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED, wxRichTextEvent )
58 wxDEFINE_EVENT( wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, wxRichTextEvent )
59
60 #if wxRICHTEXT_USE_OWN_CARET
61
62 /*!
63 * wxRichTextCaret
64 *
65 * This implements a non-flashing cursor in case there
66 * are platform-specific problems with the generic caret.
67 * wxRICHTEXT_USE_OWN_CARET is set in richtextbuffer.h.
68 */
69
70 class wxRichTextCaret: public wxCaret
71 {
72 public:
73 // ctors
74 // -----
75 // default - use Create()
76 wxRichTextCaret() { Init(); }
77 // creates a block caret associated with the given window
78 wxRichTextCaret(wxRichTextCtrl *window, int width, int height)
79 : wxCaret(window, width, height) { Init(); m_richTextCtrl = window; }
80 wxRichTextCaret(wxRichTextCtrl *window, const wxSize& size)
81 : wxCaret(window, size) { Init(); m_richTextCtrl = window; }
82
83 virtual ~wxRichTextCaret();
84
85 // implementation
86 // --------------
87
88 // called by wxWindow (not using the event tables)
89 virtual void OnSetFocus();
90 virtual void OnKillFocus();
91
92 // draw the caret on the given DC
93 void DoDraw(wxDC *dc);
94
95 // get the visible count
96 int GetVisibleCount() const { return m_countVisible; }
97
98 // delay repositioning
99 bool GetNeedsUpdate() const { return m_needsUpdate; }
100 void SetNeedsUpdate(bool needsUpdate = true ) { m_needsUpdate = needsUpdate; }
101
102 protected:
103 virtual void DoShow();
104 virtual void DoHide();
105 virtual void DoMove();
106 virtual void DoSize();
107
108 // refresh the caret
109 void Refresh();
110
111 private:
112 void Init();
113
114 int m_xOld,
115 m_yOld;
116 bool m_hasFocus; // true => our window has focus
117 bool m_needsUpdate; // must be repositioned
118
119 wxRichTextCtrl* m_richTextCtrl;
120 };
121 #endif
122
123 IMPLEMENT_DYNAMIC_CLASS( wxRichTextCtrl, wxControl )
124
125 IMPLEMENT_DYNAMIC_CLASS( wxRichTextEvent, wxNotifyEvent )
126
127 BEGIN_EVENT_TABLE( wxRichTextCtrl, wxControl )
128 EVT_PAINT(wxRichTextCtrl::OnPaint)
129 EVT_ERASE_BACKGROUND(wxRichTextCtrl::OnEraseBackground)
130 EVT_IDLE(wxRichTextCtrl::OnIdle)
131 EVT_SCROLLWIN(wxRichTextCtrl::OnScroll)
132 EVT_LEFT_DOWN(wxRichTextCtrl::OnLeftClick)
133 EVT_MOTION(wxRichTextCtrl::OnMoveMouse)
134 EVT_LEFT_UP(wxRichTextCtrl::OnLeftUp)
135 EVT_RIGHT_DOWN(wxRichTextCtrl::OnRightClick)
136 EVT_MIDDLE_DOWN(wxRichTextCtrl::OnMiddleClick)
137 EVT_LEFT_DCLICK(wxRichTextCtrl::OnLeftDClick)
138 EVT_CHAR(wxRichTextCtrl::OnChar)
139 EVT_KEY_DOWN(wxRichTextCtrl::OnChar)
140 EVT_SIZE(wxRichTextCtrl::OnSize)
141 EVT_SET_FOCUS(wxRichTextCtrl::OnSetFocus)
142 EVT_KILL_FOCUS(wxRichTextCtrl::OnKillFocus)
143 EVT_MOUSE_CAPTURE_LOST(wxRichTextCtrl::OnCaptureLost)
144 EVT_CONTEXT_MENU(wxRichTextCtrl::OnContextMenu)
145 EVT_SYS_COLOUR_CHANGED(wxRichTextCtrl::OnSysColourChanged)
146
147 EVT_MENU(wxID_UNDO, wxRichTextCtrl::OnUndo)
148 EVT_UPDATE_UI(wxID_UNDO, wxRichTextCtrl::OnUpdateUndo)
149
150 EVT_MENU(wxID_REDO, wxRichTextCtrl::OnRedo)
151 EVT_UPDATE_UI(wxID_REDO, wxRichTextCtrl::OnUpdateRedo)
152
153 EVT_MENU(wxID_COPY, wxRichTextCtrl::OnCopy)
154 EVT_UPDATE_UI(wxID_COPY, wxRichTextCtrl::OnUpdateCopy)
155
156 EVT_MENU(wxID_PASTE, wxRichTextCtrl::OnPaste)
157 EVT_UPDATE_UI(wxID_PASTE, wxRichTextCtrl::OnUpdatePaste)
158
159 EVT_MENU(wxID_CUT, wxRichTextCtrl::OnCut)
160 EVT_UPDATE_UI(wxID_CUT, wxRichTextCtrl::OnUpdateCut)
161
162 EVT_MENU(wxID_CLEAR, wxRichTextCtrl::OnClear)
163 EVT_UPDATE_UI(wxID_CLEAR, wxRichTextCtrl::OnUpdateClear)
164
165 EVT_MENU(wxID_SELECTALL, wxRichTextCtrl::OnSelectAll)
166 EVT_UPDATE_UI(wxID_SELECTALL, wxRichTextCtrl::OnUpdateSelectAll)
167 END_EVENT_TABLE()
168
169 /*!
170 * wxRichTextCtrl
171 */
172
173 wxArrayString wxRichTextCtrl::sm_availableFontNames;
174
175 wxRichTextCtrl::wxRichTextCtrl()
176 : wxScrollHelper(this)
177 {
178 Init();
179 }
180
181 wxRichTextCtrl::wxRichTextCtrl(wxWindow* parent,
182 wxWindowID id,
183 const wxString& value,
184 const wxPoint& pos,
185 const wxSize& size,
186 long style,
187 const wxValidator& validator,
188 const wxString& name)
189 : wxScrollHelper(this)
190 {
191 Init();
192 Create(parent, id, value, pos, size, style, validator, name);
193 }
194
195 /// Creation
196 bool wxRichTextCtrl::Create( wxWindow* parent, wxWindowID id, const wxString& value, const wxPoint& pos, const wxSize& size, long style,
197 const wxValidator& validator, const wxString& name)
198 {
199 if (!wxControl::Create(parent, id, pos, size,
200 style|wxFULL_REPAINT_ON_RESIZE,
201 validator, name))
202 return false;
203
204 if (!GetFont().Ok())
205 {
206 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
207 }
208
209 if (style & wxTE_READONLY)
210 SetEditable(false);
211
212 // The base attributes must all have default values
213 wxTextAttr attributes;
214 attributes.SetFont(GetFont());
215 attributes.SetTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
216 attributes.SetAlignment(wxTEXT_ALIGNMENT_LEFT);
217 attributes.SetLineSpacing(10);
218 attributes.SetParagraphSpacingAfter(10);
219 attributes.SetParagraphSpacingBefore(0);
220
221 SetBasicStyle(attributes);
222
223 // The default attributes will be merged with base attributes, so
224 // can be empty to begin with
225 wxTextAttr defaultAttributes;
226 SetDefaultStyle(defaultAttributes);
227
228 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
229 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
230
231 GetBuffer().Reset();
232 GetBuffer().SetRichTextCtrl(this);
233
234 #if wxRICHTEXT_USE_OWN_CARET
235 SetCaret(new wxRichTextCaret(this, wxRICHTEXT_DEFAULT_CARET_WIDTH, 16));
236 #else
237 SetCaret(new wxCaret(this, wxRICHTEXT_DEFAULT_CARET_WIDTH, 16));
238 #endif
239
240 // Tell the sizers to use the given or best size
241 SetInitialSize(size);
242
243 #if wxRICHTEXT_BUFFERED_PAINTING
244 // Create a buffer
245 RecreateBuffer(size);
246 #endif
247
248 m_textCursor = wxCursor(wxCURSOR_IBEAM);
249 m_urlCursor = wxCursor(wxCURSOR_HAND);
250
251 SetCursor(m_textCursor);
252
253 if (!value.IsEmpty())
254 SetValue(value);
255
256 GetBuffer().AddEventHandler(this);
257
258 // Accelerators
259 wxAcceleratorEntry entries[6];
260
261 entries[0].Set(wxACCEL_CMD, (int) 'C', wxID_COPY);
262 entries[1].Set(wxACCEL_CMD, (int) 'X', wxID_CUT);
263 entries[2].Set(wxACCEL_CMD, (int) 'V', wxID_PASTE);
264 entries[3].Set(wxACCEL_CMD, (int) 'A', wxID_SELECTALL);
265 entries[4].Set(wxACCEL_CMD, (int) 'Z', wxID_UNDO);
266 entries[5].Set(wxACCEL_CMD, (int) 'Y', wxID_REDO);
267
268 wxAcceleratorTable accel(6, entries);
269 SetAcceleratorTable(accel);
270
271 return true;
272 }
273
274 wxRichTextCtrl::~wxRichTextCtrl()
275 {
276 GetBuffer().RemoveEventHandler(this);
277
278 delete m_contextMenu;
279 }
280
281 /// Member initialisation
282 void wxRichTextCtrl::Init()
283 {
284 m_contextMenu = NULL;
285 m_caret = NULL;
286 m_caretPosition = -1;
287 m_selectionRange.SetRange(-2, -2);
288 m_selectionAnchor = -2;
289 m_editable = true;
290 m_caretAtLineStart = false;
291 m_dragging = false;
292 m_fullLayoutRequired = false;
293 m_fullLayoutTime = 0;
294 m_fullLayoutSavedPosition = 0;
295 m_delayedLayoutThreshold = wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD;
296 m_caretPositionForDefaultStyle = -2;
297 }
298
299 void wxRichTextCtrl::DoThaw()
300 {
301 if (GetBuffer().GetDirty())
302 LayoutContent();
303 else
304 SetupScrollbars();
305
306 wxWindow::DoThaw();
307 }
308
309 /// Clear all text
310 void wxRichTextCtrl::Clear()
311 {
312 m_buffer.ResetAndClearCommands();
313 m_buffer.SetDirty(true);
314 m_caretPosition = -1;
315 m_caretPositionForDefaultStyle = -2;
316 m_caretAtLineStart = false;
317 m_selectionRange.SetRange(-2, -2);
318
319 Scroll(0,0);
320
321 if (!IsFrozen())
322 {
323 LayoutContent();
324 Refresh(false);
325 }
326
327 wxTextCtrl::SendTextUpdatedEvent(this);
328 }
329
330 /// Painting
331 void wxRichTextCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
332 {
333 #if !wxRICHTEXT_USE_OWN_CARET
334 if (GetCaret() && !IsFrozen())
335 GetCaret()->Hide();
336 #endif
337
338 {
339 #if wxRICHTEXT_BUFFERED_PAINTING
340 wxBufferedPaintDC dc(this, m_bufferBitmap);
341 #else
342 wxPaintDC dc(this);
343 #endif
344
345 if (IsFrozen())
346 return;
347
348 PrepareDC(dc);
349
350 dc.SetFont(GetFont());
351
352 // Paint the background
353 PaintBackground(dc);
354
355 // wxRect drawingArea(GetLogicalPoint(wxPoint(0, 0)), GetClientSize());
356
357 wxRect drawingArea(GetUpdateRegion().GetBox());
358 drawingArea.SetPosition(GetLogicalPoint(drawingArea.GetPosition()));
359
360 wxRect availableSpace(GetClientSize());
361 if (GetBuffer().GetDirty())
362 {
363 GetBuffer().Layout(dc, availableSpace, wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT);
364 GetBuffer().SetDirty(false);
365 SetupScrollbars();
366 }
367
368 GetBuffer().Draw(dc, GetBuffer().GetRange(), GetInternalSelectionRange(), drawingArea, 0 /* descent */, 0 /* flags */);
369 #if wxRICHTEXT_USE_OWN_CARET
370 if (GetCaret()->IsVisible())
371 {
372 ((wxRichTextCaret*) GetCaret())->DoDraw(& dc);
373 }
374 #endif
375 }
376
377 #if !wxRICHTEXT_USE_OWN_CARET
378 if (GetCaret())
379 GetCaret()->Show();
380 PositionCaret();
381 #endif
382 }
383
384 // Empty implementation, to prevent flicker
385 void wxRichTextCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
386 {
387 }
388
389 void wxRichTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
390 {
391 if (GetCaret())
392 {
393 #if !wxRICHTEXT_USE_OWN_CARET
394 PositionCaret();
395 #endif
396 GetCaret()->Show();
397 }
398
399 #if defined(__WXGTK__) && !wxRICHTEXT_USE_OWN_CARET
400 // Work around dropouts when control is focused
401 if (!IsFrozen())
402 {
403 Refresh(false);
404 }
405 #endif
406 }
407
408 void wxRichTextCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
409 {
410 if (GetCaret())
411 GetCaret()->Hide();
412
413 #if defined(__WXGTK__) && !wxRICHTEXT_USE_OWN_CARET
414 // Work around dropouts when control is focused
415 if (!IsFrozen())
416 {
417 Refresh(false);
418 }
419 #endif
420 }
421
422 void wxRichTextCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
423 {
424 m_dragging = false;
425 }
426
427 /// Left-click
428 void wxRichTextCtrl::OnLeftClick(wxMouseEvent& event)
429 {
430 SetFocus();
431
432 wxClientDC dc(this);
433 PrepareDC(dc);
434 dc.SetFont(GetFont());
435
436 long position = 0;
437 int hit = GetBuffer().HitTest(dc, event.GetLogicalPosition(dc), position);
438
439 if (hit != wxRICHTEXT_HITTEST_NONE)
440 {
441 m_dragStart = event.GetLogicalPosition(dc);
442 m_dragging = true;
443 CaptureMouse();
444
445 bool caretAtLineStart = false;
446
447 if (hit & wxRICHTEXT_HITTEST_BEFORE)
448 {
449 // If we're at the start of a line (but not first in para)
450 // then we should keep the caret showing at the start of the line
451 // by showing the m_caretAtLineStart flag.
452 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
453 wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
454
455 if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
456 caretAtLineStart = true;
457 position --;
458 }
459
460 long oldCaretPos = m_caretPosition;
461
462 MoveCaret(position, caretAtLineStart);
463 SetDefaultStyleToCursorStyle();
464
465 if (event.ShiftDown())
466 {
467 if (m_selectionRange.GetStart() == -2)
468 ExtendSelection(oldCaretPos, m_caretPosition, wxRICHTEXT_SHIFT_DOWN);
469 else
470 ExtendSelection(m_caretPosition, m_caretPosition, wxRICHTEXT_SHIFT_DOWN);
471 }
472 else
473 SelectNone();
474 }
475
476 event.Skip();
477 }
478
479 /// Left-up
480 void wxRichTextCtrl::OnLeftUp(wxMouseEvent& event)
481 {
482 if (m_dragging)
483 {
484 m_dragging = false;
485 if (GetCapture() == this)
486 ReleaseMouse();
487
488 // See if we clicked on a URL
489 wxClientDC dc(this);
490 PrepareDC(dc);
491 dc.SetFont(GetFont());
492
493 long position = 0;
494 wxPoint logicalPt = event.GetLogicalPosition(dc);
495 int hit = GetBuffer().HitTest(dc, logicalPt, position);
496
497 if ((hit != wxRICHTEXT_HITTEST_NONE) && !(hit & wxRICHTEXT_HITTEST_OUTSIDE))
498 {
499 wxRichTextEvent cmdEvent(
500 wxEVT_COMMAND_RICHTEXT_LEFT_CLICK,
501 GetId());
502 cmdEvent.SetEventObject(this);
503 cmdEvent.SetPosition(m_caretPosition+1);
504
505 if (!GetEventHandler()->ProcessEvent(cmdEvent))
506 {
507 wxTextAttr attr;
508 if (GetStyle(position, attr))
509 {
510 if (attr.HasFlag(wxTEXT_ATTR_URL))
511 {
512 wxString urlTarget = attr.GetURL();
513 if (!urlTarget.IsEmpty())
514 {
515 wxMouseEvent mouseEvent(event);
516
517 long startPos = 0, endPos = 0;
518 wxRichTextObject* obj = GetBuffer().GetLeafObjectAtPosition(position);
519 if (obj)
520 {
521 startPos = obj->GetRange().GetStart();
522 endPos = obj->GetRange().GetEnd();
523 }
524
525 wxTextUrlEvent urlEvent(GetId(), mouseEvent, startPos, endPos);
526 InitCommandEvent(urlEvent);
527
528 urlEvent.SetString(urlTarget);
529
530 GetEventHandler()->ProcessEvent(urlEvent);
531 }
532 }
533 }
534 }
535 }
536 }
537 }
538
539 /// Left-click
540 void wxRichTextCtrl::OnMoveMouse(wxMouseEvent& event)
541 {
542 wxClientDC dc(this);
543 PrepareDC(dc);
544 dc.SetFont(GetFont());
545
546 long position = 0;
547 wxPoint logicalPt = event.GetLogicalPosition(dc);
548 int hit = GetBuffer().HitTest(dc, logicalPt, position);
549
550 // See if we need to change the cursor
551
552 {
553 if (hit != wxRICHTEXT_HITTEST_NONE && !(hit & wxRICHTEXT_HITTEST_OUTSIDE))
554 {
555 wxTextAttr attr;
556 if (GetStyle(position, attr))
557 {
558 if (attr.HasFlag(wxTEXT_ATTR_URL))
559 {
560 SetCursor(m_urlCursor);
561 }
562 else if (!attr.HasFlag(wxTEXT_ATTR_URL))
563 {
564 SetCursor(m_textCursor);
565 }
566 }
567 }
568 else
569 SetCursor(m_textCursor);
570 }
571
572 if (!event.Dragging())
573 {
574 event.Skip();
575 return;
576 }
577
578 if (m_dragging && hit != wxRICHTEXT_HITTEST_NONE)
579 {
580 // TODO: test closeness
581
582 bool caretAtLineStart = false;
583
584 if (hit & wxRICHTEXT_HITTEST_BEFORE)
585 {
586 // If we're at the start of a line (but not first in para)
587 // then we should keep the caret showing at the start of the line
588 // by showing the m_caretAtLineStart flag.
589 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
590 wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
591
592 if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
593 caretAtLineStart = true;
594 position --;
595 }
596
597 if (m_caretPosition != position)
598 {
599 ExtendSelection(m_caretPosition, position, wxRICHTEXT_SHIFT_DOWN);
600
601 MoveCaret(position, caretAtLineStart);
602 SetDefaultStyleToCursorStyle();
603 }
604 }
605 }
606
607 /// Right-click
608 void wxRichTextCtrl::OnRightClick(wxMouseEvent& event)
609 {
610 SetFocus();
611
612 wxRichTextEvent cmdEvent(
613 wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK,
614 GetId());
615 cmdEvent.SetEventObject(this);
616 cmdEvent.SetPosition(m_caretPosition+1);
617
618 if (!GetEventHandler()->ProcessEvent(cmdEvent))
619 event.Skip();
620 }
621
622 /// Left-double-click
623 void wxRichTextCtrl::OnLeftDClick(wxMouseEvent& WXUNUSED(event))
624 {
625 wxRichTextEvent cmdEvent(
626 wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK,
627 GetId());
628 cmdEvent.SetEventObject(this);
629 cmdEvent.SetPosition(m_caretPosition+1);
630
631 if (!GetEventHandler()->ProcessEvent(cmdEvent))
632 {
633 SelectWord(GetCaretPosition()+1);
634 }
635 }
636
637 /// Middle-click
638 void wxRichTextCtrl::OnMiddleClick(wxMouseEvent& event)
639 {
640 wxRichTextEvent cmdEvent(
641 wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK,
642 GetId());
643 cmdEvent.SetEventObject(this);
644 cmdEvent.SetPosition(m_caretPosition+1);
645
646 if (!GetEventHandler()->ProcessEvent(cmdEvent))
647 event.Skip();
648 }
649
650 /// Key press
651 void wxRichTextCtrl::OnChar(wxKeyEvent& event)
652 {
653 int flags = 0;
654 if (event.CmdDown())
655 flags |= wxRICHTEXT_CTRL_DOWN;
656 if (event.ShiftDown())
657 flags |= wxRICHTEXT_SHIFT_DOWN;
658 if (event.AltDown())
659 flags |= wxRICHTEXT_ALT_DOWN;
660
661 if (event.GetEventType() == wxEVT_KEY_DOWN)
662 {
663 if (event.GetKeyCode() == WXK_LEFT ||
664 event.GetKeyCode() == WXK_RIGHT ||
665 event.GetKeyCode() == WXK_UP ||
666 event.GetKeyCode() == WXK_DOWN ||
667 event.GetKeyCode() == WXK_HOME ||
668 event.GetKeyCode() == WXK_PAGEUP ||
669 event.GetKeyCode() == WXK_PAGEDOWN ||
670 event.GetKeyCode() == WXK_END ||
671
672 event.GetKeyCode() == WXK_NUMPAD_LEFT ||
673 event.GetKeyCode() == WXK_NUMPAD_RIGHT ||
674 event.GetKeyCode() == WXK_NUMPAD_UP ||
675 event.GetKeyCode() == WXK_NUMPAD_DOWN ||
676 event.GetKeyCode() == WXK_NUMPAD_HOME ||
677 event.GetKeyCode() == WXK_NUMPAD_PAGEUP ||
678 event.GetKeyCode() == WXK_NUMPAD_PAGEDOWN ||
679 event.GetKeyCode() == WXK_NUMPAD_END)
680 {
681 KeyboardNavigate(event.GetKeyCode(), flags);
682 return;
683 }
684
685 long keycode = event.GetKeyCode();
686 switch ( keycode )
687 {
688 case WXK_ESCAPE:
689 case WXK_START:
690 case WXK_LBUTTON:
691 case WXK_RBUTTON:
692 case WXK_CANCEL:
693 case WXK_MBUTTON:
694 case WXK_CLEAR:
695 case WXK_SHIFT:
696 case WXK_ALT:
697 case WXK_CONTROL:
698 case WXK_MENU:
699 case WXK_PAUSE:
700 case WXK_CAPITAL:
701 case WXK_END:
702 case WXK_HOME:
703 case WXK_LEFT:
704 case WXK_UP:
705 case WXK_RIGHT:
706 case WXK_DOWN:
707 case WXK_SELECT:
708 case WXK_PRINT:
709 case WXK_EXECUTE:
710 case WXK_SNAPSHOT:
711 case WXK_INSERT:
712 case WXK_HELP:
713 case WXK_F1:
714 case WXK_F2:
715 case WXK_F3:
716 case WXK_F4:
717 case WXK_F5:
718 case WXK_F6:
719 case WXK_F7:
720 case WXK_F8:
721 case WXK_F9:
722 case WXK_F10:
723 case WXK_F11:
724 case WXK_F12:
725 case WXK_F13:
726 case WXK_F14:
727 case WXK_F15:
728 case WXK_F16:
729 case WXK_F17:
730 case WXK_F18:
731 case WXK_F19:
732 case WXK_F20:
733 case WXK_F21:
734 case WXK_F22:
735 case WXK_F23:
736 case WXK_F24:
737 case WXK_NUMLOCK:
738 case WXK_SCROLL:
739 case WXK_PAGEUP:
740 case WXK_PAGEDOWN:
741 case WXK_NUMPAD_F1:
742 case WXK_NUMPAD_F2:
743 case WXK_NUMPAD_F3:
744 case WXK_NUMPAD_F4:
745 case WXK_NUMPAD_HOME:
746 case WXK_NUMPAD_LEFT:
747 case WXK_NUMPAD_UP:
748 case WXK_NUMPAD_RIGHT:
749 case WXK_NUMPAD_DOWN:
750 case WXK_NUMPAD_PAGEUP:
751 case WXK_NUMPAD_PAGEDOWN:
752 case WXK_NUMPAD_END:
753 case WXK_NUMPAD_BEGIN:
754 case WXK_NUMPAD_INSERT:
755 case WXK_NUMPAD_DELETE:
756 case WXK_WINDOWS_LEFT:
757 {
758 return;
759 }
760 default:
761 {
762 }
763 }
764
765 // Must process this before translation, otherwise it's translated into a WXK_DELETE event.
766 if (event.CmdDown() && event.GetKeyCode() == WXK_BACK)
767 {
768 BeginBatchUndo(_("Delete Text"));
769
770 long newPos = m_caretPosition;
771
772 bool processed = DeleteSelectedContent(& newPos);
773
774 // Submit range in character positions, which are greater than caret positions,
775 // so subtract 1 for deleted character and add 1 for conversion to character position.
776 if (newPos > -1)
777 {
778 if (event.CmdDown())
779 {
780 long pos = wxRichTextCtrl::FindNextWordPosition(-1);
781 if (pos < newPos)
782 {
783 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(pos+1, newPos), this);
784 processed = true;
785 }
786 }
787
788 if (!processed)
789 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(newPos, newPos), this);
790 }
791
792 EndBatchUndo();
793
794 if (GetLastPosition() == -1)
795 {
796 GetBuffer().Reset();
797
798 m_caretPosition = -1;
799 PositionCaret();
800 SetDefaultStyleToCursorStyle();
801 }
802
803 ScrollIntoView(m_caretPosition, WXK_LEFT);
804
805 wxRichTextEvent cmdEvent(
806 wxEVT_COMMAND_RICHTEXT_DELETE,
807 GetId());
808 cmdEvent.SetEventObject(this);
809 cmdEvent.SetFlags(flags);
810 cmdEvent.SetPosition(m_caretPosition+1);
811 GetEventHandler()->ProcessEvent(cmdEvent);
812
813 Update();
814 }
815 else
816 event.Skip();
817
818 return;
819 }
820
821 // all the other keys modify the controls contents which shouldn't be
822 // possible if we're read-only
823 if ( !IsEditable() )
824 {
825 event.Skip();
826 return;
827 }
828
829 if (event.GetKeyCode() == WXK_RETURN)
830 {
831 BeginBatchUndo(_("Insert Text"));
832
833 long newPos = m_caretPosition;
834
835 DeleteSelectedContent(& newPos);
836
837 if (event.ShiftDown())
838 {
839 wxString text;
840 text = wxRichTextLineBreakChar;
841 GetBuffer().InsertTextWithUndo(newPos+1, text, this);
842 m_caretAtLineStart = true;
843 PositionCaret();
844 }
845 else
846 GetBuffer().InsertNewlineWithUndo(newPos+1, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE|wxRICHTEXT_INSERT_INTERACTIVE);
847
848 EndBatchUndo();
849 SetDefaultStyleToCursorStyle();
850
851 ScrollIntoView(m_caretPosition, WXK_RIGHT);
852
853 wxRichTextEvent cmdEvent(
854 wxEVT_COMMAND_RICHTEXT_RETURN,
855 GetId());
856 cmdEvent.SetEventObject(this);
857 cmdEvent.SetFlags(flags);
858 cmdEvent.SetPosition(newPos+1);
859
860 if (!GetEventHandler()->ProcessEvent(cmdEvent))
861 {
862 // Generate conventional event
863 wxCommandEvent textEvent(wxEVT_COMMAND_TEXT_ENTER, GetId());
864 InitCommandEvent(textEvent);
865
866 GetEventHandler()->ProcessEvent(textEvent);
867 }
868 Update();
869 }
870 else if (event.GetKeyCode() == WXK_BACK)
871 {
872 BeginBatchUndo(_("Delete Text"));
873
874 long newPos = m_caretPosition;
875
876 bool processed = DeleteSelectedContent(& newPos);
877
878 // Submit range in character positions, which are greater than caret positions,
879 // so subtract 1 for deleted character and add 1 for conversion to character position.
880 if (newPos > -1)
881 {
882 if (event.CmdDown())
883 {
884 long pos = wxRichTextCtrl::FindNextWordPosition(-1);
885 if (pos < newPos)
886 {
887 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(pos+1, newPos), this);
888 processed = true;
889 }
890 }
891
892 if (!processed)
893 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(newPos, newPos), this);
894 }
895
896 EndBatchUndo();
897
898 if (GetLastPosition() == -1)
899 {
900 GetBuffer().Reset();
901
902 m_caretPosition = -1;
903 PositionCaret();
904 SetDefaultStyleToCursorStyle();
905 }
906
907 ScrollIntoView(m_caretPosition, WXK_LEFT);
908
909 wxRichTextEvent cmdEvent(
910 wxEVT_COMMAND_RICHTEXT_DELETE,
911 GetId());
912 cmdEvent.SetEventObject(this);
913 cmdEvent.SetFlags(flags);
914 cmdEvent.SetPosition(m_caretPosition+1);
915 GetEventHandler()->ProcessEvent(cmdEvent);
916
917 Update();
918 }
919 else if (event.GetKeyCode() == WXK_DELETE)
920 {
921 BeginBatchUndo(_("Delete Text"));
922
923 long newPos = m_caretPosition;
924
925 bool processed = DeleteSelectedContent(& newPos);
926
927 // Submit range in character positions, which are greater than caret positions,
928 if (newPos < GetBuffer().GetRange().GetEnd()+1)
929 {
930 if (event.CmdDown())
931 {
932 long pos = wxRichTextCtrl::FindNextWordPosition(1);
933 if (pos != -1 && (pos > newPos))
934 {
935 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(newPos+1, pos), this);
936 processed = true;
937 }
938 }
939
940 if (!processed)
941 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(newPos+1, newPos+1), this);
942 }
943
944 EndBatchUndo();
945
946 if (GetLastPosition() == -1)
947 {
948 GetBuffer().Reset();
949
950 m_caretPosition = -1;
951 PositionCaret();
952 SetDefaultStyleToCursorStyle();
953 }
954
955 wxRichTextEvent cmdEvent(
956 wxEVT_COMMAND_RICHTEXT_DELETE,
957 GetId());
958 cmdEvent.SetEventObject(this);
959 cmdEvent.SetFlags(flags);
960 cmdEvent.SetPosition(m_caretPosition+1);
961 GetEventHandler()->ProcessEvent(cmdEvent);
962
963 Update();
964 }
965 else
966 {
967 long keycode = event.GetKeyCode();
968 switch ( keycode )
969 {
970 case WXK_ESCAPE:
971 {
972 event.Skip();
973 return;
974 }
975
976 default:
977 {
978 #ifdef __WXMAC__
979 if (event.CmdDown())
980 #else
981 if (event.CmdDown() || event.AltDown())
982 #endif
983 {
984 event.Skip();
985 return;
986 }
987
988 wxRichTextEvent cmdEvent(
989 wxEVT_COMMAND_RICHTEXT_CHARACTER,
990 GetId());
991 cmdEvent.SetEventObject(this);
992 cmdEvent.SetFlags(flags);
993 #if wxUSE_UNICODE
994 cmdEvent.SetCharacter(event.GetUnicodeKey());
995 #else
996 cmdEvent.SetCharacter((wxChar) keycode);
997 #endif
998 cmdEvent.SetPosition(m_caretPosition+1);
999
1000 if (keycode == wxT('\t'))
1001 {
1002 // See if we need to promote or demote the selection or paragraph at the cursor
1003 // position, instead of inserting a tab.
1004 long pos = GetAdjustedCaretPosition(GetCaretPosition());
1005 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos);
1006 if (para && para->GetRange().GetStart() == pos && para->GetAttributes().HasListStyleName())
1007 {
1008 wxRichTextRange range;
1009 if (HasSelection())
1010 range = GetSelectionRange();
1011 else
1012 range = para->GetRange().FromInternal();
1013
1014 int promoteBy = event.ShiftDown() ? 1 : -1;
1015
1016 PromoteList(promoteBy, range, NULL);
1017
1018 GetEventHandler()->ProcessEvent(cmdEvent);
1019
1020 return;
1021 }
1022 }
1023
1024 BeginBatchUndo(_("Insert Text"));
1025
1026 long newPos = m_caretPosition;
1027 DeleteSelectedContent(& newPos);
1028
1029 #if wxUSE_UNICODE
1030 wxString str = event.GetUnicodeKey();
1031 #else
1032 wxString str = (wxChar) event.GetKeyCode();
1033 #endif
1034 GetBuffer().InsertTextWithUndo(newPos+1, str, this, 0);
1035
1036 EndBatchUndo();
1037
1038 SetDefaultStyleToCursorStyle();
1039 ScrollIntoView(m_caretPosition, WXK_RIGHT);
1040
1041 GetEventHandler()->ProcessEvent(cmdEvent);
1042
1043 Update();
1044 }
1045 }
1046 }
1047 }
1048
1049 /// Delete content if there is a selection, e.g. when pressing a key.
1050 bool wxRichTextCtrl::DeleteSelectedContent(long* newPos)
1051 {
1052 if (HasSelection())
1053 {
1054 long pos = m_selectionRange.GetStart();
1055 GetBuffer().DeleteRangeWithUndo(m_selectionRange, this);
1056 m_selectionRange.SetRange(-2, -2);
1057
1058 if (newPos)
1059 *newPos = pos-1;
1060 return true;
1061 }
1062 else
1063 return false;
1064 }
1065
1066 /// Keyboard navigation
1067
1068 /*
1069
1070 Left: left one character
1071 Right: right one character
1072 Up: up one line
1073 Down: down one line
1074 Ctrl-Left: left one word
1075 Ctrl-Right: right one word
1076 Ctrl-Up: previous paragraph start
1077 Ctrl-Down: next start of paragraph
1078 Home: start of line
1079 End: end of line
1080 Ctrl-Home: start of document
1081 Ctrl-End: end of document
1082 Page-Up: Up a screen
1083 Page-Down: Down a screen
1084
1085 Maybe:
1086
1087 Ctrl-Alt-PgUp: Start of window
1088 Ctrl-Alt-PgDn: End of window
1089 F8: Start selection mode
1090 Esc: End selection mode
1091
1092 Adding Shift does the above but starts/extends selection.
1093
1094
1095 */
1096
1097 bool wxRichTextCtrl::KeyboardNavigate(int keyCode, int flags)
1098 {
1099 bool success = false;
1100
1101 if (keyCode == WXK_RIGHT || keyCode == WXK_NUMPAD_RIGHT)
1102 {
1103 if (flags & wxRICHTEXT_CTRL_DOWN)
1104 success = WordRight(1, flags);
1105 else
1106 success = MoveRight(1, flags);
1107 }
1108 else if (keyCode == WXK_LEFT || keyCode == WXK_NUMPAD_LEFT)
1109 {
1110 if (flags & wxRICHTEXT_CTRL_DOWN)
1111 success = WordLeft(1, flags);
1112 else
1113 success = MoveLeft(1, flags);
1114 }
1115 else if (keyCode == WXK_UP || keyCode == WXK_NUMPAD_UP)
1116 {
1117 if (flags & wxRICHTEXT_CTRL_DOWN)
1118 success = MoveToParagraphStart(flags);
1119 else
1120 success = MoveUp(1, flags);
1121 }
1122 else if (keyCode == WXK_DOWN || keyCode == WXK_NUMPAD_DOWN)
1123 {
1124 if (flags & wxRICHTEXT_CTRL_DOWN)
1125 success = MoveToParagraphEnd(flags);
1126 else
1127 success = MoveDown(1, flags);
1128 }
1129 else if (keyCode == WXK_PAGEUP || keyCode == WXK_NUMPAD_PAGEUP)
1130 {
1131 success = PageUp(1, flags);
1132 }
1133 else if (keyCode == WXK_PAGEDOWN || keyCode == WXK_NUMPAD_PAGEDOWN)
1134 {
1135 success = PageDown(1, flags);
1136 }
1137 else if (keyCode == WXK_HOME || keyCode == WXK_NUMPAD_HOME)
1138 {
1139 if (flags & wxRICHTEXT_CTRL_DOWN)
1140 success = MoveHome(flags);
1141 else
1142 success = MoveToLineStart(flags);
1143 }
1144 else if (keyCode == WXK_END || keyCode == WXK_NUMPAD_END)
1145 {
1146 if (flags & wxRICHTEXT_CTRL_DOWN)
1147 success = MoveEnd(flags);
1148 else
1149 success = MoveToLineEnd(flags);
1150 }
1151
1152 if (success)
1153 {
1154 ScrollIntoView(m_caretPosition, keyCode);
1155 SetDefaultStyleToCursorStyle();
1156 }
1157
1158 return success;
1159 }
1160
1161 /// Extend the selection. Selections are in caret positions.
1162 bool wxRichTextCtrl::ExtendSelection(long oldPos, long newPos, int flags)
1163 {
1164 if (flags & wxRICHTEXT_SHIFT_DOWN)
1165 {
1166 if (oldPos == newPos)
1167 return false;
1168
1169 wxRichTextRange oldSelection = m_selectionRange;
1170
1171 // If not currently selecting, start selecting
1172 if (m_selectionRange.GetStart() == -2)
1173 {
1174 m_selectionAnchor = oldPos;
1175
1176 if (oldPos > newPos)
1177 m_selectionRange.SetRange(newPos+1, oldPos);
1178 else
1179 m_selectionRange.SetRange(oldPos+1, newPos);
1180 }
1181 else
1182 {
1183 // Always ensure that the selection range start is greater than
1184 // the end.
1185 if (newPos > m_selectionAnchor)
1186 m_selectionRange.SetRange(m_selectionAnchor+1, newPos);
1187 else if (newPos == m_selectionAnchor)
1188 m_selectionRange = wxRichTextRange(-2, -2);
1189 else
1190 m_selectionRange.SetRange(newPos+1, m_selectionAnchor);
1191 }
1192
1193 RefreshForSelectionChange(oldSelection, m_selectionRange);
1194
1195 if (m_selectionRange.GetStart() > m_selectionRange.GetEnd())
1196 {
1197 wxLogDebug(wxT("Strange selection range"));
1198 }
1199
1200 return true;
1201 }
1202 else
1203 return false;
1204 }
1205
1206 /// Scroll into view, returning true if we scrolled.
1207 /// This takes a _caret_ position.
1208 bool wxRichTextCtrl::ScrollIntoView(long position, int keyCode)
1209 {
1210 wxRichTextLine* line = GetVisibleLineForCaretPosition(position);
1211
1212 if (!line)
1213 return false;
1214
1215 int ppuX, ppuY;
1216 GetScrollPixelsPerUnit(& ppuX, & ppuY);
1217
1218 int startXUnits, startYUnits;
1219 GetViewStart(& startXUnits, & startYUnits);
1220 int startY = startYUnits * ppuY;
1221
1222 int sx = 0, sy = 0;
1223 GetVirtualSize(& sx, & sy);
1224 int sxUnits = 0;
1225 int syUnits = 0;
1226 if (ppuY != 0)
1227 syUnits = sy/ppuY;
1228
1229 wxRect rect = line->GetRect();
1230
1231 bool scrolled = false;
1232
1233 wxSize clientSize = GetClientSize();
1234
1235 // Going down
1236 if (keyCode == WXK_DOWN || keyCode == WXK_NUMPAD_DOWN ||
1237 keyCode == WXK_RIGHT || keyCode == WXK_NUMPAD_RIGHT ||
1238 keyCode == WXK_END || keyCode == WXK_NUMPAD_END ||
1239 keyCode == WXK_PAGEDOWN || keyCode == WXK_NUMPAD_PAGEDOWN)
1240 {
1241 if ((rect.y + rect.height) > (clientSize.y + startY))
1242 {
1243 // Make it scroll so this item is at the bottom
1244 // of the window
1245 int y = rect.y - (clientSize.y - rect.height);
1246 int yUnits = (int) (0.5 + ((float) y)/(float) ppuY);
1247
1248 // If we're still off the screen, scroll another line down
1249 if ((rect.y + rect.height) > (clientSize.y + (yUnits*ppuY)))
1250 yUnits ++;
1251
1252 if (startYUnits != yUnits)
1253 {
1254 SetScrollbars(ppuX, ppuY, sxUnits, syUnits, 0, yUnits);
1255 scrolled = true;
1256 }
1257 }
1258 else if (rect.y < startY)
1259 {
1260 // Make it scroll so this item is at the top
1261 // of the window
1262 int y = rect.y ;
1263 int yUnits = (int) (0.5 + ((float) y)/(float) ppuY);
1264
1265 if (startYUnits != yUnits)
1266 {
1267 SetScrollbars(ppuX, ppuY, sxUnits, syUnits, 0, yUnits);
1268 scrolled = true;
1269 }
1270 }
1271 }
1272 // Going up
1273 else if (keyCode == WXK_UP || keyCode == WXK_NUMPAD_UP ||
1274 keyCode == WXK_LEFT || keyCode == WXK_NUMPAD_LEFT ||
1275 keyCode == WXK_HOME || keyCode == WXK_NUMPAD_HOME ||
1276 keyCode == WXK_PAGEUP || keyCode == WXK_NUMPAD_PAGEUP )
1277 {
1278 if (rect.y < startY)
1279 {
1280 // Make it scroll so this item is at the top
1281 // of the window
1282 int y = rect.y ;
1283 int yUnits = (int) (0.5 + ((float) y)/(float) ppuY);
1284
1285 if (startYUnits != yUnits)
1286 {
1287 SetScrollbars(ppuX, ppuY, sxUnits, syUnits, 0, yUnits);
1288 scrolled = true;
1289 }
1290 }
1291 else if ((rect.y + rect.height) > (clientSize.y + startY))
1292 {
1293 // Make it scroll so this item is at the bottom
1294 // of the window
1295 int y = rect.y - (clientSize.y - rect.height);
1296 int yUnits = (int) (0.5 + ((float) y)/(float) ppuY);
1297
1298 // If we're still off the screen, scroll another line down
1299 if ((rect.y + rect.height) > (clientSize.y + (yUnits*ppuY)))
1300 yUnits ++;
1301
1302 if (startYUnits != yUnits)
1303 {
1304 SetScrollbars(ppuX, ppuY, sxUnits, syUnits, 0, yUnits);
1305 scrolled = true;
1306 }
1307 }
1308 }
1309
1310 #if !wxRICHTEXT_USE_OWN_CARET
1311 if (scrolled)
1312 #endif
1313 PositionCaret();
1314
1315 return scrolled;
1316 }
1317
1318 /// Is the given position visible on the screen?
1319 bool wxRichTextCtrl::IsPositionVisible(long pos) const
1320 {
1321 wxRichTextLine* line = GetVisibleLineForCaretPosition(pos-1);
1322
1323 if (!line)
1324 return false;
1325
1326 int ppuX, ppuY;
1327 GetScrollPixelsPerUnit(& ppuX, & ppuY);
1328
1329 int startX, startY;
1330 GetViewStart(& startX, & startY);
1331 startX = 0;
1332 startY = startY * ppuY;
1333
1334 wxRect rect = line->GetRect();
1335 wxSize clientSize = GetClientSize();
1336
1337 return (rect.GetBottom() > startY) && (rect.GetTop() < (startY + clientSize.y));
1338 }
1339
1340 void wxRichTextCtrl::SetCaretPosition(long position, bool showAtLineStart)
1341 {
1342 m_caretPosition = position;
1343 m_caretAtLineStart = showAtLineStart;
1344 }
1345
1346 /// Move caret one visual step forward: this may mean setting a flag
1347 /// and keeping the same position if we're going from the end of one line
1348 /// to the start of the next, which may be the exact same caret position.
1349 void wxRichTextCtrl::MoveCaretForward(long oldPosition)
1350 {
1351 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
1352
1353 // Only do the check if we're not at the end of the paragraph (where things work OK
1354 // anyway)
1355 if (para && (oldPosition != para->GetRange().GetEnd() - 1))
1356 {
1357 wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
1358
1359 if (line)
1360 {
1361 wxRichTextRange lineRange = line->GetAbsoluteRange();
1362
1363 // We're at the end of a line. See whether we need to
1364 // stay at the same actual caret position but change visual
1365 // position, or not.
1366 if (oldPosition == lineRange.GetEnd())
1367 {
1368 if (m_caretAtLineStart)
1369 {
1370 // We're already at the start of the line, so actually move on now.
1371 m_caretPosition = oldPosition + 1;
1372 m_caretAtLineStart = false;
1373 }
1374 else
1375 {
1376 // We're showing at the end of the line, so keep to
1377 // the same position but indicate that we're to show
1378 // at the start of the next line.
1379 m_caretPosition = oldPosition;
1380 m_caretAtLineStart = true;
1381 }
1382 SetDefaultStyleToCursorStyle();
1383 return;
1384 }
1385 }
1386 }
1387 m_caretPosition ++;
1388 SetDefaultStyleToCursorStyle();
1389 }
1390
1391 /// Move caret one visual step backward: this may mean setting a flag
1392 /// and keeping the same position if we're going from the end of one line
1393 /// to the start of the next, which may be the exact same caret position.
1394 void wxRichTextCtrl::MoveCaretBack(long oldPosition)
1395 {
1396 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
1397
1398 // Only do the check if we're not at the start of the paragraph (where things work OK
1399 // anyway)
1400 if (para && (oldPosition != para->GetRange().GetStart()))
1401 {
1402 wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
1403
1404 if (line)
1405 {
1406 wxRichTextRange lineRange = line->GetAbsoluteRange();
1407
1408 // We're at the start of a line. See whether we need to
1409 // stay at the same actual caret position but change visual
1410 // position, or not.
1411 if (oldPosition == lineRange.GetStart())
1412 {
1413 m_caretPosition = oldPosition-1;
1414 m_caretAtLineStart = true;
1415 return;
1416 }
1417 else if (oldPosition == lineRange.GetEnd())
1418 {
1419 if (m_caretAtLineStart)
1420 {
1421 // We're at the start of the line, so keep the same caret position
1422 // but clear the start-of-line flag.
1423 m_caretPosition = oldPosition;
1424 m_caretAtLineStart = false;
1425 }
1426 else
1427 {
1428 // We're showing at the end of the line, so go back
1429 // to the previous character position.
1430 m_caretPosition = oldPosition - 1;
1431 }
1432 SetDefaultStyleToCursorStyle();
1433 return;
1434 }
1435 }
1436 }
1437 m_caretPosition --;
1438 SetDefaultStyleToCursorStyle();
1439 }
1440
1441 /// Move right
1442 bool wxRichTextCtrl::MoveRight(int noPositions, int flags)
1443 {
1444 long endPos = GetBuffer().GetRange().GetEnd();
1445
1446 if (m_caretPosition + noPositions < endPos)
1447 {
1448 long oldPos = m_caretPosition;
1449 long newPos = m_caretPosition + noPositions;
1450
1451 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1452 if (!extendSel)
1453 SelectNone();
1454
1455 // Determine by looking at oldPos and m_caretPosition whether
1456 // we moved from the end of a line to the start of the next line, in which case
1457 // we want to adjust the caret position such that it is positioned at the
1458 // start of the next line, rather than jumping past the first character of the
1459 // line.
1460 if (noPositions == 1 && !extendSel)
1461 MoveCaretForward(oldPos);
1462 else
1463 SetCaretPosition(newPos);
1464
1465 PositionCaret();
1466 SetDefaultStyleToCursorStyle();
1467
1468 return true;
1469 }
1470 else
1471 return false;
1472 }
1473
1474 /// Move left
1475 bool wxRichTextCtrl::MoveLeft(int noPositions, int flags)
1476 {
1477 long startPos = -1;
1478
1479 if (m_caretPosition > startPos - noPositions + 1)
1480 {
1481 long oldPos = m_caretPosition;
1482 long newPos = m_caretPosition - noPositions;
1483 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1484 if (!extendSel)
1485 SelectNone();
1486
1487 if (noPositions == 1 && !extendSel)
1488 MoveCaretBack(oldPos);
1489 else
1490 SetCaretPosition(newPos);
1491
1492 PositionCaret();
1493 SetDefaultStyleToCursorStyle();
1494
1495 return true;
1496 }
1497 else
1498 return false;
1499 }
1500
1501 /// Move up
1502 bool wxRichTextCtrl::MoveUp(int noLines, int flags)
1503 {
1504 return MoveDown(- noLines, flags);
1505 }
1506
1507 /// Move up
1508 bool wxRichTextCtrl::MoveDown(int noLines, int flags)
1509 {
1510 if (!GetCaret())
1511 return false;
1512
1513 long lineNumber = GetBuffer().GetVisibleLineNumber(m_caretPosition, true, m_caretAtLineStart);
1514 wxPoint pt = GetCaret()->GetPosition();
1515 long newLine = lineNumber + noLines;
1516
1517 if (lineNumber != -1)
1518 {
1519 if (noLines > 0)
1520 {
1521 long lastLine = GetBuffer().GetVisibleLineNumber(GetBuffer().GetRange().GetEnd());
1522
1523 if (newLine > lastLine)
1524 return false;
1525 }
1526 else
1527 {
1528 if (newLine < 0)
1529 return false;
1530 }
1531 }
1532
1533 wxRichTextLine* lineObj = GetBuffer().GetLineForVisibleLineNumber(newLine);
1534 if (lineObj)
1535 {
1536 pt.y = lineObj->GetAbsolutePosition().y + 2;
1537 }
1538 else
1539 return false;
1540
1541 long newPos = 0;
1542 wxClientDC dc(this);
1543 PrepareDC(dc);
1544 dc.SetFont(GetFont());
1545
1546 int hitTest = GetBuffer().HitTest(dc, pt, newPos);
1547
1548 if (hitTest != wxRICHTEXT_HITTEST_NONE)
1549 {
1550 // If end of previous line, and hitTest is wxRICHTEXT_HITTEST_BEFORE,
1551 // we want to be at the end of the last line but with m_caretAtLineStart set to true,
1552 // so we view the caret at the start of the line.
1553 bool caretLineStart = false;
1554 if (hitTest & wxRICHTEXT_HITTEST_BEFORE)
1555 {
1556 wxRichTextLine* thisLine = GetBuffer().GetLineAtPosition(newPos-1);
1557 wxRichTextRange lineRange;
1558 if (thisLine)
1559 lineRange = thisLine->GetAbsoluteRange();
1560
1561 if (thisLine && (newPos-1) == lineRange.GetEnd())
1562 {
1563 newPos --;
1564 caretLineStart = true;
1565 }
1566 else
1567 {
1568 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(newPos);
1569 if (para && para->GetRange().GetStart() == newPos)
1570 newPos --;
1571 }
1572 }
1573
1574 long newSelEnd = newPos;
1575
1576 bool extendSel = ExtendSelection(m_caretPosition, newSelEnd, flags);
1577 if (!extendSel)
1578 SelectNone();
1579
1580 SetCaretPosition(newPos, caretLineStart);
1581 PositionCaret();
1582 SetDefaultStyleToCursorStyle();
1583
1584 return true;
1585 }
1586
1587 return false;
1588 }
1589
1590 /// Move to the end of the paragraph
1591 bool wxRichTextCtrl::MoveToParagraphEnd(int flags)
1592 {
1593 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1594 if (para)
1595 {
1596 long newPos = para->GetRange().GetEnd() - 1;
1597 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1598 if (!extendSel)
1599 SelectNone();
1600
1601 SetCaretPosition(newPos);
1602 PositionCaret();
1603 SetDefaultStyleToCursorStyle();
1604
1605 return true;
1606 }
1607
1608 return false;
1609 }
1610
1611 /// Move to the start of the paragraph
1612 bool wxRichTextCtrl::MoveToParagraphStart(int flags)
1613 {
1614 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1615 if (para)
1616 {
1617 long newPos = para->GetRange().GetStart() - 1;
1618 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1619 if (!extendSel)
1620 SelectNone();
1621
1622 SetCaretPosition(newPos);
1623 PositionCaret();
1624 SetDefaultStyleToCursorStyle();
1625
1626 return true;
1627 }
1628
1629 return false;
1630 }
1631
1632 /// Move to the end of the line
1633 bool wxRichTextCtrl::MoveToLineEnd(int flags)
1634 {
1635 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1636
1637 if (line)
1638 {
1639 wxRichTextRange lineRange = line->GetAbsoluteRange();
1640 long newPos = lineRange.GetEnd();
1641 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1642 if (!extendSel)
1643 SelectNone();
1644
1645 SetCaretPosition(newPos);
1646 PositionCaret();
1647 SetDefaultStyleToCursorStyle();
1648
1649 return true;
1650 }
1651
1652 return false;
1653 }
1654
1655 /// Move to the start of the line
1656 bool wxRichTextCtrl::MoveToLineStart(int flags)
1657 {
1658 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1659 if (line)
1660 {
1661 wxRichTextRange lineRange = line->GetAbsoluteRange();
1662 long newPos = lineRange.GetStart()-1;
1663
1664 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1665 if (!extendSel)
1666 SelectNone();
1667
1668 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(line);
1669
1670 SetCaretPosition(newPos, para->GetRange().GetStart() != lineRange.GetStart());
1671 PositionCaret();
1672 SetDefaultStyleToCursorStyle();
1673
1674 return true;
1675 }
1676
1677 return false;
1678 }
1679
1680 /// Move to the start of the buffer
1681 bool wxRichTextCtrl::MoveHome(int flags)
1682 {
1683 if (m_caretPosition != -1)
1684 {
1685 bool extendSel = ExtendSelection(m_caretPosition, -1, flags);
1686 if (!extendSel)
1687 SelectNone();
1688
1689 SetCaretPosition(-1);
1690 PositionCaret();
1691 SetDefaultStyleToCursorStyle();
1692
1693 return true;
1694 }
1695 else
1696 return false;
1697 }
1698
1699 /// Move to the end of the buffer
1700 bool wxRichTextCtrl::MoveEnd(int flags)
1701 {
1702 long endPos = GetBuffer().GetRange().GetEnd()-1;
1703
1704 if (m_caretPosition != endPos)
1705 {
1706 bool extendSel = ExtendSelection(m_caretPosition, endPos, flags);
1707 if (!extendSel)
1708 SelectNone();
1709
1710 SetCaretPosition(endPos);
1711 PositionCaret();
1712 SetDefaultStyleToCursorStyle();
1713
1714 return true;
1715 }
1716 else
1717 return false;
1718 }
1719
1720 /// Move noPages pages up
1721 bool wxRichTextCtrl::PageUp(int noPages, int flags)
1722 {
1723 return PageDown(- noPages, flags);
1724 }
1725
1726 /// Move noPages pages down
1727 bool wxRichTextCtrl::PageDown(int noPages, int flags)
1728 {
1729 // Calculate which line occurs noPages * screen height further down.
1730 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1731 if (line)
1732 {
1733 wxSize clientSize = GetClientSize();
1734 int newY = line->GetAbsolutePosition().y + noPages*clientSize.y;
1735
1736 wxRichTextLine* newLine = GetBuffer().GetLineAtYPosition(newY);
1737 if (newLine)
1738 {
1739 wxRichTextRange lineRange = newLine->GetAbsoluteRange();
1740 long pos = lineRange.GetStart()-1;
1741 if (pos != m_caretPosition)
1742 {
1743 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(newLine);
1744
1745 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1746 if (!extendSel)
1747 SelectNone();
1748
1749 SetCaretPosition(pos, para->GetRange().GetStart() != lineRange.GetStart());
1750 PositionCaret();
1751 SetDefaultStyleToCursorStyle();
1752
1753 return true;
1754 }
1755 }
1756 }
1757
1758 return false;
1759 }
1760
1761 static bool wxRichTextCtrlIsWhitespace(const wxString& str)
1762 {
1763 return str == wxT(" ") || str == wxT("\t");
1764 }
1765
1766 // Finds the caret position for the next word
1767 long wxRichTextCtrl::FindNextWordPosition(int direction) const
1768 {
1769 long endPos = GetBuffer().GetRange().GetEnd();
1770
1771 if (direction > 0)
1772 {
1773 long i = m_caretPosition+1+direction; // +1 for conversion to character pos
1774
1775 // First skip current text to space
1776 while (i < endPos && i > -1)
1777 {
1778 // i is in character, not caret positions
1779 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1780 wxRichTextLine* line = GetBuffer().GetLineAtPosition(i, false);
1781 if (line && (i == line->GetAbsoluteRange().GetEnd()))
1782 {
1783 break;
1784 }
1785 else if (!wxRichTextCtrlIsWhitespace(text) && !text.empty())
1786 i += direction;
1787 else
1788 {
1789 break;
1790 }
1791 }
1792 while (i < endPos && i > -1)
1793 {
1794 // i is in character, not caret positions
1795 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1796 wxRichTextLine* line = GetBuffer().GetLineAtPosition(i, false);
1797 if (line && (i == line->GetAbsoluteRange().GetEnd()))
1798 return wxMax(-1, i);
1799
1800 if (text.empty()) // End of paragraph, or maybe an image
1801 return wxMax(-1, i - 1);
1802 else if (wxRichTextCtrlIsWhitespace(text) || text.empty())
1803 i += direction;
1804 else
1805 {
1806 // Convert to caret position
1807 return wxMax(-1, i - 1);
1808 }
1809 }
1810 if (i >= endPos)
1811 return endPos-1;
1812 return i-1;
1813 }
1814 else
1815 {
1816 long i = m_caretPosition;
1817
1818 // First skip white space
1819 while (i < endPos && i > -1)
1820 {
1821 // i is in character, not caret positions
1822 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1823 wxRichTextLine* line = GetBuffer().GetLineAtPosition(i, false);
1824
1825 if (text.empty() || (line && (i == line->GetAbsoluteRange().GetStart()))) // End of paragraph, or maybe an image
1826 break;
1827 else if (wxRichTextCtrlIsWhitespace(text) || text.empty())
1828 i += direction;
1829 else
1830 break;
1831 }
1832 // Next skip current text to space
1833 while (i < endPos && i > -1)
1834 {
1835 // i is in character, not caret positions
1836 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1837 wxRichTextLine* line = GetBuffer().GetLineAtPosition(i, false);
1838 if (line && line->GetAbsoluteRange().GetStart() == i)
1839 return i-1;
1840
1841 if (!wxRichTextCtrlIsWhitespace(text) /* && !text.empty() */)
1842 i += direction;
1843 else
1844 {
1845 return i;
1846 }
1847 }
1848 if (i < -1)
1849 return -1;
1850 return i;
1851 }
1852 }
1853
1854 /// Move n words left
1855 bool wxRichTextCtrl::WordLeft(int WXUNUSED(n), int flags)
1856 {
1857 long pos = FindNextWordPosition(-1);
1858 if (pos != m_caretPosition)
1859 {
1860 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1861
1862 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1863 if (!extendSel)
1864 SelectNone();
1865
1866 SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1867 PositionCaret();
1868 SetDefaultStyleToCursorStyle();
1869
1870 return true;
1871 }
1872
1873 return false;
1874 }
1875
1876 /// Move n words right
1877 bool wxRichTextCtrl::WordRight(int WXUNUSED(n), int flags)
1878 {
1879 long pos = FindNextWordPosition(1);
1880 if (pos != m_caretPosition)
1881 {
1882 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1883
1884 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1885 if (!extendSel)
1886 SelectNone();
1887
1888 SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1889 PositionCaret();
1890 SetDefaultStyleToCursorStyle();
1891
1892 return true;
1893 }
1894
1895 return false;
1896 }
1897
1898 /// Sizing
1899 void wxRichTextCtrl::OnSize(wxSizeEvent& event)
1900 {
1901 // Only do sizing optimization for large buffers
1902 if (GetBuffer().GetRange().GetEnd() > m_delayedLayoutThreshold)
1903 {
1904 m_fullLayoutRequired = true;
1905 m_fullLayoutTime = wxGetLocalTimeMillis();
1906 m_fullLayoutSavedPosition = GetFirstVisiblePosition();
1907 LayoutContent(true /* onlyVisibleRect */);
1908 }
1909 else
1910 GetBuffer().Invalidate(wxRICHTEXT_ALL);
1911
1912 #if wxRICHTEXT_BUFFERED_PAINTING
1913 RecreateBuffer();
1914 #endif
1915
1916 event.Skip();
1917 }
1918
1919
1920 /// Idle-time processing
1921 void wxRichTextCtrl::OnIdle(wxIdleEvent& event)
1922 {
1923 #if wxRICHTEXT_USE_OWN_CARET
1924 if (((wxRichTextCaret*) GetCaret())->GetNeedsUpdate())
1925 {
1926 ((wxRichTextCaret*) GetCaret())->SetNeedsUpdate(false);
1927 PositionCaret();
1928 GetCaret()->Show();
1929 }
1930 #endif
1931
1932 const int layoutInterval = wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL;
1933
1934 if (m_fullLayoutRequired && (wxGetLocalTimeMillis() > (m_fullLayoutTime + layoutInterval)))
1935 {
1936 m_fullLayoutRequired = false;
1937 m_fullLayoutTime = 0;
1938 GetBuffer().Invalidate(wxRICHTEXT_ALL);
1939 ShowPosition(m_fullLayoutSavedPosition);
1940 Refresh(false);
1941 }
1942
1943 if (m_caretPositionForDefaultStyle != -2)
1944 {
1945 // If the caret position has changed, no longer reflect the default style
1946 // in the UI.
1947 if (GetCaretPosition() != m_caretPositionForDefaultStyle)
1948 m_caretPositionForDefaultStyle = -2;
1949 }
1950
1951 event.Skip();
1952 }
1953
1954 /// Scrolling
1955 void wxRichTextCtrl::OnScroll(wxScrollWinEvent& event)
1956 {
1957 #if wxRICHTEXT_USE_OWN_CARET
1958 if (!((wxRichTextCaret*) GetCaret())->GetNeedsUpdate())
1959 {
1960 GetCaret()->Hide();
1961 ((wxRichTextCaret*) GetCaret())->SetNeedsUpdate();
1962 }
1963 #endif
1964
1965 event.Skip();
1966 }
1967
1968 /// Set up scrollbars, e.g. after a resize
1969 void wxRichTextCtrl::SetupScrollbars(bool atTop)
1970 {
1971 if (IsFrozen())
1972 return;
1973
1974 if (GetBuffer().IsEmpty())
1975 {
1976 SetScrollbars(0, 0, 0, 0, 0, 0);
1977 return;
1978 }
1979
1980 // TODO: reimplement scrolling so we scroll by line, not by fixed number
1981 // of pixels. See e.g. wxVScrolledWindow for ideas.
1982 int pixelsPerUnit = 5;
1983 wxSize clientSize = GetClientSize();
1984
1985 int maxHeight = GetBuffer().GetCachedSize().y;
1986
1987 // Round up so we have at least maxHeight pixels
1988 int unitsY = (int) (((float)maxHeight/(float)pixelsPerUnit) + 0.5);
1989
1990 int startX = 0, startY = 0;
1991 if (!atTop)
1992 GetViewStart(& startX, & startY);
1993
1994 int maxPositionX = 0;
1995 int maxPositionY = (int) ((((float)(wxMax((unitsY*pixelsPerUnit) - clientSize.y, 0)))/((float)pixelsPerUnit)) + 0.5);
1996
1997 int newStartX = wxMin(maxPositionX, startX);
1998 int newStartY = wxMin(maxPositionY, startY);
1999
2000 int oldPPUX, oldPPUY;
2001 int oldStartX, oldStartY;
2002 int oldVirtualSizeX = 0, oldVirtualSizeY = 0;
2003 GetScrollPixelsPerUnit(& oldPPUX, & oldPPUY);
2004 GetViewStart(& oldStartX, & oldStartY);
2005 GetVirtualSize(& oldVirtualSizeX, & oldVirtualSizeY);
2006 if (oldPPUY > 0)
2007 oldVirtualSizeY /= oldPPUY;
2008
2009 if (oldPPUX == 0 && oldPPUY == pixelsPerUnit && oldVirtualSizeY == unitsY && oldStartX == newStartX && oldStartY == newStartY)
2010 return;
2011
2012 // Don't set scrollbars if there were none before, and there will be none now.
2013 if (oldPPUY != 0 && (oldVirtualSizeY < clientSize.y) && (unitsY*pixelsPerUnit < clientSize.y))
2014 return;
2015
2016 // Move to previous scroll position if
2017 // possible
2018 SetScrollbars(0, pixelsPerUnit, 0, unitsY, newStartX, newStartY);
2019 }
2020
2021 /// Paint the background
2022 void wxRichTextCtrl::PaintBackground(wxDC& dc)
2023 {
2024 wxColour backgroundColour = GetBackgroundColour();
2025 if (!backgroundColour.Ok())
2026 backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
2027
2028 // Clear the background
2029 dc.SetBrush(wxBrush(backgroundColour));
2030 dc.SetPen(*wxTRANSPARENT_PEN);
2031 wxRect windowRect(GetClientSize());
2032 windowRect.x -= 2; windowRect.y -= 2;
2033 windowRect.width += 4; windowRect.height += 4;
2034
2035 // We need to shift the rectangle to take into account
2036 // scrolling. Converting device to logical coordinates.
2037 CalcUnscrolledPosition(windowRect.x, windowRect.y, & windowRect.x, & windowRect.y);
2038 dc.DrawRectangle(windowRect);
2039 }
2040
2041 #if wxRICHTEXT_BUFFERED_PAINTING
2042 /// Recreate buffer bitmap if necessary
2043 bool wxRichTextCtrl::RecreateBuffer(const wxSize& size)
2044 {
2045 wxSize sz = size;
2046 if (sz == wxDefaultSize)
2047 sz = GetClientSize();
2048
2049 if (sz.x < 1 || sz.y < 1)
2050 return false;
2051
2052 if (!m_bufferBitmap.Ok() || m_bufferBitmap.GetWidth() < sz.x || m_bufferBitmap.GetHeight() < sz.y)
2053 m_bufferBitmap = wxBitmap(sz.x, sz.y);
2054 return m_bufferBitmap.Ok();
2055 }
2056 #endif
2057
2058 // ----------------------------------------------------------------------------
2059 // file IO functions
2060 // ----------------------------------------------------------------------------
2061
2062 bool wxRichTextCtrl::DoLoadFile(const wxString& filename, int fileType)
2063 {
2064 bool success = GetBuffer().LoadFile(filename, (wxRichTextFileType)fileType);
2065 if (success)
2066 m_filename = filename;
2067
2068 DiscardEdits();
2069 SetInsertionPoint(0);
2070 LayoutContent();
2071 PositionCaret();
2072 SetupScrollbars(true);
2073 Refresh(false);
2074 wxTextCtrl::SendTextUpdatedEvent(this);
2075
2076 if (success)
2077 return true;
2078 else
2079 {
2080 wxLogError(_("File couldn't be loaded."));
2081
2082 return false;
2083 }
2084 }
2085
2086 bool wxRichTextCtrl::DoSaveFile(const wxString& filename, int fileType)
2087 {
2088 if (GetBuffer().SaveFile(filename, (wxRichTextFileType)fileType))
2089 {
2090 m_filename = filename;
2091
2092 DiscardEdits();
2093
2094 return true;
2095 }
2096
2097 wxLogError(_("The text couldn't be saved."));
2098
2099 return false;
2100 }
2101
2102 // ----------------------------------------------------------------------------
2103 // wxRichTextCtrl specific functionality
2104 // ----------------------------------------------------------------------------
2105
2106 /// Add a new paragraph of text to the end of the buffer
2107 wxRichTextRange wxRichTextCtrl::AddParagraph(const wxString& text)
2108 {
2109 wxRichTextRange range = GetBuffer().AddParagraph(text);
2110 LayoutContent();
2111 return range;
2112 }
2113
2114 /// Add an image
2115 wxRichTextRange wxRichTextCtrl::AddImage(const wxImage& image)
2116 {
2117 wxRichTextRange range = GetBuffer().AddImage(image);
2118 LayoutContent();
2119 return range;
2120 }
2121
2122 // ----------------------------------------------------------------------------
2123 // selection and ranges
2124 // ----------------------------------------------------------------------------
2125
2126 void wxRichTextCtrl::SelectAll()
2127 {
2128 SetSelection(0, GetLastPosition()+1);
2129 m_selectionAnchor = -1;
2130 }
2131
2132 /// Select none
2133 void wxRichTextCtrl::SelectNone()
2134 {
2135 if (!(GetSelectionRange() == wxRichTextRange(-2, -2)))
2136 {
2137 wxRichTextRange oldSelection = m_selectionRange;
2138
2139 m_selectionRange = wxRichTextRange(-2, -2);
2140
2141 RefreshForSelectionChange(oldSelection, m_selectionRange);
2142 }
2143 m_selectionAnchor = -2;
2144 }
2145
2146 static bool wxIsWordDelimiter(const wxString& text)
2147 {
2148 return !text.IsEmpty() && !wxIsalnum(text[0]);
2149 }
2150
2151 /// Select the word at the given character position
2152 bool wxRichTextCtrl::SelectWord(long position)
2153 {
2154 if (position < 0 || position > GetBuffer().GetRange().GetEnd())
2155 return false;
2156
2157 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
2158 if (!para)
2159 return false;
2160
2161 if (position == para->GetRange().GetEnd())
2162 position --;
2163
2164 long positionStart = position;
2165 long positionEnd = position;
2166
2167 for (positionStart = position; positionStart >= para->GetRange().GetStart(); positionStart --)
2168 {
2169 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(positionStart, positionStart));
2170 if (wxIsWordDelimiter(text))
2171 {
2172 positionStart ++;
2173 break;
2174 }
2175 }
2176 if (positionStart < para->GetRange().GetStart())
2177 positionStart = para->GetRange().GetStart();
2178
2179 for (positionEnd = position; positionEnd < para->GetRange().GetEnd(); positionEnd ++)
2180 {
2181 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(positionEnd, positionEnd));
2182 if (wxIsWordDelimiter(text))
2183 {
2184 positionEnd --;
2185 break;
2186 }
2187 }
2188 if (positionEnd >= para->GetRange().GetEnd())
2189 positionEnd = para->GetRange().GetEnd();
2190
2191 if (positionEnd < positionStart)
2192 return false;
2193
2194 SetSelection(positionStart, positionEnd+1);
2195
2196 if (positionStart >= 0)
2197 {
2198 MoveCaret(positionStart-1, true);
2199 SetDefaultStyleToCursorStyle();
2200 }
2201
2202 return true;
2203 }
2204
2205 wxString wxRichTextCtrl::GetStringSelection() const
2206 {
2207 long from, to;
2208 GetSelection(&from, &to);
2209
2210 return GetRange(from, to);
2211 }
2212
2213 // ----------------------------------------------------------------------------
2214 // hit testing
2215 // ----------------------------------------------------------------------------
2216
2217 wxTextCtrlHitTestResult
2218 wxRichTextCtrl::HitTest(const wxPoint& pt, wxTextCoord *x, wxTextCoord *y) const
2219 {
2220 // implement in terms of the other overload as the native ports typically
2221 // can get the position and not (x, y) pair directly (although wxUniv
2222 // directly gets x and y -- and so overrides this method as well)
2223 long pos;
2224 wxTextCtrlHitTestResult rc = HitTest(pt, &pos);
2225
2226 if ( rc != wxTE_HT_UNKNOWN )
2227 {
2228 PositionToXY(pos, x, y);
2229 }
2230
2231 return rc;
2232 }
2233
2234 wxTextCtrlHitTestResult
2235 wxRichTextCtrl::HitTest(const wxPoint& pt,
2236 long * pos) const
2237 {
2238 wxClientDC dc((wxRichTextCtrl*) this);
2239 ((wxRichTextCtrl*)this)->PrepareDC(dc);
2240
2241 // Buffer uses logical position (relative to start of buffer)
2242 // so convert
2243 wxPoint pt2 = GetLogicalPoint(pt);
2244
2245 int hit = ((wxRichTextCtrl*)this)->GetBuffer().HitTest(dc, pt2, *pos);
2246
2247 if ((hit & wxRICHTEXT_HITTEST_BEFORE) && (hit & wxRICHTEXT_HITTEST_OUTSIDE))
2248 return wxTE_HT_BEFORE;
2249 else if ((hit & wxRICHTEXT_HITTEST_AFTER) && (hit & wxRICHTEXT_HITTEST_OUTSIDE))
2250 return wxTE_HT_BEYOND;
2251 else if (hit & (wxRICHTEXT_HITTEST_BEFORE|wxRICHTEXT_HITTEST_AFTER))
2252 return wxTE_HT_ON_TEXT;
2253
2254 return wxTE_HT_UNKNOWN;
2255 }
2256
2257 // ----------------------------------------------------------------------------
2258 // set/get the controls text
2259 // ----------------------------------------------------------------------------
2260
2261 wxString wxRichTextCtrl::GetValue() const
2262 {
2263 return GetBuffer().GetText();
2264 }
2265
2266 wxString wxRichTextCtrl::GetRange(long from, long to) const
2267 {
2268 // Public API for range is different from internals
2269 return GetBuffer().GetTextForRange(wxRichTextRange(from, to-1));
2270 }
2271
2272 void wxRichTextCtrl::DoSetValue(const wxString& value, int flags)
2273 {
2274 // Don't call Clear here, since it always sends a text updated event
2275 m_buffer.ResetAndClearCommands();
2276 m_buffer.SetDirty(true);
2277 m_caretPosition = -1;
2278 m_caretPositionForDefaultStyle = -2;
2279 m_caretAtLineStart = false;
2280 m_selectionRange.SetRange(-2, -2);
2281
2282 Scroll(0,0);
2283
2284 if (!IsFrozen())
2285 {
2286 LayoutContent();
2287 Refresh(false);
2288 }
2289
2290 if (!value.IsEmpty())
2291 {
2292 // Remove empty paragraph
2293 GetBuffer().Clear();
2294 DoWriteText(value, flags);
2295
2296 // for compatibility, don't move the cursor when doing SetValue()
2297 SetInsertionPoint(0);
2298 }
2299 else
2300 {
2301 // still send an event for consistency
2302 if (flags & SetValue_SendEvent)
2303 wxTextCtrl::SendTextUpdatedEvent(this);
2304 }
2305 DiscardEdits();
2306 }
2307
2308 void wxRichTextCtrl::WriteText(const wxString& value)
2309 {
2310 DoWriteText(value);
2311 }
2312
2313 void wxRichTextCtrl::DoWriteText(const wxString& value, int flags)
2314 {
2315 wxString valueUnix = wxTextFile::Translate(value, wxTextFileType_Unix);
2316
2317 GetBuffer().InsertTextWithUndo(m_caretPosition+1, valueUnix, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
2318
2319 if ( flags & SetValue_SendEvent )
2320 wxTextCtrl::SendTextUpdatedEvent(this);
2321 }
2322
2323 void wxRichTextCtrl::AppendText(const wxString& text)
2324 {
2325 SetInsertionPointEnd();
2326
2327 WriteText(text);
2328 }
2329
2330 /// Write an image at the current insertion point
2331 bool wxRichTextCtrl::WriteImage(const wxImage& image, wxBitmapType bitmapType)
2332 {
2333 wxRichTextImageBlock imageBlock;
2334
2335 wxImage image2 = image;
2336 if (imageBlock.MakeImageBlock(image2, bitmapType))
2337 return WriteImage(imageBlock);
2338
2339 return false;
2340 }
2341
2342 bool wxRichTextCtrl::WriteImage(const wxString& filename, wxBitmapType bitmapType)
2343 {
2344 wxRichTextImageBlock imageBlock;
2345
2346 wxImage image;
2347 if (imageBlock.MakeImageBlock(filename, bitmapType, image, false))
2348 return WriteImage(imageBlock);
2349
2350 return false;
2351 }
2352
2353 bool wxRichTextCtrl::WriteImage(const wxRichTextImageBlock& imageBlock)
2354 {
2355 return GetBuffer().InsertImageWithUndo(m_caretPosition+1, imageBlock, this);
2356 }
2357
2358 bool wxRichTextCtrl::WriteImage(const wxBitmap& bitmap, wxBitmapType bitmapType)
2359 {
2360 if (bitmap.Ok())
2361 {
2362 wxRichTextImageBlock imageBlock;
2363
2364 wxImage image = bitmap.ConvertToImage();
2365 if (image.Ok() && imageBlock.MakeImageBlock(image, bitmapType))
2366 return WriteImage(imageBlock);
2367 }
2368
2369 return false;
2370 }
2371
2372 /// Insert a newline (actually paragraph) at the current insertion point.
2373 bool wxRichTextCtrl::Newline()
2374 {
2375 return GetBuffer().InsertNewlineWithUndo(m_caretPosition+1, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
2376 }
2377
2378 /// Insert a line break at the current insertion point.
2379 bool wxRichTextCtrl::LineBreak()
2380 {
2381 wxString text;
2382 text = wxRichTextLineBreakChar;
2383 return GetBuffer().InsertTextWithUndo(m_caretPosition+1, text, this);
2384 }
2385
2386 // ----------------------------------------------------------------------------
2387 // Clipboard operations
2388 // ----------------------------------------------------------------------------
2389
2390 void wxRichTextCtrl::Copy()
2391 {
2392 if (CanCopy())
2393 {
2394 wxRichTextRange range = GetInternalSelectionRange();
2395 GetBuffer().CopyToClipboard(range);
2396 }
2397 }
2398
2399 void wxRichTextCtrl::Cut()
2400 {
2401 if (CanCut())
2402 {
2403 wxRichTextRange range = GetInternalSelectionRange();
2404 GetBuffer().CopyToClipboard(range);
2405
2406 DeleteSelectedContent();
2407 LayoutContent();
2408 Refresh(false);
2409 }
2410 }
2411
2412 void wxRichTextCtrl::Paste()
2413 {
2414 if (CanPaste())
2415 {
2416 BeginBatchUndo(_("Paste"));
2417
2418 long newPos = m_caretPosition;
2419 DeleteSelectedContent(& newPos);
2420
2421 GetBuffer().PasteFromClipboard(newPos);
2422
2423 EndBatchUndo();
2424 }
2425 }
2426
2427 void wxRichTextCtrl::DeleteSelection()
2428 {
2429 if (CanDeleteSelection())
2430 {
2431 DeleteSelectedContent();
2432 }
2433 }
2434
2435 bool wxRichTextCtrl::HasSelection() const
2436 {
2437 return m_selectionRange.GetStart() != -2 && m_selectionRange.GetEnd() != -2;
2438 }
2439
2440 bool wxRichTextCtrl::CanCopy() const
2441 {
2442 // Can copy if there's a selection
2443 return HasSelection();
2444 }
2445
2446 bool wxRichTextCtrl::CanCut() const
2447 {
2448 return HasSelection() && IsEditable();
2449 }
2450
2451 bool wxRichTextCtrl::CanPaste() const
2452 {
2453 if ( !IsEditable() )
2454 return false;
2455
2456 return GetBuffer().CanPasteFromClipboard();
2457 }
2458
2459 bool wxRichTextCtrl::CanDeleteSelection() const
2460 {
2461 return HasSelection() && IsEditable();
2462 }
2463
2464
2465 // ----------------------------------------------------------------------------
2466 // Accessors
2467 // ----------------------------------------------------------------------------
2468
2469 void wxRichTextCtrl::SetEditable(bool editable)
2470 {
2471 m_editable = editable;
2472 }
2473
2474 void wxRichTextCtrl::SetInsertionPoint(long pos)
2475 {
2476 SelectNone();
2477
2478 m_caretPosition = pos - 1;
2479
2480 PositionCaret();
2481 }
2482
2483 void wxRichTextCtrl::SetInsertionPointEnd()
2484 {
2485 long pos = GetLastPosition();
2486 SetInsertionPoint(pos);
2487 }
2488
2489 long wxRichTextCtrl::GetInsertionPoint() const
2490 {
2491 return m_caretPosition+1;
2492 }
2493
2494 wxTextPos wxRichTextCtrl::GetLastPosition() const
2495 {
2496 return GetBuffer().GetRange().GetEnd();
2497 }
2498
2499 // If the return values from and to are the same, there is no
2500 // selection.
2501 void wxRichTextCtrl::GetSelection(long* from, long* to) const
2502 {
2503 *from = m_selectionRange.GetStart();
2504 *to = m_selectionRange.GetEnd();
2505 if ((*to) != -1 && (*to) != -2)
2506 (*to) ++;
2507 }
2508
2509 bool wxRichTextCtrl::IsEditable() const
2510 {
2511 return m_editable;
2512 }
2513
2514 // ----------------------------------------------------------------------------
2515 // selection
2516 // ----------------------------------------------------------------------------
2517
2518 void wxRichTextCtrl::SetSelection(long from, long to)
2519 {
2520 // if from and to are both -1, it means (in wxWidgets) that all text should
2521 // be selected.
2522 if ( (from == -1) && (to == -1) )
2523 {
2524 from = 0;
2525 to = GetLastPosition()+1;
2526 }
2527
2528 DoSetSelection(from, to);
2529 }
2530
2531 void wxRichTextCtrl::DoSetSelection(long from, long to, bool WXUNUSED(scrollCaret))
2532 {
2533 if (from == to)
2534 {
2535 SelectNone();
2536 }
2537 else
2538 {
2539 wxRichTextRange oldSelection = m_selectionRange;
2540 m_selectionAnchor = from;
2541 m_selectionRange.SetRange(from, to-1);
2542 if (from > -2)
2543 m_caretPosition = from-1;
2544
2545 RefreshForSelectionChange(oldSelection, m_selectionRange);
2546 PositionCaret();
2547 }
2548 }
2549
2550 // ----------------------------------------------------------------------------
2551 // Editing
2552 // ----------------------------------------------------------------------------
2553
2554 void wxRichTextCtrl::Replace(long WXUNUSED(from), long WXUNUSED(to),
2555 const wxString& value)
2556 {
2557 BeginBatchUndo(_("Replace"));
2558
2559 DeleteSelectedContent();
2560
2561 DoWriteText(value, SetValue_SelectionOnly);
2562
2563 EndBatchUndo();
2564 }
2565
2566 void wxRichTextCtrl::Remove(long from, long to)
2567 {
2568 SelectNone();
2569
2570 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(from, to-1), this);
2571
2572 LayoutContent();
2573 if (!IsFrozen())
2574 Refresh(false);
2575 }
2576
2577 bool wxRichTextCtrl::IsModified() const
2578 {
2579 return m_buffer.IsModified();
2580 }
2581
2582 void wxRichTextCtrl::MarkDirty()
2583 {
2584 m_buffer.Modify(true);
2585 }
2586
2587 void wxRichTextCtrl::DiscardEdits()
2588 {
2589 m_caretPositionForDefaultStyle = -2;
2590 m_buffer.Modify(false);
2591 m_buffer.GetCommandProcessor()->ClearCommands();
2592 }
2593
2594 int wxRichTextCtrl::GetNumberOfLines() const
2595 {
2596 return GetBuffer().GetParagraphCount();
2597 }
2598
2599 // ----------------------------------------------------------------------------
2600 // Positions <-> coords
2601 // ----------------------------------------------------------------------------
2602
2603 long wxRichTextCtrl::XYToPosition(long x, long y) const
2604 {
2605 return GetBuffer().XYToPosition(x, y);
2606 }
2607
2608 bool wxRichTextCtrl::PositionToXY(long pos, long *x, long *y) const
2609 {
2610 return GetBuffer().PositionToXY(pos, x, y);
2611 }
2612
2613 // ----------------------------------------------------------------------------
2614 //
2615 // ----------------------------------------------------------------------------
2616
2617 void wxRichTextCtrl::ShowPosition(long pos)
2618 {
2619 if (!IsPositionVisible(pos))
2620 ScrollIntoView(pos-1, WXK_DOWN);
2621 }
2622
2623 int wxRichTextCtrl::GetLineLength(long lineNo) const
2624 {
2625 return GetBuffer().GetParagraphLength(lineNo);
2626 }
2627
2628 wxString wxRichTextCtrl::GetLineText(long lineNo) const
2629 {
2630 return GetBuffer().GetParagraphText(lineNo);
2631 }
2632
2633 // ----------------------------------------------------------------------------
2634 // Undo/redo
2635 // ----------------------------------------------------------------------------
2636
2637 void wxRichTextCtrl::Undo()
2638 {
2639 if (CanUndo())
2640 {
2641 GetCommandProcessor()->Undo();
2642 }
2643 }
2644
2645 void wxRichTextCtrl::Redo()
2646 {
2647 if (CanRedo())
2648 {
2649 GetCommandProcessor()->Redo();
2650 }
2651 }
2652
2653 bool wxRichTextCtrl::CanUndo() const
2654 {
2655 return GetCommandProcessor()->CanUndo();
2656 }
2657
2658 bool wxRichTextCtrl::CanRedo() const
2659 {
2660 return GetCommandProcessor()->CanRedo();
2661 }
2662
2663 // ----------------------------------------------------------------------------
2664 // implementation details
2665 // ----------------------------------------------------------------------------
2666
2667 void wxRichTextCtrl::Command(wxCommandEvent& event)
2668 {
2669 SetValue(event.GetString());
2670 GetEventHandler()->ProcessEvent(event);
2671 }
2672
2673 void wxRichTextCtrl::OnDropFiles(wxDropFilesEvent& event)
2674 {
2675 // By default, load the first file into the text window.
2676 if (event.GetNumberOfFiles() > 0)
2677 {
2678 LoadFile(event.GetFiles()[0]);
2679 }
2680 }
2681
2682 wxSize wxRichTextCtrl::DoGetBestSize() const
2683 {
2684 return wxSize(10, 10);
2685 }
2686
2687 // ----------------------------------------------------------------------------
2688 // standard handlers for standard edit menu events
2689 // ----------------------------------------------------------------------------
2690
2691 void wxRichTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2692 {
2693 Cut();
2694 }
2695
2696 void wxRichTextCtrl::OnClear(wxCommandEvent& WXUNUSED(event))
2697 {
2698 DeleteSelection();
2699 }
2700
2701 void wxRichTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2702 {
2703 Copy();
2704 }
2705
2706 void wxRichTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2707 {
2708 Paste();
2709 }
2710
2711 void wxRichTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2712 {
2713 Undo();
2714 }
2715
2716 void wxRichTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2717 {
2718 Redo();
2719 }
2720
2721 void wxRichTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2722 {
2723 event.Enable( CanCut() );
2724 }
2725
2726 void wxRichTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2727 {
2728 event.Enable( CanCopy() );
2729 }
2730
2731 void wxRichTextCtrl::OnUpdateClear(wxUpdateUIEvent& event)
2732 {
2733 event.Enable( CanDeleteSelection() );
2734 }
2735
2736 void wxRichTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2737 {
2738 event.Enable( CanPaste() );
2739 }
2740
2741 void wxRichTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2742 {
2743 event.Enable( CanUndo() );
2744 event.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
2745 }
2746
2747 void wxRichTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2748 {
2749 event.Enable( CanRedo() );
2750 event.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
2751 }
2752
2753 void wxRichTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
2754 {
2755 SelectAll();
2756 }
2757
2758 void wxRichTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
2759 {
2760 event.Enable(GetLastPosition() > 0);
2761 }
2762
2763 void wxRichTextCtrl::OnContextMenu(wxContextMenuEvent& event)
2764 {
2765 if (event.GetEventObject() != this)
2766 {
2767 event.Skip();
2768 return;
2769 }
2770
2771 if (!m_contextMenu)
2772 {
2773 m_contextMenu = new wxMenu;
2774 m_contextMenu->Append(wxID_UNDO, _("&Undo"));
2775 m_contextMenu->Append(wxID_REDO, _("&Redo"));
2776 m_contextMenu->AppendSeparator();
2777 m_contextMenu->Append(wxID_CUT, _("Cu&t"));
2778 m_contextMenu->Append(wxID_COPY, _("&Copy"));
2779 m_contextMenu->Append(wxID_PASTE, _("&Paste"));
2780 m_contextMenu->Append(wxID_CLEAR, _("&Delete"));
2781 m_contextMenu->AppendSeparator();
2782 m_contextMenu->Append(wxID_SELECTALL, _("Select &All"));
2783 }
2784 PopupMenu(m_contextMenu);
2785 return;
2786 }
2787
2788 bool wxRichTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
2789 {
2790 return GetBuffer().SetStyle(wxRichTextRange(start, end-1), wxTextAttr(style));
2791 }
2792
2793 bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxTextAttr& style)
2794 {
2795 return GetBuffer().SetStyle(range.ToInternal(), style);
2796 }
2797
2798 // extended style setting operation with flags including:
2799 // wxRICHTEXT_SETSTYLE_WITH_UNDO, wxRICHTEXT_SETSTYLE_OPTIMIZE, wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY.
2800 // see richtextbuffer.h for more details.
2801
2802 bool wxRichTextCtrl::SetStyleEx(const wxRichTextRange& range, const wxTextAttr& style, int flags)
2803 {
2804 return GetBuffer().SetStyle(range.ToInternal(), style, flags);
2805 }
2806
2807 bool wxRichTextCtrl::SetDefaultStyle(const wxTextAttr& style)
2808 {
2809 return GetBuffer().SetDefaultStyle(wxTextAttr(style));
2810 }
2811
2812 const wxTextAttr& wxRichTextCtrl::GetDefaultStyle() const
2813 {
2814 return GetBuffer().GetDefaultStyle();
2815 }
2816
2817 bool wxRichTextCtrl::GetStyle(long position, wxTextAttr& style)
2818 {
2819 return GetBuffer().GetStyle(position, style);
2820 }
2821
2822 // get the common set of styles for the range
2823 bool wxRichTextCtrl::GetStyleForRange(const wxRichTextRange& range, wxTextAttr& style)
2824 {
2825 return GetBuffer().GetStyleForRange(range.ToInternal(), style);
2826 }
2827
2828 /// Get the content (uncombined) attributes for this position.
2829 bool wxRichTextCtrl::GetUncombinedStyle(long position, wxTextAttr& style)
2830 {
2831 return GetBuffer().GetUncombinedStyle(position, style);
2832 }
2833
2834 /// Set font, and also the buffer attributes
2835 bool wxRichTextCtrl::SetFont(const wxFont& font)
2836 {
2837 wxControl::SetFont(font);
2838
2839 wxTextAttr attr = GetBuffer().GetAttributes();
2840 attr.SetFont(font);
2841 GetBuffer().SetBasicStyle(attr);
2842
2843 GetBuffer().Invalidate(wxRICHTEXT_ALL);
2844 Refresh(false);
2845
2846 return true;
2847 }
2848
2849 /// Transform logical to physical
2850 wxPoint wxRichTextCtrl::GetPhysicalPoint(const wxPoint& ptLogical) const
2851 {
2852 wxPoint pt;
2853 CalcScrolledPosition(ptLogical.x, ptLogical.y, & pt.x, & pt.y);
2854
2855 return pt;
2856 }
2857
2858 /// Transform physical to logical
2859 wxPoint wxRichTextCtrl::GetLogicalPoint(const wxPoint& ptPhysical) const
2860 {
2861 wxPoint pt;
2862 CalcUnscrolledPosition(ptPhysical.x, ptPhysical.y, & pt.x, & pt.y);
2863
2864 return pt;
2865 }
2866
2867 /// Position the caret
2868 void wxRichTextCtrl::PositionCaret()
2869 {
2870 if (!GetCaret())
2871 return;
2872
2873 //wxLogDebug(wxT("PositionCaret"));
2874
2875 wxRect caretRect;
2876 if (GetCaretPositionForIndex(GetCaretPosition(), caretRect))
2877 {
2878 wxPoint newPt = caretRect.GetPosition();
2879 wxSize newSz = caretRect.GetSize();
2880 wxPoint pt = GetPhysicalPoint(newPt);
2881 if (GetCaret()->GetPosition() != pt || GetCaret()->GetSize() != newSz)
2882 {
2883 GetCaret()->Hide();
2884 if (GetCaret()->GetSize() != newSz)
2885 GetCaret()->SetSize(newSz);
2886 GetCaret()->Move(pt);
2887 GetCaret()->Show();
2888 }
2889 }
2890 }
2891
2892 /// Get the caret height and position for the given character position
2893 bool wxRichTextCtrl::GetCaretPositionForIndex(long position, wxRect& rect)
2894 {
2895 wxClientDC dc(this);
2896 dc.SetFont(GetFont());
2897
2898 PrepareDC(dc);
2899
2900 wxPoint pt;
2901 int height = 0;
2902
2903 if (GetBuffer().FindPosition(dc, position, pt, & height, m_caretAtLineStart))
2904 {
2905 // Caret height can't be zero
2906 if (height == 0)
2907 height = dc.GetCharHeight();
2908
2909 rect = wxRect(pt, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH, height));
2910 return true;
2911 }
2912
2913 return false;
2914 }
2915
2916 /// Gets the line for the visible caret position. If the caret is
2917 /// shown at the very end of the line, it means the next character is actually
2918 /// on the following line. So let's get the line we're expecting to find
2919 /// if this is the case.
2920 wxRichTextLine* wxRichTextCtrl::GetVisibleLineForCaretPosition(long caretPosition) const
2921 {
2922 wxRichTextLine* line = GetBuffer().GetLineAtPosition(caretPosition, true);
2923 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(caretPosition, true);
2924 if (line)
2925 {
2926 wxRichTextRange lineRange = line->GetAbsoluteRange();
2927 if (caretPosition == lineRange.GetStart()-1 &&
2928 (para->GetRange().GetStart() != lineRange.GetStart()))
2929 {
2930 if (!m_caretAtLineStart)
2931 line = GetBuffer().GetLineAtPosition(caretPosition-1, true);
2932 }
2933 }
2934 return line;
2935 }
2936
2937
2938 /// Move the caret to the given character position
2939 bool wxRichTextCtrl::MoveCaret(long pos, bool showAtLineStart)
2940 {
2941 if (GetBuffer().GetDirty())
2942 LayoutContent();
2943
2944 if (pos <= GetBuffer().GetRange().GetEnd())
2945 {
2946 SetCaretPosition(pos, showAtLineStart);
2947
2948 PositionCaret();
2949
2950 return true;
2951 }
2952 else
2953 return false;
2954 }
2955
2956 /// Layout the buffer: which we must do before certain operations, such as
2957 /// setting the caret position.
2958 bool wxRichTextCtrl::LayoutContent(bool onlyVisibleRect)
2959 {
2960 if (GetBuffer().GetDirty() || onlyVisibleRect)
2961 {
2962 wxRect availableSpace(GetClientSize());
2963 if (availableSpace.width == 0)
2964 availableSpace.width = 10;
2965 if (availableSpace.height == 0)
2966 availableSpace.height = 10;
2967
2968 int flags = wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT;
2969 if (onlyVisibleRect)
2970 {
2971 flags |= wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
2972 availableSpace.SetPosition(GetLogicalPoint(wxPoint(0, 0)));
2973 }
2974
2975 wxClientDC dc(this);
2976 dc.SetFont(GetFont());
2977
2978 PrepareDC(dc);
2979
2980 GetBuffer().Defragment();
2981 GetBuffer().UpdateRanges(); // If items were deleted, ranges need recalculation
2982 GetBuffer().Layout(dc, availableSpace, flags);
2983 GetBuffer().SetDirty(false);
2984
2985 if (!IsFrozen())
2986 SetupScrollbars();
2987 }
2988
2989 return true;
2990 }
2991
2992 /// Is all of the selection bold?
2993 bool wxRichTextCtrl::IsSelectionBold()
2994 {
2995 if (HasSelection())
2996 {
2997 wxTextAttr attr;
2998 wxRichTextRange range = GetSelectionRange();
2999 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
3000 attr.SetFontWeight(wxFONTWEIGHT_BOLD);
3001
3002 return HasCharacterAttributes(range, attr);
3003 }
3004 else
3005 {
3006 // If no selection, then we need to combine current style with default style
3007 // to see what the effect would be if we started typing.
3008 wxTextAttr attr;
3009 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
3010
3011 long pos = GetAdjustedCaretPosition(GetCaretPosition());
3012 if (GetStyle(pos, attr))
3013 {
3014 if (IsDefaultStyleShowing())
3015 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3016 return attr.GetFontWeight() == wxFONTWEIGHT_BOLD;
3017 }
3018 }
3019 return false;
3020 }
3021
3022 /// Is all of the selection italics?
3023 bool wxRichTextCtrl::IsSelectionItalics()
3024 {
3025 if (HasSelection())
3026 {
3027 wxRichTextRange range = GetSelectionRange();
3028 wxTextAttr attr;
3029 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
3030 attr.SetFontStyle(wxFONTSTYLE_ITALIC);
3031
3032 return HasCharacterAttributes(range, attr);
3033 }
3034 else
3035 {
3036 // If no selection, then we need to combine current style with default style
3037 // to see what the effect would be if we started typing.
3038 wxTextAttr attr;
3039 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
3040
3041 long pos = GetAdjustedCaretPosition(GetCaretPosition());
3042 if (GetStyle(pos, attr))
3043 {
3044 if (IsDefaultStyleShowing())
3045 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3046 return attr.GetFontStyle() == wxFONTSTYLE_ITALIC;
3047 }
3048 }
3049 return false;
3050 }
3051
3052 /// Is all of the selection underlined?
3053 bool wxRichTextCtrl::IsSelectionUnderlined()
3054 {
3055 if (HasSelection())
3056 {
3057 wxRichTextRange range = GetSelectionRange();
3058 wxTextAttr attr;
3059 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
3060 attr.SetFontUnderlined(true);
3061
3062 return HasCharacterAttributes(range, attr);
3063 }
3064 else
3065 {
3066 // If no selection, then we need to combine current style with default style
3067 // to see what the effect would be if we started typing.
3068 wxTextAttr attr;
3069 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
3070 long pos = GetAdjustedCaretPosition(GetCaretPosition());
3071
3072 if (GetStyle(pos, attr))
3073 {
3074 if (IsDefaultStyleShowing())
3075 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3076 return attr.GetFontUnderlined();
3077 }
3078 }
3079 return false;
3080 }
3081
3082 /// Apply bold to the selection
3083 bool wxRichTextCtrl::ApplyBoldToSelection()
3084 {
3085 wxTextAttr attr;
3086 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
3087 attr.SetFontWeight(IsSelectionBold() ? wxFONTWEIGHT_NORMAL : wxFONTWEIGHT_BOLD);
3088
3089 if (HasSelection())
3090 return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
3091 else
3092 {
3093 wxRichTextAttr current = GetDefaultStyleEx();
3094 current.Apply(attr);
3095 SetAndShowDefaultStyle(current);
3096 }
3097 return true;
3098 }
3099
3100 /// Apply italic to the selection
3101 bool wxRichTextCtrl::ApplyItalicToSelection()
3102 {
3103 wxTextAttr attr;
3104 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
3105 attr.SetFontStyle(IsSelectionItalics() ? wxFONTSTYLE_NORMAL : wxFONTSTYLE_ITALIC);
3106
3107 if (HasSelection())
3108 return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
3109 else
3110 {
3111 wxRichTextAttr current = GetDefaultStyleEx();
3112 current.Apply(attr);
3113 SetAndShowDefaultStyle(current);
3114 }
3115 return true;
3116 }
3117
3118 /// Apply underline to the selection
3119 bool wxRichTextCtrl::ApplyUnderlineToSelection()
3120 {
3121 wxTextAttr attr;
3122 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
3123 attr.SetFontUnderlined(!IsSelectionUnderlined());
3124
3125 if (HasSelection())
3126 return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
3127 else
3128 {
3129 wxRichTextAttr current = GetDefaultStyleEx();
3130 current.Apply(attr);
3131 SetAndShowDefaultStyle(current);
3132 }
3133 return true;
3134 }
3135
3136 /// Is all of the selection aligned according to the specified flag?
3137 bool wxRichTextCtrl::IsSelectionAligned(wxTextAttrAlignment alignment)
3138 {
3139 wxRichTextRange range;
3140 if (HasSelection())
3141 range = GetSelectionRange();
3142 else
3143 range = wxRichTextRange(GetCaretPosition()+1, GetCaretPosition()+2);
3144
3145 wxTextAttr attr;
3146 attr.SetAlignment(alignment);
3147
3148 return HasParagraphAttributes(range, attr);
3149 }
3150
3151 /// Apply alignment to the selection
3152 bool wxRichTextCtrl::ApplyAlignmentToSelection(wxTextAttrAlignment alignment)
3153 {
3154 wxTextAttr attr;
3155 attr.SetAlignment(alignment);
3156 if (HasSelection())
3157 return SetStyle(GetSelectionRange(), attr);
3158 else
3159 {
3160 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
3161 if (para)
3162 return SetStyleEx(para->GetRange().FromInternal(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY);
3163 }
3164 return true;
3165 }
3166
3167 /// Apply a named style to the selection
3168 bool wxRichTextCtrl::ApplyStyle(wxRichTextStyleDefinition* def)
3169 {
3170 // Flags are defined within each definition, so only certain
3171 // attributes are applied.
3172 wxTextAttr attr(GetStyleSheet() ? def->GetStyleMergedWithBase(GetStyleSheet()) : def->GetStyle());
3173
3174 int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_RESET;
3175
3176 if (def->IsKindOf(CLASSINFO(wxRichTextListStyleDefinition)))
3177 {
3178 flags |= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY;
3179
3180 wxRichTextRange range;
3181
3182 if (HasSelection())
3183 range = GetSelectionRange();
3184 else
3185 {
3186 long pos = GetAdjustedCaretPosition(GetCaretPosition());
3187 range = wxRichTextRange(pos, pos+1);
3188 }
3189
3190 return SetListStyle(range, (wxRichTextListStyleDefinition*) def, flags);
3191 }
3192
3193 // Make sure the attr has the style name
3194 if (def->IsKindOf(CLASSINFO(wxRichTextParagraphStyleDefinition)))
3195 {
3196 attr.SetParagraphStyleName(def->GetName());
3197
3198 // If applying a paragraph style, we only want the paragraph nodes to adopt these
3199 // attributes, and not the leaf nodes. This will allow the content (e.g. text)
3200 // to change its style independently.
3201 flags |= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY;
3202 }
3203 else
3204 attr.SetCharacterStyleName(def->GetName());
3205
3206 if (HasSelection())
3207 return SetStyleEx(GetSelectionRange(), attr, flags);
3208 else
3209 {
3210 wxRichTextAttr current = GetDefaultStyleEx();
3211 current.Apply(attr);
3212 SetAndShowDefaultStyle(current);
3213 return true;
3214 }
3215 }
3216
3217 /// Apply the style sheet to the buffer, for example if the styles have changed.
3218 bool wxRichTextCtrl::ApplyStyleSheet(wxRichTextStyleSheet* styleSheet)
3219 {
3220 if (!styleSheet)
3221 styleSheet = GetBuffer().GetStyleSheet();
3222 if (!styleSheet)
3223 return false;
3224
3225 if (GetBuffer().ApplyStyleSheet(styleSheet))
3226 {
3227 GetBuffer().Invalidate(wxRICHTEXT_ALL);
3228 Refresh(false);
3229 return true;
3230 }
3231 else
3232 return false;
3233 }
3234
3235 /// Sets the default style to the style under the cursor
3236 bool wxRichTextCtrl::SetDefaultStyleToCursorStyle()
3237 {
3238 wxTextAttr attr;
3239 attr.SetFlags(wxTEXT_ATTR_CHARACTER);
3240
3241 // If at the start of a paragraph, use the next position.
3242 long pos = GetAdjustedCaretPosition(GetCaretPosition());
3243
3244 if (GetUncombinedStyle(pos, attr))
3245 {
3246 SetDefaultStyle(attr);
3247 return true;
3248 }
3249
3250 return false;
3251 }
3252
3253 /// Returns the first visible position in the current view
3254 long wxRichTextCtrl::GetFirstVisiblePosition() const
3255 {
3256 wxRichTextLine* line = GetBuffer().GetLineAtYPosition(GetLogicalPoint(wxPoint(0, 0)).y);
3257 if (line)
3258 return line->GetAbsoluteRange().GetStart();
3259 else
3260 return 0;
3261 }
3262
3263 /// Get the first visible point in the window
3264 wxPoint wxRichTextCtrl::GetFirstVisiblePoint() const
3265 {
3266 int ppuX, ppuY;
3267 int startXUnits, startYUnits;
3268
3269 GetScrollPixelsPerUnit(& ppuX, & ppuY);
3270 GetViewStart(& startXUnits, & startYUnits);
3271
3272 return wxPoint(startXUnits * ppuX, startYUnits * ppuY);
3273 }
3274
3275 /// The adjusted caret position is the character position adjusted to take
3276 /// into account whether we're at the start of a paragraph, in which case
3277 /// style information should be taken from the next position, not current one.
3278 long wxRichTextCtrl::GetAdjustedCaretPosition(long caretPos) const
3279 {
3280 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(caretPos+1);
3281
3282 if (para && (caretPos+1 == para->GetRange().GetStart()))
3283 caretPos ++;
3284 return caretPos;
3285 }
3286
3287 /// Get/set the selection range in character positions. -1, -1 means no selection.
3288 /// The range is in API convention, i.e. a single character selection is denoted
3289 /// by (n, n+1)
3290 wxRichTextRange wxRichTextCtrl::GetSelectionRange() const
3291 {
3292 wxRichTextRange range = GetInternalSelectionRange();
3293 if (range != wxRichTextRange(-2,-2) && range != wxRichTextRange(-1,-1))
3294 range.SetEnd(range.GetEnd() + 1);
3295 return range;
3296 }
3297
3298 void wxRichTextCtrl::SetSelectionRange(const wxRichTextRange& range)
3299 {
3300 wxRichTextRange range1(range);
3301 if (range1 != wxRichTextRange(-2,-2) && range1 != wxRichTextRange(-1,-1) )
3302 range1.SetEnd(range1.GetEnd() - 1);
3303
3304 wxASSERT( range1.GetStart() > range1.GetEnd() );
3305
3306 SetInternalSelectionRange(range1);
3307 }
3308
3309 /// Set list style
3310 bool wxRichTextCtrl::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
3311 {
3312 return GetBuffer().SetListStyle(range.ToInternal(), def, flags, startFrom, specifiedLevel);
3313 }
3314
3315 bool wxRichTextCtrl::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
3316 {
3317 return GetBuffer().SetListStyle(range.ToInternal(), defName, flags, startFrom, specifiedLevel);
3318 }
3319
3320 /// Clear list for given range
3321 bool wxRichTextCtrl::ClearListStyle(const wxRichTextRange& range, int flags)
3322 {
3323 return GetBuffer().ClearListStyle(range.ToInternal(), flags);
3324 }
3325
3326 /// Number/renumber any list elements in the given range
3327 bool wxRichTextCtrl::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
3328 {
3329 return GetBuffer().NumberList(range.ToInternal(), def, flags, startFrom, specifiedLevel);
3330 }
3331
3332 bool wxRichTextCtrl::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
3333 {
3334 return GetBuffer().NumberList(range.ToInternal(), defName, flags, startFrom, specifiedLevel);
3335 }
3336
3337 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
3338 bool wxRichTextCtrl::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
3339 {
3340 return GetBuffer().PromoteList(promoteBy, range.ToInternal(), def, flags, specifiedLevel);
3341 }
3342
3343 bool wxRichTextCtrl::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
3344 {
3345 return GetBuffer().PromoteList(promoteBy, range.ToInternal(), defName, flags, specifiedLevel);
3346 }
3347
3348 /// Deletes the content in the given range
3349 bool wxRichTextCtrl::Delete(const wxRichTextRange& range)
3350 {
3351 return GetBuffer().DeleteRangeWithUndo(range.ToInternal(), this);
3352 }
3353
3354 const wxArrayString& wxRichTextCtrl::GetAvailableFontNames()
3355 {
3356 if (sm_availableFontNames.GetCount() == 0)
3357 {
3358 sm_availableFontNames = wxFontEnumerator::GetFacenames();
3359 sm_availableFontNames.Sort();
3360 }
3361 return sm_availableFontNames;
3362 }
3363
3364 void wxRichTextCtrl::ClearAvailableFontNames()
3365 {
3366 sm_availableFontNames.Clear();
3367 }
3368
3369 void wxRichTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
3370 {
3371 //wxLogDebug(wxT("wxRichTextCtrl::OnSysColourChanged"));
3372
3373 wxTextAttrEx basicStyle = GetBasicStyle();
3374 basicStyle.SetTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
3375 SetBasicStyle(basicStyle);
3376 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
3377
3378 Refresh();
3379 }
3380
3381 // Refresh the area affected by a selection change
3382 bool wxRichTextCtrl::RefreshForSelectionChange(const wxRichTextRange& oldSelection, const wxRichTextRange& newSelection)
3383 {
3384 // Calculate the refresh rectangle - just the affected lines
3385 long firstPos, lastPos;
3386 if (oldSelection.GetStart() == -2 && newSelection.GetStart() != -2)
3387 {
3388 firstPos = newSelection.GetStart();
3389 lastPos = newSelection.GetEnd();
3390 }
3391 else if (oldSelection.GetStart() != -2 && newSelection.GetStart() == -2)
3392 {
3393 firstPos = oldSelection.GetStart();
3394 lastPos = oldSelection.GetEnd();
3395 }
3396 else if (oldSelection.GetStart() == -2 && newSelection.GetStart() == -2)
3397 {
3398 return false;
3399 }
3400 else
3401 {
3402 firstPos = wxMin(oldSelection.GetStart(), newSelection.GetStart());
3403 lastPos = wxMax(oldSelection.GetEnd(), newSelection.GetEnd());
3404 }
3405
3406 wxRichTextLine* firstLine = GetBuffer().GetLineAtPosition(firstPos);
3407 wxRichTextLine* lastLine = GetBuffer().GetLineAtPosition(lastPos);
3408
3409 if (firstLine && lastLine)
3410 {
3411 wxSize clientSize = GetClientSize();
3412 wxPoint pt1 = GetPhysicalPoint(firstLine->GetAbsolutePosition());
3413 wxPoint pt2 = GetPhysicalPoint(lastLine->GetAbsolutePosition()) + wxPoint(0, lastLine->GetSize().y);
3414
3415 pt1.x = 0;
3416 pt1.y = wxMax(0, pt1.y);
3417 pt2.x = 0;
3418 pt2.y = wxMin(clientSize.y, pt2.y);
3419
3420 wxRect rect(pt1, wxSize(clientSize.x, pt2.y - pt1.y));
3421 RefreshRect(rect, false);
3422 }
3423 else
3424 Refresh(false);
3425
3426 return true;
3427 }
3428
3429 #if wxRICHTEXT_USE_OWN_CARET
3430
3431 // ----------------------------------------------------------------------------
3432 // initialization and destruction
3433 // ----------------------------------------------------------------------------
3434
3435 void wxRichTextCaret::Init()
3436 {
3437 m_hasFocus = true;
3438
3439 m_xOld =
3440 m_yOld = -1;
3441 m_richTextCtrl = NULL;
3442 m_needsUpdate = false;
3443 }
3444
3445 wxRichTextCaret::~wxRichTextCaret()
3446 {
3447 }
3448
3449 // ----------------------------------------------------------------------------
3450 // showing/hiding/moving the caret (base class interface)
3451 // ----------------------------------------------------------------------------
3452
3453 void wxRichTextCaret::DoShow()
3454 {
3455 Refresh();
3456 }
3457
3458 void wxRichTextCaret::DoHide()
3459 {
3460 Refresh();
3461 }
3462
3463 void wxRichTextCaret::DoMove()
3464 {
3465 if (IsVisible())
3466 {
3467 Refresh();
3468
3469 if (m_xOld != -1 && m_yOld != -1)
3470 {
3471 if (m_richTextCtrl)
3472 {
3473 wxRect rect(GetPosition(), GetSize());
3474 m_richTextCtrl->RefreshRect(rect, false);
3475 }
3476 }
3477 }
3478
3479 m_xOld = m_x;
3480 m_yOld = m_y;
3481 }
3482
3483 void wxRichTextCaret::DoSize()
3484 {
3485 int countVisible = m_countVisible;
3486 if (countVisible > 0)
3487 {
3488 m_countVisible = 0;
3489 DoHide();
3490 }
3491
3492 if (countVisible > 0)
3493 {
3494 m_countVisible = countVisible;
3495 DoShow();
3496 }
3497 }
3498
3499 // ----------------------------------------------------------------------------
3500 // handling the focus
3501 // ----------------------------------------------------------------------------
3502
3503 void wxRichTextCaret::OnSetFocus()
3504 {
3505 m_hasFocus = true;
3506
3507 if ( IsVisible() )
3508 Refresh();
3509 }
3510
3511 void wxRichTextCaret::OnKillFocus()
3512 {
3513 m_hasFocus = false;
3514 }
3515
3516 // ----------------------------------------------------------------------------
3517 // drawing the caret
3518 // ----------------------------------------------------------------------------
3519
3520 void wxRichTextCaret::Refresh()
3521 {
3522 if (m_richTextCtrl)
3523 {
3524 wxRect rect(GetPosition(), GetSize());
3525 m_richTextCtrl->RefreshRect(rect, false);
3526 }
3527 }
3528
3529 void wxRichTextCaret::DoDraw(wxDC *dc)
3530 {
3531 dc->SetPen( *wxBLACK_PEN );
3532
3533 dc->SetBrush(*(m_hasFocus ? wxBLACK_BRUSH : wxTRANSPARENT_BRUSH));
3534 dc->SetPen(*wxBLACK_PEN);
3535
3536 // VZ: unfortunately, the rectangle comes out a pixel smaller when this is
3537 // done under wxGTK - no idea why
3538 //dc->SetLogicalFunction(wxINVERT);
3539
3540 wxPoint pt(m_x, m_y);
3541
3542 if (m_richTextCtrl)
3543 {
3544 pt = m_richTextCtrl->GetLogicalPoint(pt);
3545 }
3546 dc->DrawRectangle(pt.x, pt.y, m_width, m_height);
3547 }
3548 #endif
3549 // wxRICHTEXT_USE_OWN_CARET
3550
3551 #endif
3552 // wxUSE_RICHTEXT
wxWidgets (Impactor)