1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/richtext/richeditctrl.cpp
3 // Purpose: A rich edit control
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
21 #include "wx/richtext/richtextctrl.h"
22 #include "wx/richtext/richtextstyles.h"
26 #include "wx/settings.h"
29 #include "wx/textfile.h"
31 #include "wx/filename.h"
32 #include "wx/dcbuffer.h"
33 #include "wx/arrimpl.cpp"
34 #include "wx/fontenum.h"
36 // DLL options compatibility check:
38 WX_CHECK_BUILD_OPTIONS("wxRichTextCtrl")
40 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK
)
41 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK
)
42 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK
)
43 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK
)
44 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RETURN
)
45 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_CHARACTER
)
46 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_DELETE
)
48 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING
)
49 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED
)
50 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING
)
51 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED
)
53 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED
)
54 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED
)
55 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED
)
56 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED
)
57 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_BUFFER_RESET
)
59 IMPLEMENT_CLASS( wxRichTextCtrl
, wxControl
)
61 IMPLEMENT_CLASS( wxRichTextEvent
, wxNotifyEvent
)
63 BEGIN_EVENT_TABLE( wxRichTextCtrl
, wxControl
)
64 EVT_PAINT(wxRichTextCtrl
::OnPaint
)
65 EVT_ERASE_BACKGROUND(wxRichTextCtrl
::OnEraseBackground
)
66 EVT_IDLE(wxRichTextCtrl
::OnIdle
)
67 EVT_SCROLLWIN(wxRichTextCtrl
::OnScroll
)
68 EVT_LEFT_DOWN(wxRichTextCtrl
::OnLeftClick
)
69 EVT_MOTION(wxRichTextCtrl
::OnMoveMouse
)
70 EVT_LEFT_UP(wxRichTextCtrl
::OnLeftUp
)
71 EVT_RIGHT_DOWN(wxRichTextCtrl
::OnRightClick
)
72 EVT_MIDDLE_DOWN(wxRichTextCtrl
::OnMiddleClick
)
73 EVT_LEFT_DCLICK(wxRichTextCtrl
::OnLeftDClick
)
74 EVT_CHAR(wxRichTextCtrl
::OnChar
)
75 EVT_SIZE(wxRichTextCtrl
::OnSize
)
76 EVT_SET_FOCUS(wxRichTextCtrl
::OnSetFocus
)
77 EVT_KILL_FOCUS(wxRichTextCtrl
::OnKillFocus
)
78 EVT_MOUSE_CAPTURE_LOST(wxRichTextCtrl
::OnCaptureLost
)
79 EVT_CONTEXT_MENU(wxRichTextCtrl
::OnContextMenu
)
80 EVT_SYS_COLOUR_CHANGED(wxRichTextCtrl
::OnSysColourChanged
)
82 EVT_MENU(wxID_UNDO
, wxRichTextCtrl
::OnUndo
)
83 EVT_UPDATE_UI(wxID_UNDO
, wxRichTextCtrl
::OnUpdateUndo
)
85 EVT_MENU(wxID_REDO
, wxRichTextCtrl
::OnRedo
)
86 EVT_UPDATE_UI(wxID_REDO
, wxRichTextCtrl
::OnUpdateRedo
)
88 EVT_MENU(wxID_COPY
, wxRichTextCtrl
::OnCopy
)
89 EVT_UPDATE_UI(wxID_COPY
, wxRichTextCtrl
::OnUpdateCopy
)
91 EVT_MENU(wxID_PASTE
, wxRichTextCtrl
::OnPaste
)
92 EVT_UPDATE_UI(wxID_PASTE
, wxRichTextCtrl
::OnUpdatePaste
)
94 EVT_MENU(wxID_CUT
, wxRichTextCtrl
::OnCut
)
95 EVT_UPDATE_UI(wxID_CUT
, wxRichTextCtrl
::OnUpdateCut
)
97 EVT_MENU(wxID_CLEAR
, wxRichTextCtrl
::OnClear
)
98 EVT_UPDATE_UI(wxID_CLEAR
, wxRichTextCtrl
::OnUpdateClear
)
100 EVT_MENU(wxID_SELECTALL
, wxRichTextCtrl
::OnSelectAll
)
101 EVT_UPDATE_UI(wxID_SELECTALL
, wxRichTextCtrl
::OnUpdateSelectAll
)
108 wxArrayString wxRichTextCtrl
::sm_availableFontNames
;
110 wxRichTextCtrl
::wxRichTextCtrl()
111 : wxScrollHelper(this)
116 wxRichTextCtrl
::wxRichTextCtrl(wxWindow
* parent
,
118 const wxString
& value
,
122 const wxValidator
& validator
,
123 const wxString
& name
)
124 : wxScrollHelper(this)
127 Create(parent
, id
, value
, pos
, size
, style
, validator
, name
);
131 bool wxRichTextCtrl
::Create( wxWindow
* parent
, wxWindowID id
, const wxString
& value
, const wxPoint
& pos
, const wxSize
& size
, long style
,
132 const wxValidator
& validator
, const wxString
& name
)
134 if (!wxControl
::Create(parent
, id
, pos
, size
,
135 style
|wxFULL_REPAINT_ON_RESIZE
,
141 SetFont(wxSystemSettings
::GetFont(wxSYS_DEFAULT_GUI_FONT
));
144 if (style
& wxTE_READONLY
)
147 // The base attributes must all have default values
148 wxTextAttr attributes
;
149 attributes
.SetFont(GetFont());
150 attributes
.SetTextColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
151 attributes
.SetAlignment(wxTEXT_ALIGNMENT_LEFT
);
152 attributes
.SetLineSpacing(10);
153 attributes
.SetParagraphSpacingAfter(10);
154 attributes
.SetParagraphSpacingBefore(0);
155 attributes
.SetTextEffects(0);
156 attributes
.SetTextEffectFlags(wxTEXT_ATTR_EFFECT_STRIKETHROUGH
|wxTEXT_ATTR_EFFECT_CAPITALS
);
158 SetBasicStyle(attributes
);
160 // The default attributes will be merged with base attributes, so
161 // can be empty to begin with
162 wxTextAttr defaultAttributes
;
163 SetDefaultStyle(defaultAttributes
);
165 SetBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
));
166 SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
169 GetBuffer().SetRichTextCtrl(this);
171 SetCaret(new wxCaret(this, wxRICHTEXT_DEFAULT_CARET_WIDTH
, 16));
174 // Tell the sizers to use the given or best size
175 SetInitialSize(size
);
177 #if wxRICHTEXT_BUFFERED_PAINTING
179 RecreateBuffer(size
);
182 m_textCursor
= wxCursor(wxCURSOR_IBEAM
);
183 m_urlCursor
= wxCursor(wxCURSOR_HAND
);
185 SetCursor(m_textCursor
);
187 if (!value
.IsEmpty())
190 GetBuffer().AddEventHandler(this);
195 wxRichTextCtrl
::~wxRichTextCtrl()
197 GetBuffer().RemoveEventHandler(this);
199 delete m_contextMenu
;
202 /// Member initialisation
203 void wxRichTextCtrl
::Init()
205 m_contextMenu
= NULL
;
207 m_caretPosition
= -1;
208 m_selectionRange
.SetRange(-2, -2);
209 m_selectionAnchor
= -2;
211 m_caretAtLineStart
= false;
213 m_fullLayoutRequired
= false;
214 m_fullLayoutTime
= 0;
215 m_fullLayoutSavedPosition
= 0;
216 m_delayedLayoutThreshold
= wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD
;
217 m_caretPositionForDefaultStyle
= -2;
220 void wxRichTextCtrl
::DoThaw()
222 if (GetBuffer().GetDirty())
230 void wxRichTextCtrl
::Clear()
232 m_buffer
.ResetAndClearCommands();
233 m_buffer
.SetDirty(true);
234 m_caretPosition
= -1;
235 m_caretPositionForDefaultStyle
= -2;
236 m_caretAtLineStart
= false;
237 m_selectionRange
.SetRange(-2, -2);
247 wxTextCtrl
::SendTextUpdatedEvent(this);
251 void wxRichTextCtrl
::OnPaint(wxPaintEvent
& WXUNUSED(event
))
253 if (GetCaret() && GetCaret()->IsVisible())
257 #if wxRICHTEXT_BUFFERED_PAINTING
258 wxBufferedPaintDC
dc(this, m_bufferBitmap
);
268 dc
.SetFont(GetFont());
270 // Paint the background
273 // wxRect drawingArea(GetLogicalPoint(wxPoint(0, 0)), GetClientSize());
275 wxRect
drawingArea(GetUpdateRegion().GetBox());
276 drawingArea
.SetPosition(GetLogicalPoint(drawingArea
.GetPosition()));
278 wxRect
availableSpace(GetClientSize());
279 if (GetBuffer().GetDirty())
281 GetBuffer().Layout(dc
, availableSpace
, wxRICHTEXT_FIXED_WIDTH
|wxRICHTEXT_VARIABLE_HEIGHT
);
282 GetBuffer().SetDirty(false);
286 GetBuffer().Draw(dc
, GetBuffer().GetRange(), GetInternalSelectionRange(), drawingArea
, 0 /* descent */, 0 /* flags */);
289 if (GetCaret() && !GetCaret()->IsVisible())
295 // Empty implementation, to prevent flicker
296 void wxRichTextCtrl
::OnEraseBackground(wxEraseEvent
& WXUNUSED(event
))
300 void wxRichTextCtrl
::OnSetFocus(wxFocusEvent
& WXUNUSED(event
))
304 if (!GetCaret()->IsVisible())
313 void wxRichTextCtrl
::OnKillFocus(wxFocusEvent
& WXUNUSED(event
))
315 if (GetCaret() && GetCaret()->IsVisible())
322 void wxRichTextCtrl
::OnCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
328 void wxRichTextCtrl
::OnLeftClick(wxMouseEvent
& event
)
334 dc
.SetFont(GetFont());
337 int hit
= GetBuffer().HitTest(dc
, event
.GetLogicalPosition(dc
), position
);
339 if (hit
!= wxRICHTEXT_HITTEST_NONE
)
341 m_dragStart
= event
.GetLogicalPosition(dc
);
345 bool caretAtLineStart
= false;
347 if (hit
& wxRICHTEXT_HITTEST_BEFORE
)
349 // If we're at the start of a line (but not first in para)
350 // then we should keep the caret showing at the start of the line
351 // by showing the m_caretAtLineStart flag.
352 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(position
);
353 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(position
);
355 if (line
&& para
&& line
->GetAbsoluteRange().GetStart() == position
&& para
->GetRange().GetStart() != position
)
356 caretAtLineStart
= true;
360 long oldCaretPos
= m_caretPosition
;
362 MoveCaret(position
, caretAtLineStart
);
363 SetDefaultStyleToCursorStyle();
365 if (event
.ShiftDown())
367 bool extendSel
= false;
368 if (m_selectionRange
.GetStart() == -2)
369 extendSel
= ExtendSelection(oldCaretPos
, m_caretPosition
, wxRICHTEXT_SHIFT_DOWN
);
371 extendSel
= ExtendSelection(m_caretPosition
, m_caretPosition
, wxRICHTEXT_SHIFT_DOWN
);
384 void wxRichTextCtrl
::OnLeftUp(wxMouseEvent
& event
)
389 if (GetCapture() == this)
392 // See if we clicked on a URL
395 dc
.SetFont(GetFont());
398 wxPoint logicalPt
= event
.GetLogicalPosition(dc
);
399 int hit
= GetBuffer().HitTest(dc
, logicalPt
, position
);
401 if ((hit
!= wxRICHTEXT_HITTEST_NONE
) && !(hit
& wxRICHTEXT_HITTEST_OUTSIDE
))
403 wxRichTextEvent
cmdEvent(
404 wxEVT_COMMAND_RICHTEXT_LEFT_CLICK
,
406 cmdEvent
.SetEventObject(this);
407 cmdEvent
.SetPosition(m_caretPosition
+1);
409 if (!GetEventHandler()->ProcessEvent(cmdEvent
))
412 if (GetStyle(position
, attr
))
414 if (attr
.HasFlag(wxTEXT_ATTR_URL
))
416 wxString urlTarget
= attr
.GetURL();
417 if (!urlTarget
.IsEmpty())
419 wxMouseEvent
mouseEvent(event
);
421 long startPos
= 0, endPos
= 0;
422 wxRichTextObject
* obj
= GetBuffer().GetLeafObjectAtPosition(position
);
425 startPos
= obj
->GetRange().GetStart();
426 endPos
= obj
->GetRange().GetEnd();
429 wxTextUrlEvent
urlEvent(GetId(), mouseEvent
, startPos
, endPos
);
430 InitCommandEvent(urlEvent
);
432 urlEvent
.SetString(urlTarget
);
434 GetEventHandler()->ProcessEvent(urlEvent
);
444 void wxRichTextCtrl
::OnMoveMouse(wxMouseEvent
& event
)
448 dc
.SetFont(GetFont());
451 wxPoint logicalPt
= event
.GetLogicalPosition(dc
);
452 int hit
= GetBuffer().HitTest(dc
, logicalPt
, position
);
454 // See if we need to change the cursor
457 if (hit
!= wxRICHTEXT_HITTEST_NONE
&& !(hit
& wxRICHTEXT_HITTEST_OUTSIDE
))
460 if (GetStyle(position
, attr
))
462 if (attr
.HasFlag(wxTEXT_ATTR_URL
))
464 SetCursor(m_urlCursor
);
466 else if (!attr
.HasFlag(wxTEXT_ATTR_URL
))
468 SetCursor(m_textCursor
);
473 SetCursor(m_textCursor
);
476 if (!event
.Dragging())
482 if (m_dragging
&& hit
!= wxRICHTEXT_HITTEST_NONE
)
484 // TODO: test closeness
486 bool caretAtLineStart
= false;
488 if (hit
& wxRICHTEXT_HITTEST_BEFORE
)
490 // If we're at the start of a line (but not first in para)
491 // then we should keep the caret showing at the start of the line
492 // by showing the m_caretAtLineStart flag.
493 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(position
);
494 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(position
);
496 if (line
&& para
&& line
->GetAbsoluteRange().GetStart() == position
&& para
->GetRange().GetStart() != position
)
497 caretAtLineStart
= true;
501 if (m_caretPosition
!= position
)
503 bool extendSel
= ExtendSelection(m_caretPosition
, position
, wxRICHTEXT_SHIFT_DOWN
);
505 MoveCaret(position
, caretAtLineStart
);
506 SetDefaultStyleToCursorStyle();
515 void wxRichTextCtrl
::OnRightClick(wxMouseEvent
& event
)
519 wxRichTextEvent
cmdEvent(
520 wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK
,
522 cmdEvent
.SetEventObject(this);
523 cmdEvent
.SetPosition(m_caretPosition
+1);
525 if (!GetEventHandler()->ProcessEvent(cmdEvent
))
529 /// Left-double-click
530 void wxRichTextCtrl
::OnLeftDClick(wxMouseEvent
& WXUNUSED(event
))
532 wxRichTextEvent
cmdEvent(
533 wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK
,
535 cmdEvent
.SetEventObject(this);
536 cmdEvent
.SetPosition(m_caretPosition
+1);
538 if (!GetEventHandler()->ProcessEvent(cmdEvent
))
540 SelectWord(GetCaretPosition()+1);
545 void wxRichTextCtrl
::OnMiddleClick(wxMouseEvent
& event
)
547 wxRichTextEvent
cmdEvent(
548 wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK
,
550 cmdEvent
.SetEventObject(this);
551 cmdEvent
.SetPosition(m_caretPosition
+1);
553 if (!GetEventHandler()->ProcessEvent(cmdEvent
))
558 void wxRichTextCtrl
::OnChar(wxKeyEvent
& event
)
562 flags
|= wxRICHTEXT_CTRL_DOWN
;
563 if (event
.ShiftDown())
564 flags
|= wxRICHTEXT_SHIFT_DOWN
;
566 flags
|= wxRICHTEXT_ALT_DOWN
;
568 if (event
.GetKeyCode() == WXK_LEFT
||
569 event
.GetKeyCode() == WXK_RIGHT
||
570 event
.GetKeyCode() == WXK_UP
||
571 event
.GetKeyCode() == WXK_DOWN
||
572 event
.GetKeyCode() == WXK_HOME
||
573 event
.GetKeyCode() == WXK_PAGEUP
||
574 event
.GetKeyCode() == WXK_PAGEDOWN
||
575 event
.GetKeyCode() == WXK_END
||
577 event
.GetKeyCode() == WXK_NUMPAD_LEFT
||
578 event
.GetKeyCode() == WXK_NUMPAD_RIGHT
||
579 event
.GetKeyCode() == WXK_NUMPAD_UP
||
580 event
.GetKeyCode() == WXK_NUMPAD_DOWN
||
581 event
.GetKeyCode() == WXK_NUMPAD_HOME
||
582 event
.GetKeyCode() == WXK_NUMPAD_PAGEUP
||
583 event
.GetKeyCode() == WXK_NUMPAD_PAGEDOWN
||
584 event
.GetKeyCode() == WXK_NUMPAD_END
)
586 KeyboardNavigate(event
.GetKeyCode(), flags
);
590 // all the other keys modify the controls contents which shouldn't be
591 // possible if we're read-only
598 if (event
.GetKeyCode() == WXK_RETURN
)
600 BeginBatchUndo(_("Insert Text"));
602 long newPos
= m_caretPosition
;
604 DeleteSelectedContent(& newPos
);
606 if (event
.ShiftDown())
609 text
= wxRichTextLineBreakChar
;
610 GetBuffer().InsertTextWithUndo(newPos
+1, text
, this);
613 GetBuffer().InsertNewlineWithUndo(newPos
+1, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE
|wxRICHTEXT_INSERT_INTERACTIVE
);
616 SetDefaultStyleToCursorStyle();
618 ScrollIntoView(m_caretPosition
, WXK_RIGHT
);
620 wxRichTextEvent
cmdEvent(
621 wxEVT_COMMAND_RICHTEXT_RETURN
,
623 cmdEvent
.SetEventObject(this);
624 cmdEvent
.SetFlags(flags
);
625 cmdEvent
.SetPosition(newPos
+1);
627 if (!GetEventHandler()->ProcessEvent(cmdEvent
))
629 // Generate conventional event
630 wxCommandEvent
textEvent(wxEVT_COMMAND_TEXT_ENTER
, GetId());
631 InitCommandEvent(textEvent
);
633 GetEventHandler()->ProcessEvent(textEvent
);
637 else if (event
.GetKeyCode() == WXK_BACK
)
639 BeginBatchUndo(_("Delete Text"));
641 // Submit range in character positions, which are greater than caret positions,
642 // so subtract 1 for deleted character and add 1 for conversion to character position.
643 if (m_caretPosition
> -1 && !HasSelection())
645 bool processed
= false;
648 long pos
= wxRichTextCtrl
::FindNextWordPosition(-1);
649 if (pos
!= -1 && (pos
< m_caretPosition
))
651 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(pos
+1, m_caretPosition
), this);
657 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition
, m_caretPosition
), this);
660 DeleteSelectedContent();
664 if (GetLastPosition() == -1)
668 m_caretPosition
= -1;
670 SetDefaultStyleToCursorStyle();
673 ScrollIntoView(m_caretPosition
, WXK_LEFT
);
675 wxRichTextEvent
cmdEvent(
676 wxEVT_COMMAND_RICHTEXT_DELETE
,
678 cmdEvent
.SetEventObject(this);
679 cmdEvent
.SetFlags(flags
);
680 cmdEvent
.SetPosition(m_caretPosition
+1);
681 GetEventHandler()->ProcessEvent(cmdEvent
);
685 else if (event
.GetKeyCode() == WXK_DELETE
)
687 BeginBatchUndo(_("Delete Text"));
689 // Submit range in character positions, which are greater than caret positions,
690 if (m_caretPosition
< GetBuffer().GetRange().GetEnd()+1 && !HasSelection())
692 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition
+1, m_caretPosition
+1), this);
695 DeleteSelectedContent();
699 if (GetLastPosition() == -1)
703 m_caretPosition
= -1;
705 SetDefaultStyleToCursorStyle();
708 wxRichTextEvent
cmdEvent(
709 wxEVT_COMMAND_RICHTEXT_DELETE
,
711 cmdEvent
.SetEventObject(this);
712 cmdEvent
.SetFlags(flags
);
713 cmdEvent
.SetPosition(m_caretPosition
+1);
714 GetEventHandler()->ProcessEvent(cmdEvent
);
720 long keycode
= event
.GetKeyCode();
793 case WXK_NUMPAD_SPACE
:
795 case WXK_NUMPAD_ENTER
:
800 case WXK_NUMPAD_HOME
:
801 case WXK_NUMPAD_LEFT
:
803 case WXK_NUMPAD_RIGHT
:
804 case WXK_NUMPAD_DOWN
:
805 case WXK_NUMPAD_PAGEUP
:
806 case WXK_NUMPAD_PAGEDOWN
:
808 case WXK_NUMPAD_BEGIN
:
809 case WXK_NUMPAD_INSERT
:
810 case WXK_NUMPAD_DELETE
:
811 case WXK_NUMPAD_EQUAL
:
812 case WXK_NUMPAD_MULTIPLY
:
814 case WXK_NUMPAD_SEPARATOR
:
815 case WXK_NUMPAD_SUBTRACT
:
816 case WXK_NUMPAD_DECIMAL
:
817 case WXK_WINDOWS_LEFT
:
825 if (event
.CmdDown() || event
.AltDown())
831 wxRichTextEvent
cmdEvent(
832 wxEVT_COMMAND_RICHTEXT_CHARACTER
,
834 cmdEvent
.SetEventObject(this);
835 cmdEvent
.SetFlags(flags
);
837 cmdEvent
.SetCharacter(event
.GetUnicodeKey());
839 cmdEvent
.SetCharacter((wxChar
) keycode
);
841 cmdEvent
.SetPosition(m_caretPosition
+1);
843 if (keycode
== wxT('\t'))
845 // See if we need to promote or demote the selection or paragraph at the cursor
846 // position, instead of inserting a tab.
847 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
848 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(pos
);
849 if (para
&& para
->GetRange().GetStart() == pos
&& para
->GetAttributes().HasListStyleName())
851 wxRichTextRange range
;
853 range
= GetSelectionRange();
855 range
= para
->GetRange().FromInternal();
857 int promoteBy
= event
.ShiftDown() ?
1 : -1;
859 PromoteList(promoteBy
, range
, NULL
);
861 GetEventHandler()->ProcessEvent(cmdEvent
);
867 BeginBatchUndo(_("Insert Text"));
869 long newPos
= m_caretPosition
;
870 DeleteSelectedContent(& newPos
);
873 wxString str
= event
.GetUnicodeKey();
875 wxString str
= (wxChar
) event
.GetKeyCode();
877 GetBuffer().InsertTextWithUndo(newPos
+1, str
, this, 0);
881 SetDefaultStyleToCursorStyle();
882 ScrollIntoView(m_caretPosition
, WXK_RIGHT
);
884 GetEventHandler()->ProcessEvent(cmdEvent
);
892 /// Delete content if there is a selection, e.g. when pressing a key.
893 bool wxRichTextCtrl
::DeleteSelectedContent(long* newPos
)
897 long pos
= m_selectionRange
.GetStart();
898 GetBuffer().DeleteRangeWithUndo(m_selectionRange
, this);
899 m_selectionRange
.SetRange(-2, -2);
909 /// Keyboard navigation
913 Left: left one character
914 Right: right one character
917 Ctrl-Left: left one word
918 Ctrl-Right: right one word
919 Ctrl-Up: previous paragraph start
920 Ctrl-Down: next start of paragraph
923 Ctrl-Home: start of document
924 Ctrl-End: end of document
926 Page-Down: Down a screen
930 Ctrl-Alt-PgUp: Start of window
931 Ctrl-Alt-PgDn: End of window
932 F8: Start selection mode
933 Esc: End selection mode
935 Adding Shift does the above but starts/extends selection.
940 bool wxRichTextCtrl
::KeyboardNavigate(int keyCode
, int flags
)
942 bool success
= false;
944 if (keyCode
== WXK_RIGHT
|| keyCode
== WXK_NUMPAD_RIGHT
)
946 if (flags
& wxRICHTEXT_CTRL_DOWN
)
947 success
= WordRight(1, flags
);
949 success
= MoveRight(1, flags
);
951 else if (keyCode
== WXK_LEFT
|| keyCode
== WXK_NUMPAD_LEFT
)
953 if (flags
& wxRICHTEXT_CTRL_DOWN
)
954 success
= WordLeft(1, flags
);
956 success
= MoveLeft(1, flags
);
958 else if (keyCode
== WXK_UP
|| keyCode
== WXK_NUMPAD_UP
)
960 if (flags
& wxRICHTEXT_CTRL_DOWN
)
961 success
= MoveToParagraphStart(flags
);
963 success
= MoveUp(1, flags
);
965 else if (keyCode
== WXK_DOWN
|| keyCode
== WXK_NUMPAD_DOWN
)
967 if (flags
& wxRICHTEXT_CTRL_DOWN
)
968 success
= MoveToParagraphEnd(flags
);
970 success
= MoveDown(1, flags
);
972 else if (keyCode
== WXK_PAGEUP
|| keyCode
== WXK_NUMPAD_PAGEUP
)
974 success
= PageUp(1, flags
);
976 else if (keyCode
== WXK_PAGEDOWN
|| keyCode
== WXK_NUMPAD_PAGEDOWN
)
978 success
= PageDown(1, flags
);
980 else if (keyCode
== WXK_HOME
|| keyCode
== WXK_NUMPAD_HOME
)
982 if (flags
& wxRICHTEXT_CTRL_DOWN
)
983 success
= MoveHome(flags
);
985 success
= MoveToLineStart(flags
);
987 else if (keyCode
== WXK_END
|| keyCode
== WXK_NUMPAD_END
)
989 if (flags
& wxRICHTEXT_CTRL_DOWN
)
990 success
= MoveEnd(flags
);
992 success
= MoveToLineEnd(flags
);
997 ScrollIntoView(m_caretPosition
, keyCode
);
998 SetDefaultStyleToCursorStyle();
1004 /// Extend the selection. Selections are in caret positions.
1005 bool wxRichTextCtrl
::ExtendSelection(long oldPos
, long newPos
, int flags
)
1007 if (flags
& wxRICHTEXT_SHIFT_DOWN
)
1009 // If not currently selecting, start selecting
1010 if (m_selectionRange
.GetStart() == -2)
1012 m_selectionAnchor
= oldPos
;
1014 if (oldPos
> newPos
)
1015 m_selectionRange
.SetRange(newPos
+1, oldPos
);
1017 m_selectionRange
.SetRange(oldPos
+1, newPos
);
1021 // Always ensure that the selection range start is greater than
1023 if (newPos
> m_selectionAnchor
)
1024 m_selectionRange
.SetRange(m_selectionAnchor
+1, newPos
);
1026 m_selectionRange
.SetRange(newPos
+1, m_selectionAnchor
);
1029 if (m_selectionRange
.GetStart() > m_selectionRange
.GetEnd())
1031 wxLogDebug(wxT("Strange selection range"));
1040 /// Scroll into view, returning true if we scrolled.
1041 /// This takes a _caret_ position.
1042 bool wxRichTextCtrl
::ScrollIntoView(long position
, int keyCode
)
1044 wxRichTextLine
* line
= GetVisibleLineForCaretPosition(position
);
1050 GetScrollPixelsPerUnit(& ppuX
, & ppuY
);
1052 int startXUnits
, startYUnits
;
1053 GetViewStart(& startXUnits
, & startYUnits
);
1054 int startY
= startYUnits
* ppuY
;
1057 GetVirtualSize(& sx
, & sy
);
1063 wxRect rect
= line
->GetRect();
1065 bool scrolled
= false;
1067 wxSize clientSize
= GetClientSize();
1070 if (keyCode
== WXK_DOWN
|| keyCode
== WXK_NUMPAD_DOWN
||
1071 keyCode
== WXK_RIGHT
|| keyCode
== WXK_NUMPAD_RIGHT
||
1072 keyCode
== WXK_END
|| keyCode
== WXK_NUMPAD_END
||
1073 keyCode
== WXK_PAGEDOWN
|| keyCode
== WXK_NUMPAD_PAGEDOWN
)
1075 if ((rect
.y
+ rect
.height
) > (clientSize
.y
+ startY
))
1077 // Make it scroll so this item is at the bottom
1079 int y
= rect
.y
- (clientSize
.y
- rect
.height
);
1080 int yUnits
= (int) (0.5 + ((float) y
)/(float) ppuY
);
1082 // If we're still off the screen, scroll another line down
1083 if ((rect
.y
+ rect
.height
) > (clientSize
.y
+ (yUnits
*ppuY
)))
1086 if (startYUnits
!= yUnits
)
1088 SetScrollbars(ppuX
, ppuY
, sxUnits
, syUnits
, 0, yUnits
);
1092 else if (rect
.y
< startY
)
1094 // Make it scroll so this item is at the top
1097 int yUnits
= (int) (0.5 + ((float) y
)/(float) ppuY
);
1099 if (startYUnits
!= yUnits
)
1101 SetScrollbars(ppuX
, ppuY
, sxUnits
, syUnits
, 0, yUnits
);
1107 else if (keyCode
== WXK_UP
|| keyCode
== WXK_NUMPAD_UP
||
1108 keyCode
== WXK_LEFT
|| keyCode
== WXK_NUMPAD_LEFT
||
1109 keyCode
== WXK_HOME
|| keyCode
== WXK_NUMPAD_HOME
||
1110 keyCode
== WXK_PAGEUP
|| keyCode
== WXK_NUMPAD_PAGEUP
)
1112 if (rect
.y
< startY
)
1114 // Make it scroll so this item is at the top
1117 int yUnits
= (int) (0.5 + ((float) y
)/(float) ppuY
);
1119 if (startYUnits
!= yUnits
)
1121 SetScrollbars(ppuX
, ppuY
, sxUnits
, syUnits
, 0, yUnits
);
1125 else if ((rect
.y
+ rect
.height
) > (clientSize
.y
+ startY
))
1127 // Make it scroll so this item is at the bottom
1129 int y
= rect
.y
- (clientSize
.y
- rect
.height
);
1130 int yUnits
= (int) (0.5 + ((float) y
)/(float) ppuY
);
1132 // If we're still off the screen, scroll another line down
1133 if ((rect
.y
+ rect
.height
) > (clientSize
.y
+ (yUnits
*ppuY
)))
1136 if (startYUnits
!= yUnits
)
1138 SetScrollbars(ppuX
, ppuY
, sxUnits
, syUnits
, 0, yUnits
);
1150 /// Is the given position visible on the screen?
1151 bool wxRichTextCtrl
::IsPositionVisible(long pos
) const
1153 wxRichTextLine
* line
= GetVisibleLineForCaretPosition(pos
-1);
1159 GetScrollPixelsPerUnit(& ppuX
, & ppuY
);
1162 GetViewStart(& startX
, & startY
);
1164 startY
= startY
* ppuY
;
1166 wxRect rect
= line
->GetRect();
1167 wxSize clientSize
= GetClientSize();
1169 return (rect
.GetBottom() > startY
) && (rect
.GetTop() < (startY
+ clientSize
.y
));
1172 void wxRichTextCtrl
::SetCaretPosition(long position
, bool showAtLineStart
)
1174 m_caretPosition
= position
;
1175 m_caretAtLineStart
= showAtLineStart
;
1178 /// Move caret one visual step forward: this may mean setting a flag
1179 /// and keeping the same position if we're going from the end of one line
1180 /// to the start of the next, which may be the exact same caret position.
1181 void wxRichTextCtrl
::MoveCaretForward(long oldPosition
)
1183 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(oldPosition
);
1185 // Only do the check if we're not at the end of the paragraph (where things work OK
1187 if (para
&& (oldPosition
!= para
->GetRange().GetEnd() - 1))
1189 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(oldPosition
);
1193 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1195 // We're at the end of a line. See whether we need to
1196 // stay at the same actual caret position but change visual
1197 // position, or not.
1198 if (oldPosition
== lineRange
.GetEnd())
1200 if (m_caretAtLineStart
)
1202 // We're already at the start of the line, so actually move on now.
1203 m_caretPosition
= oldPosition
+ 1;
1204 m_caretAtLineStart
= false;
1208 // We're showing at the end of the line, so keep to
1209 // the same position but indicate that we're to show
1210 // at the start of the next line.
1211 m_caretPosition
= oldPosition
;
1212 m_caretAtLineStart
= true;
1214 SetDefaultStyleToCursorStyle();
1220 SetDefaultStyleToCursorStyle();
1223 /// Move caret one visual step backward: this may mean setting a flag
1224 /// and keeping the same position if we're going from the end of one line
1225 /// to the start of the next, which may be the exact same caret position.
1226 void wxRichTextCtrl
::MoveCaretBack(long oldPosition
)
1228 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(oldPosition
);
1230 // Only do the check if we're not at the start of the paragraph (where things work OK
1232 if (para
&& (oldPosition
!= para
->GetRange().GetStart()))
1234 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(oldPosition
);
1238 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1240 // We're at the start of a line. See whether we need to
1241 // stay at the same actual caret position but change visual
1242 // position, or not.
1243 if (oldPosition
== lineRange
.GetStart())
1245 m_caretPosition
= oldPosition
-1;
1246 m_caretAtLineStart
= true;
1249 else if (oldPosition
== lineRange
.GetEnd())
1251 if (m_caretAtLineStart
)
1253 // We're at the start of the line, so keep the same caret position
1254 // but clear the start-of-line flag.
1255 m_caretPosition
= oldPosition
;
1256 m_caretAtLineStart
= false;
1260 // We're showing at the end of the line, so go back
1261 // to the previous character position.
1262 m_caretPosition
= oldPosition
- 1;
1264 SetDefaultStyleToCursorStyle();
1270 SetDefaultStyleToCursorStyle();
1274 bool wxRichTextCtrl
::MoveRight(int noPositions
, int flags
)
1276 long endPos
= GetBuffer().GetRange().GetEnd();
1278 if (m_caretPosition
+ noPositions
< endPos
)
1280 long oldPos
= m_caretPosition
;
1281 long newPos
= m_caretPosition
+ noPositions
;
1283 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1287 // Determine by looking at oldPos and m_caretPosition whether
1288 // we moved from the end of a line to the start of the next line, in which case
1289 // we want to adjust the caret position such that it is positioned at the
1290 // start of the next line, rather than jumping past the first character of the
1292 if (noPositions
== 1 && !extendSel
)
1293 MoveCaretForward(oldPos
);
1295 SetCaretPosition(newPos
);
1298 SetDefaultStyleToCursorStyle();
1309 bool wxRichTextCtrl
::MoveLeft(int noPositions
, int flags
)
1313 if (m_caretPosition
> startPos
- noPositions
+ 1)
1315 long oldPos
= m_caretPosition
;
1316 long newPos
= m_caretPosition
- noPositions
;
1317 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1321 if (noPositions
== 1 && !extendSel
)
1322 MoveCaretBack(oldPos
);
1324 SetCaretPosition(newPos
);
1327 SetDefaultStyleToCursorStyle();
1338 bool wxRichTextCtrl
::MoveUp(int noLines
, int flags
)
1340 return MoveDown(- noLines
, flags
);
1344 bool wxRichTextCtrl
::MoveDown(int noLines
, int flags
)
1349 long lineNumber
= GetBuffer().GetVisibleLineNumber(m_caretPosition
, true, m_caretAtLineStart
);
1350 wxPoint pt
= GetCaret()->GetPosition();
1351 long newLine
= lineNumber
+ noLines
;
1353 if (lineNumber
!= -1)
1357 long lastLine
= GetBuffer().GetVisibleLineNumber(GetBuffer().GetRange().GetEnd());
1359 if (newLine
> lastLine
)
1369 wxRichTextLine
* lineObj
= GetBuffer().GetLineForVisibleLineNumber(newLine
);
1372 pt
.y
= lineObj
->GetAbsolutePosition().y
+ 2;
1378 wxClientDC
dc(this);
1380 dc
.SetFont(GetFont());
1382 int hitTest
= GetBuffer().HitTest(dc
, pt
, newPos
);
1384 if (hitTest
!= wxRICHTEXT_HITTEST_NONE
)
1386 // If end of previous line, and hitTest is wxRICHTEXT_HITTEST_BEFORE,
1387 // we want to be at the end of the last line but with m_caretAtLineStart set to true,
1388 // so we view the caret at the start of the line.
1389 bool caretLineStart
= false;
1390 if (hitTest
& wxRICHTEXT_HITTEST_BEFORE
)
1392 wxRichTextLine
* thisLine
= GetBuffer().GetLineAtPosition(newPos
-1);
1393 wxRichTextRange lineRange
;
1395 lineRange
= thisLine
->GetAbsoluteRange();
1397 if (thisLine
&& (newPos
-1) == lineRange
.GetEnd())
1400 caretLineStart
= true;
1404 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(newPos
);
1405 if (para
&& para
->GetRange().GetStart() == newPos
)
1410 long newSelEnd
= newPos
;
1412 bool extendSel
= ExtendSelection(m_caretPosition
, newSelEnd
, flags
);
1416 SetCaretPosition(newPos
, caretLineStart
);
1418 SetDefaultStyleToCursorStyle();
1428 /// Move to the end of the paragraph
1429 bool wxRichTextCtrl
::MoveToParagraphEnd(int flags
)
1431 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(m_caretPosition
, true);
1434 long newPos
= para
->GetRange().GetEnd() - 1;
1435 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1439 SetCaretPosition(newPos
);
1441 SetDefaultStyleToCursorStyle();
1451 /// Move to the start of the paragraph
1452 bool wxRichTextCtrl
::MoveToParagraphStart(int flags
)
1454 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(m_caretPosition
, true);
1457 long newPos
= para
->GetRange().GetStart() - 1;
1458 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1462 SetCaretPosition(newPos
);
1464 SetDefaultStyleToCursorStyle();
1474 /// Move to the end of the line
1475 bool wxRichTextCtrl
::MoveToLineEnd(int flags
)
1477 wxRichTextLine
* line
= GetVisibleLineForCaretPosition(m_caretPosition
);
1481 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1482 long newPos
= lineRange
.GetEnd();
1483 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1487 SetCaretPosition(newPos
);
1489 SetDefaultStyleToCursorStyle();
1499 /// Move to the start of the line
1500 bool wxRichTextCtrl
::MoveToLineStart(int flags
)
1502 wxRichTextLine
* line
= GetVisibleLineForCaretPosition(m_caretPosition
);
1505 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1506 long newPos
= lineRange
.GetStart()-1;
1508 bool extendSel
= ExtendSelection(m_caretPosition
, newPos
, flags
);
1512 wxRichTextParagraph
* para
= GetBuffer().GetParagraphForLine(line
);
1514 SetCaretPosition(newPos
, para
->GetRange().GetStart() != lineRange
.GetStart());
1516 SetDefaultStyleToCursorStyle();
1526 /// Move to the start of the buffer
1527 bool wxRichTextCtrl
::MoveHome(int flags
)
1529 if (m_caretPosition
!= -1)
1531 bool extendSel
= ExtendSelection(m_caretPosition
, -1, flags
);
1535 SetCaretPosition(-1);
1537 SetDefaultStyleToCursorStyle();
1547 /// Move to the end of the buffer
1548 bool wxRichTextCtrl
::MoveEnd(int flags
)
1550 long endPos
= GetBuffer().GetRange().GetEnd()-1;
1552 if (m_caretPosition
!= endPos
)
1554 bool extendSel
= ExtendSelection(m_caretPosition
, endPos
, flags
);
1558 SetCaretPosition(endPos
);
1560 SetDefaultStyleToCursorStyle();
1570 /// Move noPages pages up
1571 bool wxRichTextCtrl
::PageUp(int noPages
, int flags
)
1573 return PageDown(- noPages
, flags
);
1576 /// Move noPages pages down
1577 bool wxRichTextCtrl
::PageDown(int noPages
, int flags
)
1579 // Calculate which line occurs noPages * screen height further down.
1580 wxRichTextLine
* line
= GetVisibleLineForCaretPosition(m_caretPosition
);
1583 wxSize clientSize
= GetClientSize();
1584 int newY
= line
->GetAbsolutePosition().y
+ noPages
*clientSize
.y
;
1586 wxRichTextLine
* newLine
= GetBuffer().GetLineAtYPosition(newY
);
1589 wxRichTextRange lineRange
= newLine
->GetAbsoluteRange();
1590 long pos
= lineRange
.GetStart()-1;
1591 if (pos
!= m_caretPosition
)
1593 wxRichTextParagraph
* para
= GetBuffer().GetParagraphForLine(newLine
);
1595 bool extendSel
= ExtendSelection(m_caretPosition
, pos
, flags
);
1599 SetCaretPosition(pos
, para
->GetRange().GetStart() != lineRange
.GetStart());
1601 SetDefaultStyleToCursorStyle();
1613 static bool wxRichTextCtrlIsWhitespace(const wxString
& str
)
1615 return str
== wxT(" ") || str
== wxT("\t");
1618 // Finds the caret position for the next word
1619 long wxRichTextCtrl
::FindNextWordPosition(int direction
) const
1621 long endPos
= GetBuffer().GetRange().GetEnd();
1625 long i
= m_caretPosition
+1+direction
; // +1 for conversion to character pos
1627 // First skip current text to space
1628 while (i
< endPos
&& i
> -1)
1630 // i is in character, not caret positions
1631 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(i
, i
));
1632 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(i
, false);
1633 if (line
&& (i
== line
->GetAbsoluteRange().GetEnd()))
1637 else if (!wxRichTextCtrlIsWhitespace(text
) && !text
.empty())
1644 while (i
< endPos
&& i
> -1)
1646 // i is in character, not caret positions
1647 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(i
, i
));
1648 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(i
, false);
1649 if (line
&& (i
== line
->GetAbsoluteRange().GetEnd()))
1650 return wxMax(-1, i
);
1652 if (text
.empty()) // End of paragraph, or maybe an image
1653 return wxMax(-1, i
- 1);
1654 else if (wxRichTextCtrlIsWhitespace(text
) || text
.empty())
1658 // Convert to caret position
1659 return wxMax(-1, i
- 1);
1668 long i
= m_caretPosition
;
1670 // First skip white space
1671 while (i
< endPos
&& i
> -1)
1673 // i is in character, not caret positions
1674 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(i
, i
));
1675 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(i
, false);
1677 if (text
.empty() || (line
&& (i
== line
->GetAbsoluteRange().GetStart()))) // End of paragraph, or maybe an image
1679 else if (wxRichTextCtrlIsWhitespace(text
) || text
.empty())
1684 // Next skip current text to space
1685 while (i
< endPos
&& i
> -1)
1687 // i is in character, not caret positions
1688 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(i
, i
));
1689 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(i
, false);
1690 if (line
&& line
->GetAbsoluteRange().GetStart() == i
)
1693 if (!wxRichTextCtrlIsWhitespace(text
) /* && !text.empty() */)
1706 /// Move n words left
1707 bool wxRichTextCtrl
::WordLeft(int WXUNUSED(n
), int flags
)
1709 long pos
= FindNextWordPosition(-1);
1710 if (pos
!= m_caretPosition
)
1712 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(pos
, true);
1714 bool extendSel
= ExtendSelection(m_caretPosition
, pos
, flags
);
1718 SetCaretPosition(pos
, para
->GetRange().GetStart() != pos
);
1720 SetDefaultStyleToCursorStyle();
1730 /// Move n words right
1731 bool wxRichTextCtrl
::WordRight(int WXUNUSED(n
), int flags
)
1733 long pos
= FindNextWordPosition(1);
1734 if (pos
!= m_caretPosition
)
1736 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(pos
, true);
1738 bool extendSel
= ExtendSelection(m_caretPosition
, pos
, flags
);
1742 SetCaretPosition(pos
, para
->GetRange().GetStart() != pos
);
1744 SetDefaultStyleToCursorStyle();
1755 void wxRichTextCtrl
::OnSize(wxSizeEvent
& event
)
1757 // Only do sizing optimization for large buffers
1758 if (GetBuffer().GetRange().GetEnd() > m_delayedLayoutThreshold
)
1760 m_fullLayoutRequired
= true;
1761 m_fullLayoutTime
= wxGetLocalTimeMillis();
1762 m_fullLayoutSavedPosition
= GetFirstVisiblePosition();
1763 LayoutContent(true /* onlyVisibleRect */);
1766 GetBuffer().Invalidate(wxRICHTEXT_ALL
);
1768 #if wxRICHTEXT_BUFFERED_PAINTING
1776 /// Idle-time processing
1777 void wxRichTextCtrl
::OnIdle(wxIdleEvent
& event
)
1779 const int layoutInterval
= wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL
;
1781 if (m_fullLayoutRequired
&& (wxGetLocalTimeMillis() > (m_fullLayoutTime
+ layoutInterval
)))
1783 m_fullLayoutRequired
= false;
1784 m_fullLayoutTime
= 0;
1785 GetBuffer().Invalidate(wxRICHTEXT_ALL
);
1786 ShowPosition(m_fullLayoutSavedPosition
);
1790 if (m_caretPositionForDefaultStyle
!= -2)
1792 // If the caret position has changed, no longer reflect the default style
1794 if (GetCaretPosition() != m_caretPositionForDefaultStyle
)
1795 m_caretPositionForDefaultStyle
= -2;
1802 void wxRichTextCtrl
::OnScroll(wxScrollWinEvent
& event
)
1808 /// Set up scrollbars, e.g. after a resize
1809 void wxRichTextCtrl
::SetupScrollbars(bool atTop
)
1814 if (GetBuffer().IsEmpty())
1816 SetScrollbars(0, 0, 0, 0, 0, 0);
1820 // TODO: reimplement scrolling so we scroll by line, not by fixed number
1821 // of pixels. See e.g. wxVScrolledWindow for ideas.
1822 int pixelsPerUnit
= 5;
1823 wxSize clientSize
= GetClientSize();
1825 int maxHeight
= GetBuffer().GetCachedSize().y
;
1827 // Round up so we have at least maxHeight pixels
1828 int unitsY
= (int) (((float)maxHeight
/(float)pixelsPerUnit
) + 0.5);
1830 int startX
= 0, startY
= 0;
1832 GetViewStart(& startX
, & startY
);
1834 int maxPositionX
= 0; // wxMax(sz.x - clientSize.x, 0);
1835 int maxPositionY
= (int) ((((float)(wxMax((unitsY
*pixelsPerUnit
) - clientSize
.y
, 0)))/((float)pixelsPerUnit
)) + 0.5);
1837 // Move to previous scroll position if
1839 SetScrollbars(0, pixelsPerUnit
,
1841 wxMin(maxPositionX
, startX
), wxMin(maxPositionY
, startY
));
1844 /// Paint the background
1845 void wxRichTextCtrl
::PaintBackground(wxDC
& dc
)
1847 wxColour backgroundColour
= GetBackgroundColour();
1848 if (!backgroundColour
.Ok())
1849 backgroundColour
= wxSystemSettings
::GetColour(wxSYS_COLOUR_3DFACE
);
1851 // Clear the background
1852 dc
.SetBrush(wxBrush(backgroundColour
));
1853 dc
.SetPen(*wxTRANSPARENT_PEN
);
1854 wxRect
windowRect(GetClientSize());
1855 windowRect
.x
-= 2; windowRect
.y
-= 2;
1856 windowRect
.width
+= 4; windowRect
.height
+= 4;
1858 // We need to shift the rectangle to take into account
1859 // scrolling. Converting device to logical coordinates.
1860 CalcUnscrolledPosition(windowRect
.x
, windowRect
.y
, & windowRect
.x
, & windowRect
.y
);
1861 dc
.DrawRectangle(windowRect
);
1864 #if wxRICHTEXT_BUFFERED_PAINTING
1865 /// Recreate buffer bitmap if necessary
1866 bool wxRichTextCtrl
::RecreateBuffer(const wxSize
& size
)
1869 if (sz
== wxDefaultSize
)
1870 sz
= GetClientSize();
1872 if (sz
.x
< 1 || sz
.y
< 1)
1875 if (!m_bufferBitmap
.Ok() || m_bufferBitmap
.GetWidth() < sz
.x
|| m_bufferBitmap
.GetHeight() < sz
.y
)
1876 m_bufferBitmap
= wxBitmap(sz
.x
, sz
.y
);
1877 return m_bufferBitmap
.Ok();
1881 // ----------------------------------------------------------------------------
1882 // file IO functions
1883 // ----------------------------------------------------------------------------
1885 bool wxRichTextCtrl
::DoLoadFile(const wxString
& filename
, int fileType
)
1887 bool success
= GetBuffer().LoadFile(filename
, fileType
);
1889 m_filename
= filename
;
1892 SetInsertionPoint(0);
1895 SetupScrollbars(true);
1897 wxTextCtrl
::SendTextUpdatedEvent(this);
1903 wxLogError(_("File couldn't be loaded."));
1909 bool wxRichTextCtrl
::DoSaveFile(const wxString
& filename
, int fileType
)
1911 if (GetBuffer().SaveFile(filename
, fileType
))
1913 m_filename
= filename
;
1920 wxLogError(_("The text couldn't be saved."));
1925 // ----------------------------------------------------------------------------
1926 // wxRichTextCtrl specific functionality
1927 // ----------------------------------------------------------------------------
1929 /// Add a new paragraph of text to the end of the buffer
1930 wxRichTextRange wxRichTextCtrl
::AddParagraph(const wxString
& text
)
1932 wxRichTextRange range
= GetBuffer().AddParagraph(text
);
1938 wxRichTextRange wxRichTextCtrl
::AddImage(const wxImage
& image
)
1940 wxRichTextRange range
= GetBuffer().AddImage(image
);
1945 // ----------------------------------------------------------------------------
1946 // selection and ranges
1947 // ----------------------------------------------------------------------------
1949 void wxRichTextCtrl
::SelectAll()
1951 SetSelection(0, GetLastPosition()+1);
1952 m_selectionAnchor
= -1;
1956 void wxRichTextCtrl
::SelectNone()
1958 if (!(GetSelectionRange() == wxRichTextRange(-2, -2)))
1961 m_selectionRange
= wxRichTextRange(-2, -2);
1963 m_selectionAnchor
= -2;
1966 static bool wxIsWordDelimiter(const wxString
& text
)
1968 return !text
.IsEmpty() && !wxIsalnum(text
[0]);
1971 /// Select the word at the given character position
1972 bool wxRichTextCtrl
::SelectWord(long position
)
1974 if (position
< 0 || position
> GetBuffer().GetRange().GetEnd())
1977 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(position
);
1981 if (position
== para
->GetRange().GetEnd())
1984 long positionStart
= position
;
1985 long positionEnd
= position
;
1987 for (positionStart
= position
; positionStart
>= para
->GetRange().GetStart(); positionStart
--)
1989 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(positionStart
, positionStart
));
1990 if (wxIsWordDelimiter(text
))
1996 if (positionStart
< para
->GetRange().GetStart())
1997 positionStart
= para
->GetRange().GetStart();
1999 for (positionEnd
= position
; positionEnd
< para
->GetRange().GetEnd(); positionEnd
++)
2001 wxString text
= GetBuffer().GetTextForRange(wxRichTextRange(positionEnd
, positionEnd
));
2002 if (wxIsWordDelimiter(text
))
2008 if (positionEnd
>= para
->GetRange().GetEnd())
2009 positionEnd
= para
->GetRange().GetEnd();
2011 if (positionEnd
< positionStart
)
2014 SetSelection(positionStart
, positionEnd
+1);
2016 if (positionStart
>= 0)
2018 MoveCaret(positionStart
-1, true);
2019 SetDefaultStyleToCursorStyle();
2025 wxString wxRichTextCtrl
::GetStringSelection() const
2028 GetSelection(&from
, &to
);
2030 return GetRange(from
, to
);
2033 // ----------------------------------------------------------------------------
2035 // ----------------------------------------------------------------------------
2037 wxTextCtrlHitTestResult
2038 wxRichTextCtrl
::HitTest(const wxPoint
& pt
, wxTextCoord
*x
, wxTextCoord
*y
) const
2040 // implement in terms of the other overload as the native ports typically
2041 // can get the position and not (x, y) pair directly (although wxUniv
2042 // directly gets x and y -- and so overrides this method as well)
2044 wxTextCtrlHitTestResult rc
= HitTest(pt
, &pos
);
2046 if ( rc
!= wxTE_HT_UNKNOWN
)
2048 PositionToXY(pos
, x
, y
);
2054 wxTextCtrlHitTestResult
2055 wxRichTextCtrl
::HitTest(const wxPoint
& pt
,
2058 wxClientDC
dc((wxRichTextCtrl
*) this);
2059 ((wxRichTextCtrl
*)this)->PrepareDC(dc
);
2061 // Buffer uses logical position (relative to start of buffer)
2063 wxPoint pt2
= GetLogicalPoint(pt
);
2065 int hit
= ((wxRichTextCtrl
*)this)->GetBuffer().HitTest(dc
, pt2
, *pos
);
2067 if ((hit
& wxRICHTEXT_HITTEST_BEFORE
) && (hit
& wxRICHTEXT_HITTEST_OUTSIDE
))
2068 return wxTE_HT_BEFORE
;
2069 else if ((hit
& wxRICHTEXT_HITTEST_AFTER
) && (hit
& wxRICHTEXT_HITTEST_OUTSIDE
))
2070 return wxTE_HT_BEYOND
;
2071 else if (hit
& (wxRICHTEXT_HITTEST_BEFORE
|wxRICHTEXT_HITTEST_AFTER
))
2072 return wxTE_HT_ON_TEXT
;
2074 return wxTE_HT_UNKNOWN
;
2077 // ----------------------------------------------------------------------------
2078 // set/get the controls text
2079 // ----------------------------------------------------------------------------
2081 wxString wxRichTextCtrl
::GetValue() const
2083 return GetBuffer().GetText();
2086 wxString wxRichTextCtrl
::GetRange(long from
, long to
) const
2088 // Public API for range is different from internals
2089 return GetBuffer().GetTextForRange(wxRichTextRange(from
, to
-1));
2092 void wxRichTextCtrl
::DoSetValue(const wxString
& value
, int flags
)
2094 // Don't call Clear here, since it always sends a text updated event
2095 m_buffer
.ResetAndClearCommands();
2096 m_buffer
.SetDirty(true);
2097 m_caretPosition
= -1;
2098 m_caretPositionForDefaultStyle
= -2;
2099 m_caretAtLineStart
= false;
2100 m_selectionRange
.SetRange(-2, -2);
2110 if (!value
.IsEmpty())
2112 // Remove empty paragraph
2113 GetBuffer().Clear();
2114 DoWriteText(value
, flags
);
2116 // for compatibility, don't move the cursor when doing SetValue()
2117 SetInsertionPoint(0);
2121 // still send an event for consistency
2122 if (flags
& SetValue_SendEvent
)
2123 wxTextCtrl
::SendTextUpdatedEvent(this);
2128 void wxRichTextCtrl
::WriteText(const wxString
& value
)
2133 void wxRichTextCtrl
::DoWriteText(const wxString
& value
, int flags
)
2135 wxString valueUnix
= wxTextFile
::Translate(value
, wxTextFileType_Unix
);
2137 GetBuffer().InsertTextWithUndo(m_caretPosition
+1, valueUnix
, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE
);
2139 if ( flags
& SetValue_SendEvent
)
2140 wxTextCtrl
::SendTextUpdatedEvent(this);
2143 void wxRichTextCtrl
::AppendText(const wxString
& text
)
2145 SetInsertionPointEnd();
2150 /// Write an image at the current insertion point
2151 bool wxRichTextCtrl
::WriteImage(const wxImage
& image
, int bitmapType
)
2153 wxRichTextImageBlock imageBlock
;
2155 wxImage image2
= image
;
2156 if (imageBlock
.MakeImageBlock(image2
, bitmapType
))
2157 return WriteImage(imageBlock
);
2162 bool wxRichTextCtrl
::WriteImage(const wxString
& filename
, int bitmapType
)
2164 wxRichTextImageBlock imageBlock
;
2167 if (imageBlock
.MakeImageBlock(filename
, bitmapType
, image
, false))
2168 return WriteImage(imageBlock
);
2173 bool wxRichTextCtrl
::WriteImage(const wxRichTextImageBlock
& imageBlock
)
2175 return GetBuffer().InsertImageWithUndo(m_caretPosition
+1, imageBlock
, this);
2178 bool wxRichTextCtrl
::WriteImage(const wxBitmap
& bitmap
, int bitmapType
)
2182 wxRichTextImageBlock imageBlock
;
2184 wxImage image
= bitmap
.ConvertToImage();
2185 if (image
.Ok() && imageBlock
.MakeImageBlock(image
, bitmapType
))
2186 return WriteImage(imageBlock
);
2192 /// Insert a newline (actually paragraph) at the current insertion point.
2193 bool wxRichTextCtrl
::Newline()
2195 return GetBuffer().InsertNewlineWithUndo(m_caretPosition
+1, this);
2198 /// Insert a line break at the current insertion point.
2199 bool wxRichTextCtrl
::LineBreak()
2202 text
= wxRichTextLineBreakChar
;
2203 return GetBuffer().InsertTextWithUndo(m_caretPosition
+1, text
, this);
2206 // ----------------------------------------------------------------------------
2207 // Clipboard operations
2208 // ----------------------------------------------------------------------------
2210 void wxRichTextCtrl
::Copy()
2214 wxRichTextRange range
= GetInternalSelectionRange();
2215 GetBuffer().CopyToClipboard(range
);
2219 void wxRichTextCtrl
::Cut()
2223 wxRichTextRange range
= GetInternalSelectionRange();
2224 GetBuffer().CopyToClipboard(range
);
2226 DeleteSelectedContent();
2232 void wxRichTextCtrl
::Paste()
2236 BeginBatchUndo(_("Paste"));
2238 long newPos
= m_caretPosition
;
2239 DeleteSelectedContent(& newPos
);
2241 GetBuffer().PasteFromClipboard(newPos
);
2247 void wxRichTextCtrl
::DeleteSelection()
2249 if (CanDeleteSelection())
2251 DeleteSelectedContent();
2255 bool wxRichTextCtrl
::HasSelection() const
2257 return m_selectionRange
.GetStart() != -2 && m_selectionRange
.GetEnd() != -2;
2260 bool wxRichTextCtrl
::CanCopy() const
2262 // Can copy if there's a selection
2263 return HasSelection();
2266 bool wxRichTextCtrl
::CanCut() const
2268 return HasSelection() && IsEditable();
2271 bool wxRichTextCtrl
::CanPaste() const
2273 if ( !IsEditable() )
2276 return GetBuffer().CanPasteFromClipboard();
2279 bool wxRichTextCtrl
::CanDeleteSelection() const
2281 return HasSelection() && IsEditable();
2285 // ----------------------------------------------------------------------------
2287 // ----------------------------------------------------------------------------
2289 void wxRichTextCtrl
::SetEditable(bool editable
)
2291 m_editable
= editable
;
2294 void wxRichTextCtrl
::SetInsertionPoint(long pos
)
2298 m_caretPosition
= pos
- 1;
2303 void wxRichTextCtrl
::SetInsertionPointEnd()
2305 long pos
= GetLastPosition();
2306 SetInsertionPoint(pos
);
2309 long wxRichTextCtrl
::GetInsertionPoint() const
2311 return m_caretPosition
+1;
2314 wxTextPos wxRichTextCtrl
::GetLastPosition() const
2316 return GetBuffer().GetRange().GetEnd();
2319 // If the return values from and to are the same, there is no
2321 void wxRichTextCtrl
::GetSelection(long* from
, long* to
) const
2323 *from
= m_selectionRange
.GetStart();
2324 *to
= m_selectionRange
.GetEnd();
2325 if ((*to
) != -1 && (*to
) != -2)
2329 bool wxRichTextCtrl
::IsEditable() const
2334 // ----------------------------------------------------------------------------
2336 // ----------------------------------------------------------------------------
2338 void wxRichTextCtrl
::SetSelection(long from
, long to
)
2340 // if from and to are both -1, it means (in wxWidgets) that all text should
2342 if ( (from
== -1) && (to
== -1) )
2345 to
= GetLastPosition()+1;
2348 DoSetSelection(from
, to
);
2349 SetDefaultStyleToCursorStyle();
2352 void wxRichTextCtrl
::DoSetSelection(long from
, long to
, bool WXUNUSED(scrollCaret
))
2360 m_selectionAnchor
= from
;
2361 m_selectionRange
.SetRange(from
, to
-1);
2363 m_caretPosition
= from
-1;
2370 // ----------------------------------------------------------------------------
2372 // ----------------------------------------------------------------------------
2374 void wxRichTextCtrl
::Replace(long WXUNUSED(from
), long WXUNUSED(to
),
2375 const wxString
& value
)
2377 BeginBatchUndo(_("Replace"));
2379 DeleteSelectedContent();
2381 DoWriteText(value
, SetValue_SelectionOnly
);
2386 void wxRichTextCtrl
::Remove(long from
, long to
)
2390 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(from
, to
-1), this);
2397 bool wxRichTextCtrl
::IsModified() const
2399 return m_buffer
.IsModified();
2402 void wxRichTextCtrl
::MarkDirty()
2404 m_buffer
.Modify(true);
2407 void wxRichTextCtrl
::DiscardEdits()
2409 m_caretPositionForDefaultStyle
= -2;
2410 m_buffer
.Modify(false);
2411 m_buffer
.GetCommandProcessor()->ClearCommands();
2414 int wxRichTextCtrl
::GetNumberOfLines() const
2416 return GetBuffer().GetParagraphCount();
2419 // ----------------------------------------------------------------------------
2420 // Positions <-> coords
2421 // ----------------------------------------------------------------------------
2423 long wxRichTextCtrl
::XYToPosition(long x
, long y
) const
2425 return GetBuffer().XYToPosition(x
, y
);
2428 bool wxRichTextCtrl
::PositionToXY(long pos
, long *x
, long *y
) const
2430 return GetBuffer().PositionToXY(pos
, x
, y
);
2433 // ----------------------------------------------------------------------------
2435 // ----------------------------------------------------------------------------
2437 void wxRichTextCtrl
::ShowPosition(long pos
)
2439 if (!IsPositionVisible(pos
))
2440 ScrollIntoView(pos
-1, WXK_DOWN
);
2443 int wxRichTextCtrl
::GetLineLength(long lineNo
) const
2445 return GetBuffer().GetParagraphLength(lineNo
);
2448 wxString wxRichTextCtrl
::GetLineText(long lineNo
) const
2450 return GetBuffer().GetParagraphText(lineNo
);
2453 // ----------------------------------------------------------------------------
2455 // ----------------------------------------------------------------------------
2457 void wxRichTextCtrl
::Undo()
2461 GetCommandProcessor()->Undo();
2465 void wxRichTextCtrl
::Redo()
2469 GetCommandProcessor()->Redo();
2473 bool wxRichTextCtrl
::CanUndo() const
2475 return GetCommandProcessor()->CanUndo();
2478 bool wxRichTextCtrl
::CanRedo() const
2480 return GetCommandProcessor()->CanRedo();
2483 // ----------------------------------------------------------------------------
2484 // implementation details
2485 // ----------------------------------------------------------------------------
2487 void wxRichTextCtrl
::Command(wxCommandEvent
& event
)
2489 SetValue(event
.GetString());
2490 GetEventHandler()->ProcessEvent(event
);
2493 void wxRichTextCtrl
::OnDropFiles(wxDropFilesEvent
& event
)
2495 // By default, load the first file into the text window.
2496 if (event
.GetNumberOfFiles() > 0)
2498 LoadFile(event
.GetFiles()[0]);
2502 wxSize wxRichTextCtrl
::DoGetBestSize() const
2504 return wxSize(10, 10);
2507 // ----------------------------------------------------------------------------
2508 // standard handlers for standard edit menu events
2509 // ----------------------------------------------------------------------------
2511 void wxRichTextCtrl
::OnCut(wxCommandEvent
& WXUNUSED(event
))
2516 void wxRichTextCtrl
::OnClear(wxCommandEvent
& WXUNUSED(event
))
2521 void wxRichTextCtrl
::OnCopy(wxCommandEvent
& WXUNUSED(event
))
2526 void wxRichTextCtrl
::OnPaste(wxCommandEvent
& WXUNUSED(event
))
2531 void wxRichTextCtrl
::OnUndo(wxCommandEvent
& WXUNUSED(event
))
2536 void wxRichTextCtrl
::OnRedo(wxCommandEvent
& WXUNUSED(event
))
2541 void wxRichTextCtrl
::OnUpdateCut(wxUpdateUIEvent
& event
)
2543 event
.Enable( CanCut() );
2546 void wxRichTextCtrl
::OnUpdateCopy(wxUpdateUIEvent
& event
)
2548 event
.Enable( CanCopy() );
2551 void wxRichTextCtrl
::OnUpdateClear(wxUpdateUIEvent
& event
)
2553 event
.Enable( CanDeleteSelection() );
2556 void wxRichTextCtrl
::OnUpdatePaste(wxUpdateUIEvent
& event
)
2558 event
.Enable( CanPaste() );
2561 void wxRichTextCtrl
::OnUpdateUndo(wxUpdateUIEvent
& event
)
2563 event
.Enable( CanUndo() );
2564 event
.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
2567 void wxRichTextCtrl
::OnUpdateRedo(wxUpdateUIEvent
& event
)
2569 event
.Enable( CanRedo() );
2570 event
.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
2573 void wxRichTextCtrl
::OnSelectAll(wxCommandEvent
& WXUNUSED(event
))
2578 void wxRichTextCtrl
::OnUpdateSelectAll(wxUpdateUIEvent
& event
)
2580 event
.Enable(GetLastPosition() > 0);
2583 void wxRichTextCtrl
::OnContextMenu(wxContextMenuEvent
& event
)
2585 if (event
.GetEventObject() != this)
2593 m_contextMenu
= new wxMenu
;
2594 m_contextMenu
->Append(wxID_UNDO
, _("&Undo"));
2595 m_contextMenu
->Append(wxID_REDO
, _("&Redo"));
2596 m_contextMenu
->AppendSeparator();
2597 m_contextMenu
->Append(wxID_CUT
, _("Cu&t"));
2598 m_contextMenu
->Append(wxID_COPY
, _("&Copy"));
2599 m_contextMenu
->Append(wxID_PASTE
, _("&Paste"));
2600 m_contextMenu
->Append(wxID_CLEAR
, _("&Delete"));
2601 m_contextMenu
->AppendSeparator();
2602 m_contextMenu
->Append(wxID_SELECTALL
, _("Select &All"));
2604 PopupMenu(m_contextMenu
);
2608 bool wxRichTextCtrl
::SetStyle(long start
, long end
, const wxTextAttr
& style
)
2610 return GetBuffer().SetStyle(wxRichTextRange(start
, end
-1), wxTextAttr(style
));
2613 bool wxRichTextCtrl
::SetStyle(const wxRichTextRange
& range
, const wxTextAttr
& style
)
2615 return GetBuffer().SetStyle(range
.ToInternal(), style
);
2618 // extended style setting operation with flags including:
2619 // wxRICHTEXT_SETSTYLE_WITH_UNDO, wxRICHTEXT_SETSTYLE_OPTIMIZE, wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY.
2620 // see richtextbuffer.h for more details.
2622 bool wxRichTextCtrl
::SetStyleEx(const wxRichTextRange
& range
, const wxTextAttr
& style
, int flags
)
2624 return GetBuffer().SetStyle(range
.ToInternal(), style
, flags
);
2627 bool wxRichTextCtrl
::SetDefaultStyle(const wxTextAttr
& style
)
2629 return GetBuffer().SetDefaultStyle(wxTextAttr(style
));
2632 const wxTextAttr
& wxRichTextCtrl
::GetDefaultStyle() const
2634 return GetBuffer().GetDefaultStyle();
2637 bool wxRichTextCtrl
::GetStyle(long position
, wxTextAttr
& style
)
2639 return GetBuffer().GetStyle(position
, style
);
2642 // get the common set of styles for the range
2643 bool wxRichTextCtrl
::GetStyleForRange(const wxRichTextRange
& range
, wxTextAttr
& style
)
2645 return GetBuffer().GetStyleForRange(range
.ToInternal(), style
);
2648 /// Get the content (uncombined) attributes for this position.
2649 bool wxRichTextCtrl
::GetUncombinedStyle(long position
, wxTextAttr
& style
)
2651 return GetBuffer().GetUncombinedStyle(position
, style
);
2654 /// Set font, and also the buffer attributes
2655 bool wxRichTextCtrl
::SetFont(const wxFont
& font
)
2657 wxControl
::SetFont(font
);
2659 wxTextAttr attr
= GetBuffer().GetAttributes();
2661 GetBuffer().SetBasicStyle(attr
);
2663 GetBuffer().Invalidate(wxRICHTEXT_ALL
);
2669 /// Transform logical to physical
2670 wxPoint wxRichTextCtrl
::GetPhysicalPoint(const wxPoint
& ptLogical
) const
2673 CalcScrolledPosition(ptLogical
.x
, ptLogical
.y
, & pt
.x
, & pt
.y
);
2678 /// Transform physical to logical
2679 wxPoint wxRichTextCtrl
::GetLogicalPoint(const wxPoint
& ptPhysical
) const
2682 CalcUnscrolledPosition(ptPhysical
.x
, ptPhysical
.y
, & pt
.x
, & pt
.y
);
2687 /// Position the caret
2688 void wxRichTextCtrl
::PositionCaret()
2693 //wxLogDebug(wxT("PositionCaret"));
2696 if (GetCaretPositionForIndex(GetCaretPosition(), caretRect
))
2698 wxPoint newPt
= caretRect
.GetPosition();
2699 wxSize newSz
= caretRect
.GetSize();
2700 wxPoint pt
= GetPhysicalPoint(newPt
);
2701 if (GetCaret()->GetPosition() != pt
|| GetCaret()->GetSize() != newSz
)
2703 GetCaret()->Move(pt
);
2704 GetCaret()->SetSize(newSz
);
2709 /// Get the caret height and position for the given character position
2710 bool wxRichTextCtrl
::GetCaretPositionForIndex(long position
, wxRect
& rect
)
2712 wxClientDC
dc(this);
2713 dc
.SetFont(GetFont());
2720 if (GetBuffer().FindPosition(dc
, position
, pt
, & height
, m_caretAtLineStart
))
2722 // Caret height can't be zero
2724 height
= dc
.GetCharHeight();
2726 rect
= wxRect(pt
, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH
, height
));
2733 /// Gets the line for the visible caret position. If the caret is
2734 /// shown at the very end of the line, it means the next character is actually
2735 /// on the following line. So let's get the line we're expecting to find
2736 /// if this is the case.
2737 wxRichTextLine
* wxRichTextCtrl
::GetVisibleLineForCaretPosition(long caretPosition
) const
2739 wxRichTextLine
* line
= GetBuffer().GetLineAtPosition(caretPosition
, true);
2740 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(caretPosition
, true);
2743 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
2744 if (caretPosition
== lineRange
.GetStart()-1 &&
2745 (para
->GetRange().GetStart() != lineRange
.GetStart()))
2747 if (!m_caretAtLineStart
)
2748 line
= GetBuffer().GetLineAtPosition(caretPosition
-1, true);
2755 /// Move the caret to the given character position
2756 bool wxRichTextCtrl
::MoveCaret(long pos
, bool showAtLineStart
)
2758 if (GetBuffer().GetDirty())
2761 if (pos
<= GetBuffer().GetRange().GetEnd())
2763 SetCaretPosition(pos
, showAtLineStart
);
2773 /// Layout the buffer: which we must do before certain operations, such as
2774 /// setting the caret position.
2775 bool wxRichTextCtrl
::LayoutContent(bool onlyVisibleRect
)
2777 if (GetBuffer().GetDirty() || onlyVisibleRect
)
2779 wxRect
availableSpace(GetClientSize());
2780 if (availableSpace
.width
== 0)
2781 availableSpace
.width
= 10;
2782 if (availableSpace
.height
== 0)
2783 availableSpace
.height
= 10;
2785 int flags
= wxRICHTEXT_FIXED_WIDTH
|wxRICHTEXT_VARIABLE_HEIGHT
;
2786 if (onlyVisibleRect
)
2788 flags
|= wxRICHTEXT_LAYOUT_SPECIFIED_RECT
;
2789 availableSpace
.SetPosition(GetLogicalPoint(wxPoint(0, 0)));
2792 wxClientDC
dc(this);
2793 dc
.SetFont(GetFont());
2797 GetBuffer().Defragment();
2798 GetBuffer().UpdateRanges(); // If items were deleted, ranges need recalculation
2799 GetBuffer().Layout(dc
, availableSpace
, flags
);
2800 GetBuffer().SetDirty(false);
2809 /// Is all of the selection bold?
2810 bool wxRichTextCtrl
::IsSelectionBold()
2815 wxRichTextRange range
= GetSelectionRange();
2816 attr
.SetFlags(wxTEXT_ATTR_FONT_WEIGHT
);
2817 attr
.SetFontWeight(wxBOLD
);
2819 return HasCharacterAttributes(range
, attr
);
2823 // If no selection, then we need to combine current style with default style
2824 // to see what the effect would be if we started typing.
2826 attr
.SetFlags(wxTEXT_ATTR_FONT_WEIGHT
);
2828 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
2829 if (GetStyle(pos
, attr
))
2831 if (IsDefaultStyleShowing())
2832 wxRichTextApplyStyle(attr
, GetDefaultStyleEx());
2833 return attr
.GetFontWeight() == wxBOLD
;
2839 /// Is all of the selection italics?
2840 bool wxRichTextCtrl
::IsSelectionItalics()
2844 wxRichTextRange range
= GetSelectionRange();
2846 attr
.SetFlags(wxTEXT_ATTR_FONT_ITALIC
);
2847 attr
.SetFontStyle(wxITALIC
);
2849 return HasCharacterAttributes(range
, attr
);
2853 // If no selection, then we need to combine current style with default style
2854 // to see what the effect would be if we started typing.
2856 attr
.SetFlags(wxTEXT_ATTR_FONT_ITALIC
);
2858 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
2859 if (GetStyle(pos
, attr
))
2861 if (IsDefaultStyleShowing())
2862 wxRichTextApplyStyle(attr
, GetDefaultStyleEx());
2863 return attr
.GetFontStyle() == wxITALIC
;
2869 /// Is all of the selection underlined?
2870 bool wxRichTextCtrl
::IsSelectionUnderlined()
2874 wxRichTextRange range
= GetSelectionRange();
2876 attr
.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE
);
2877 attr
.SetFontUnderlined(true);
2879 return HasCharacterAttributes(range
, attr
);
2883 // If no selection, then we need to combine current style with default style
2884 // to see what the effect would be if we started typing.
2886 attr
.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE
);
2887 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
2889 if (GetStyle(pos
, attr
))
2891 if (IsDefaultStyleShowing())
2892 wxRichTextApplyStyle(attr
, GetDefaultStyleEx());
2893 return attr
.GetFontUnderlined();
2899 /// Apply bold to the selection
2900 bool wxRichTextCtrl
::ApplyBoldToSelection()
2903 attr
.SetFlags(wxTEXT_ATTR_FONT_WEIGHT
);
2904 attr
.SetFontWeight(IsSelectionBold() ? wxNORMAL
: wxBOLD
);
2907 return SetStyleEx(GetSelectionRange(), attr
, wxRICHTEXT_SETSTYLE_WITH_UNDO
|wxRICHTEXT_SETSTYLE_OPTIMIZE
|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY
);
2910 wxRichTextAttr current
= GetDefaultStyleEx();
2911 current
.Apply(attr
);
2912 SetAndShowDefaultStyle(current
);
2917 /// Apply italic to the selection
2918 bool wxRichTextCtrl
::ApplyItalicToSelection()
2921 attr
.SetFlags(wxTEXT_ATTR_FONT_ITALIC
);
2922 attr
.SetFontStyle(IsSelectionItalics() ? wxNORMAL
: wxITALIC
);
2925 return SetStyleEx(GetSelectionRange(), attr
, wxRICHTEXT_SETSTYLE_WITH_UNDO
|wxRICHTEXT_SETSTYLE_OPTIMIZE
|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY
);
2928 wxRichTextAttr current
= GetDefaultStyleEx();
2929 current
.Apply(attr
);
2930 SetAndShowDefaultStyle(current
);
2935 /// Apply underline to the selection
2936 bool wxRichTextCtrl
::ApplyUnderlineToSelection()
2939 attr
.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE
);
2940 attr
.SetFontUnderlined(!IsSelectionUnderlined());
2943 return SetStyleEx(GetSelectionRange(), attr
, wxRICHTEXT_SETSTYLE_WITH_UNDO
|wxRICHTEXT_SETSTYLE_OPTIMIZE
|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY
);
2946 wxRichTextAttr current
= GetDefaultStyleEx();
2947 current
.Apply(attr
);
2948 SetAndShowDefaultStyle(current
);
2953 /// Is all of the selection aligned according to the specified flag?
2954 bool wxRichTextCtrl
::IsSelectionAligned(wxTextAttrAlignment alignment
)
2956 wxRichTextRange range
;
2958 range
= GetSelectionRange();
2960 range
= wxRichTextRange(GetCaretPosition()+1, GetCaretPosition()+2);
2963 attr
.SetAlignment(alignment
);
2965 return HasParagraphAttributes(range
, attr
);
2968 /// Apply alignment to the selection
2969 bool wxRichTextCtrl
::ApplyAlignmentToSelection(wxTextAttrAlignment alignment
)
2972 attr
.SetAlignment(alignment
);
2974 return SetStyle(GetSelectionRange(), attr
);
2977 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2979 return SetStyleEx(para
->GetRange().FromInternal(), attr
, wxRICHTEXT_SETSTYLE_WITH_UNDO
|wxRICHTEXT_SETSTYLE_OPTIMIZE
|wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY
);
2984 /// Apply a named style to the selection
2985 bool wxRichTextCtrl
::ApplyStyle(wxRichTextStyleDefinition
* def
)
2987 // Flags are defined within each definition, so only certain
2988 // attributes are applied.
2989 wxTextAttr
attr(GetStyleSheet() ? def
->GetStyleMergedWithBase(GetStyleSheet()) : def
->GetStyle());
2991 int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
|wxRICHTEXT_SETSTYLE_OPTIMIZE
|wxRICHTEXT_SETSTYLE_RESET
;
2993 if (def
->IsKindOf(CLASSINFO(wxRichTextListStyleDefinition
)))
2995 flags
|= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY
;
2997 wxRichTextRange range
;
3000 range
= GetSelectionRange();
3003 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
3004 range
= wxRichTextRange(pos
, pos
+1);
3007 return SetListStyle(range
, (wxRichTextListStyleDefinition
*) def
, flags
);
3010 // Make sure the attr has the style name
3011 if (def
->IsKindOf(CLASSINFO(wxRichTextParagraphStyleDefinition
)))
3013 attr
.SetParagraphStyleName(def
->GetName());
3015 // If applying a paragraph style, we only want the paragraph nodes to adopt these
3016 // attributes, and not the leaf nodes. This will allow the content (e.g. text)
3017 // to change its style independently.
3018 flags
|= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY
;
3021 attr
.SetCharacterStyleName(def
->GetName());
3024 return SetStyleEx(GetSelectionRange(), attr
, flags
);
3027 wxRichTextAttr current
= GetDefaultStyleEx();
3028 current
.Apply(attr
);
3029 SetAndShowDefaultStyle(current
);
3034 /// Apply the style sheet to the buffer, for example if the styles have changed.
3035 bool wxRichTextCtrl
::ApplyStyleSheet(wxRichTextStyleSheet
* styleSheet
)
3038 styleSheet
= GetBuffer().GetStyleSheet();
3042 if (GetBuffer().ApplyStyleSheet(styleSheet
))
3044 GetBuffer().Invalidate(wxRICHTEXT_ALL
);
3052 /// Sets the default style to the style under the cursor
3053 bool wxRichTextCtrl
::SetDefaultStyleToCursorStyle()
3056 attr
.SetFlags(wxTEXT_ATTR_CHARACTER
);
3058 // If at the start of a paragraph, use the next position.
3059 long pos
= GetAdjustedCaretPosition(GetCaretPosition());
3061 if (GetUncombinedStyle(pos
, attr
))
3063 SetDefaultStyle(attr
);
3070 /// Returns the first visible position in the current view
3071 long wxRichTextCtrl
::GetFirstVisiblePosition() const
3073 wxRichTextLine
* line
= GetBuffer().GetLineAtYPosition(GetLogicalPoint(wxPoint(0, 0)).y
);
3075 return line
->GetAbsoluteRange().GetStart();
3080 /// Get the first visible point in the window
3081 wxPoint wxRichTextCtrl
::GetFirstVisiblePoint() const
3084 int startXUnits
, startYUnits
;
3086 GetScrollPixelsPerUnit(& ppuX
, & ppuY
);
3087 GetViewStart(& startXUnits
, & startYUnits
);
3089 return wxPoint(startXUnits
* ppuX
, startYUnits
* ppuY
);
3092 /// The adjusted caret position is the character position adjusted to take
3093 /// into account whether we're at the start of a paragraph, in which case
3094 /// style information should be taken from the next position, not current one.
3095 long wxRichTextCtrl
::GetAdjustedCaretPosition(long caretPos
) const
3097 wxRichTextParagraph
* para
= GetBuffer().GetParagraphAtPosition(caretPos
+1);
3099 if (para
&& (caretPos
+1 == para
->GetRange().GetStart()))
3104 /// Get/set the selection range in character positions. -1, -1 means no selection.
3105 /// The range is in API convention, i.e. a single character selection is denoted
3107 wxRichTextRange wxRichTextCtrl
::GetSelectionRange() const
3109 wxRichTextRange range
= GetInternalSelectionRange();
3110 if (range
!= wxRichTextRange(-2,-2) && range
!= wxRichTextRange(-1,-1))
3111 range
.SetEnd(range
.GetEnd() + 1);
3115 void wxRichTextCtrl
::SetSelectionRange(const wxRichTextRange
& range
)
3117 wxRichTextRange
range1(range
);
3118 if (range1
!= wxRichTextRange(-2,-2) && range1
!= wxRichTextRange(-1,-1) )
3119 range1
.SetEnd(range1
.GetEnd() - 1);
3121 wxASSERT( range1
.GetStart() > range1
.GetEnd() );
3123 SetInternalSelectionRange(range1
);
3127 bool wxRichTextCtrl
::SetListStyle(const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
, int flags
, int startFrom
, int specifiedLevel
)
3129 return GetBuffer().SetListStyle(range
.ToInternal(), def
, flags
, startFrom
, specifiedLevel
);
3132 bool wxRichTextCtrl
::SetListStyle(const wxRichTextRange
& range
, const wxString
& defName
, int flags
, int startFrom
, int specifiedLevel
)
3134 return GetBuffer().SetListStyle(range
.ToInternal(), defName
, flags
, startFrom
, specifiedLevel
);
3137 /// Clear list for given range
3138 bool wxRichTextCtrl
::ClearListStyle(const wxRichTextRange
& range
, int flags
)
3140 return GetBuffer().ClearListStyle(range
.ToInternal(), flags
);
3143 /// Number/renumber any list elements in the given range
3144 bool wxRichTextCtrl
::NumberList(const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
, int flags
, int startFrom
, int specifiedLevel
)
3146 return GetBuffer().NumberList(range
.ToInternal(), def
, flags
, startFrom
, specifiedLevel
);
3149 bool wxRichTextCtrl
::NumberList(const wxRichTextRange
& range
, const wxString
& defName
, int flags
, int startFrom
, int specifiedLevel
)
3151 return GetBuffer().NumberList(range
.ToInternal(), defName
, flags
, startFrom
, specifiedLevel
);
3154 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
3155 bool wxRichTextCtrl
::PromoteList(int promoteBy
, const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
, int flags
, int specifiedLevel
)
3157 return GetBuffer().PromoteList(promoteBy
, range
.ToInternal(), def
, flags
, specifiedLevel
);
3160 bool wxRichTextCtrl
::PromoteList(int promoteBy
, const wxRichTextRange
& range
, const wxString
& defName
, int flags
, int specifiedLevel
)
3162 return GetBuffer().PromoteList(promoteBy
, range
.ToInternal(), defName
, flags
, specifiedLevel
);
3165 /// Deletes the content in the given range
3166 bool wxRichTextCtrl
::Delete(const wxRichTextRange
& range
)
3168 return GetBuffer().DeleteRangeWithUndo(range
.ToInternal(), this);
3171 const wxArrayString
& wxRichTextCtrl
::GetAvailableFontNames()
3173 if (sm_availableFontNames
.GetCount() == 0)
3175 sm_availableFontNames
= wxFontEnumerator
::GetFacenames();
3176 sm_availableFontNames
.Sort();
3178 return sm_availableFontNames
;
3181 void wxRichTextCtrl
::ClearAvailableFontNames()
3183 sm_availableFontNames
.Clear();
3186 void wxRichTextCtrl
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3188 //wxLogDebug(wxT("wxRichTextCtrl::OnSysColourChanged"));
3190 wxTextAttrEx basicStyle
= GetBasicStyle();
3191 basicStyle
.SetTextColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
3192 SetBasicStyle(basicStyle
);
3193 SetBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
));