]> git.saurik.com Git - wxWidgets.git/blame - src/richtext/richtextctrl.cpp
clean - reformatting
[wxWidgets.git] / src / richtext / richtextctrl.cpp
CommitLineData
5d7836c4 1/////////////////////////////////////////////////////////////////////////////
7fe8059f 2// Name: richtext/richeditctrl.cpp
5d7836c4
JS
3// Purpose: A rich edit control
4// Author: Julian Smart
7fe8059f 5// Modified by:
5d7836c4 6// Created: 2005-09-30
7fe8059f 7// RCS-ID: $Id$
5d7836c4
JS
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
b01ca8b6
JS
19#if wxUSE_RICHTEXT
20
21#include "wx/richtext/richtextctrl.h"
22
5d7836c4
JS
23#ifndef WX_PRECOMP
24 #include "wx/wx.h"
25#endif
26
5d7836c4
JS
27#include "wx/textfile.h"
28#include "wx/ffile.h"
29#include "wx/settings.h"
30#include "wx/filename.h"
31#include "wx/dcbuffer.h"
5d7836c4
JS
32#include "wx/arrimpl.cpp"
33
34DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED)
35DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED)
36DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK)
37DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK)
38DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK)
39DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK)
40DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RETURN)
41
42#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
43IMPLEMENT_CLASS( wxRichTextCtrl, wxControl )
44#else
45IMPLEMENT_CLASS( wxRichTextCtrl, wxScrolledWindow )
46#endif
47
48IMPLEMENT_CLASS( wxRichTextEvent, wxNotifyEvent )
49
50#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
51BEGIN_EVENT_TABLE( wxRichTextCtrl, wxControl )
52#else
53BEGIN_EVENT_TABLE( wxRichTextCtrl, wxScrolledWindow )
54#endif
55 EVT_PAINT(wxRichTextCtrl::OnPaint)
56 EVT_ERASE_BACKGROUND(wxRichTextCtrl::OnEraseBackground)
4d551ad5 57 EVT_IDLE(wxRichTextCtrl::OnIdle)
c59f6793 58 EVT_SCROLLWIN(wxRichTextCtrl::OnScroll)
5d7836c4
JS
59 EVT_LEFT_DOWN(wxRichTextCtrl::OnLeftClick)
60 EVT_MOTION(wxRichTextCtrl::OnMoveMouse)
61 EVT_LEFT_UP(wxRichTextCtrl::OnLeftUp)
62 EVT_RIGHT_DOWN(wxRichTextCtrl::OnRightClick)
63 EVT_MIDDLE_DOWN(wxRichTextCtrl::OnMiddleClick)
64 EVT_LEFT_DCLICK(wxRichTextCtrl::OnLeftDClick)
65 EVT_CHAR(wxRichTextCtrl::OnChar)
66 EVT_SIZE(wxRichTextCtrl::OnSize)
67 EVT_SET_FOCUS(wxRichTextCtrl::OnSetFocus)
68 EVT_KILL_FOCUS(wxRichTextCtrl::OnKillFocus)
69 EVT_CONTEXT_MENU(wxRichTextCtrl::OnContextMenu)
70
71 EVT_MENU(wxID_UNDO, wxRichTextCtrl::OnUndo)
72 EVT_UPDATE_UI(wxID_UNDO, wxRichTextCtrl::OnUpdateUndo)
73
74 EVT_MENU(wxID_REDO, wxRichTextCtrl::OnRedo)
75 EVT_UPDATE_UI(wxID_REDO, wxRichTextCtrl::OnUpdateRedo)
76
77 EVT_MENU(wxID_COPY, wxRichTextCtrl::OnCopy)
78 EVT_UPDATE_UI(wxID_COPY, wxRichTextCtrl::OnUpdateCopy)
79
80 EVT_MENU(wxID_PASTE, wxRichTextCtrl::OnPaste)
81 EVT_UPDATE_UI(wxID_PASTE, wxRichTextCtrl::OnUpdatePaste)
82
83 EVT_MENU(wxID_CUT, wxRichTextCtrl::OnCut)
84 EVT_UPDATE_UI(wxID_CUT, wxRichTextCtrl::OnUpdateCut)
85
86 EVT_MENU(wxID_CLEAR, wxRichTextCtrl::OnClear)
87 EVT_UPDATE_UI(wxID_CLEAR, wxRichTextCtrl::OnUpdateClear)
88
89 EVT_MENU(wxID_SELECTALL, wxRichTextCtrl::OnSelectAll)
90 EVT_UPDATE_UI(wxID_SELECTALL, wxRichTextCtrl::OnUpdateSelectAll)
91END_EVENT_TABLE()
92
93/*!
94 * wxRichTextCtrl
95 */
96
97wxRichTextCtrl::wxRichTextCtrl()
98#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
99 : wxScrollHelper(this)
100#endif
101{
102 Init();
103}
104
105wxRichTextCtrl::wxRichTextCtrl( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
106#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
107 : wxScrollHelper(this)
108#endif
109{
110 Init();
111 Create(parent, id, pos, size, style);
112}
113
114/// Creation
115bool wxRichTextCtrl::Create( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
116{
117#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
118 if (!wxTextCtrlBase::Create(parent, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE
119 ))
120 return false;
121#else
122 if (!wxScrolledWindow::Create(parent, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE
123 ))
124 return false;
125#endif
126
127 if (!GetFont().Ok())
128 {
129 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
130 }
7fe8059f 131
5d7836c4
JS
132 GetBuffer().SetRichTextCtrl(this);
133
134 wxTextAttrEx attributes;
135 attributes.SetFont(GetFont());
136 attributes.SetTextColour(*wxBLACK);
137 attributes.SetBackgroundColour(*wxWHITE);
138 attributes.SetAlignment(wxTEXT_ALIGNMENT_LEFT);
139 attributes.SetFlags(wxTEXT_ATTR_ALL);
140
141 SetDefaultStyle(attributes);
142 SetBasicStyle(attributes);
143
7fe8059f 144 SetBackgroundColour(*wxWHITE);
5d7836c4
JS
145 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
146
7fe8059f 147 // Tell the sizers to use the given or best size
5d7836c4 148 SetBestFittingSize(size);
7fe8059f 149
5d7836c4
JS
150 // Create a buffer
151 RecreateBuffer(size);
152
5d7836c4 153 SetCursor(wxCursor(wxCURSOR_IBEAM));
7fe8059f 154
5d7836c4
JS
155 return true;
156}
157
158wxRichTextCtrl::~wxRichTextCtrl()
159{
160 delete m_contextMenu;
161}
162
163/// Member initialisation
164void wxRichTextCtrl::Init()
165{
166 m_freezeCount = 0;
167 m_contextMenu = NULL;
168 m_caret = NULL;
169 m_caretPosition = -1;
170 m_selectionRange.SetRange(-2, -2);
171 m_selectionAnchor = -2;
172 m_editable = true;
173 m_caretAtLineStart = false;
174 m_dragging = false;
4d551ad5
JS
175 m_fullLayoutRequired = false;
176 m_fullLayoutTime = 0;
177 m_fullLayoutSavedPosition = 0;
178 m_delayedLayoutThreshold = wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD;
5d7836c4
JS
179}
180
181/// Call Freeze to prevent refresh
182void wxRichTextCtrl::Freeze()
183{
184 m_freezeCount ++;
185}
186
187/// Call Thaw to refresh
0bab774b 188void wxRichTextCtrl::Thaw()
5d7836c4
JS
189{
190 m_freezeCount --;
191
0bab774b 192 if (m_freezeCount == 0)
5d7836c4
JS
193 {
194 SetupScrollbars();
76bcd815 195 Refresh(false);
5d7836c4
JS
196 }
197}
198
199/// Clear all text
200void wxRichTextCtrl::Clear()
201{
202 m_buffer.Reset();
203 m_buffer.SetDirty(true);
204 m_caretPosition = -1;
205 m_caretAtLineStart = false;
206 m_selectionRange.SetRange(-2, -2);
207
208 if (m_freezeCount == 0)
209 {
210 SetupScrollbars();
76bcd815 211 Refresh(false);
5d7836c4
JS
212 }
213 SendUpdateEvent();
214}
215
216/// Painting
217void wxRichTextCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
218{
d2142335
JS
219 if (GetCaret())
220 GetCaret()->Hide();
221
5d7836c4 222 {
c59f6793
JS
223 wxBufferedPaintDC dc(this, m_bufferBitmap);
224 //wxLogDebug(wxT("OnPaint"));
41e155b4 225
c59f6793 226 PrepareDC(dc);
41e155b4 227
c59f6793
JS
228 if (m_freezeCount > 0)
229 return;
41e155b4 230
c59f6793 231 dc.SetFont(GetFont());
41e155b4 232
c59f6793
JS
233 // Paint the background
234 PaintBackground(dc);
41e155b4 235
c59f6793 236 wxRegion dirtyRegion = GetUpdateRegion();
41e155b4 237
c59f6793
JS
238 wxRect drawingArea(GetLogicalPoint(wxPoint(0, 0)), GetClientSize());
239 wxRect availableSpace(GetClientSize());
240 if (GetBuffer().GetDirty())
241 {
242 GetBuffer().Layout(dc, availableSpace, wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT);
243 GetBuffer().SetDirty(false);
244 SetupScrollbars();
245 }
41e155b4 246
c59f6793 247 GetBuffer().Draw(dc, GetBuffer().GetRange(), GetSelectionRange(), drawingArea, 0 /* descent */, 0 /* flags */);
5d7836c4 248 }
d2142335
JS
249
250 if (GetCaret())
251 GetCaret()->Show();
252
7383cf9d 253 PositionCaret();
5d7836c4
JS
254}
255
256// Empty implementation, to prevent flicker
257void wxRichTextCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
258{
259}
260
261void wxRichTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
262{
c59f6793
JS
263 wxCaret* caret = new wxCaret(this, wxRICHTEXT_DEFAULT_CARET_WIDTH, 16);
264 SetCaret(caret);
265 caret->Show();
266 PositionCaret();
267
5d7836c4 268 if (!IsFrozen())
76bcd815 269 Refresh(false);
5d7836c4
JS
270}
271
272void wxRichTextCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
273{
c59f6793
JS
274 SetCaret(NULL);
275
5d7836c4 276 if (!IsFrozen())
76bcd815 277 Refresh(false);
5d7836c4
JS
278}
279
280/// Left-click
281void wxRichTextCtrl::OnLeftClick(wxMouseEvent& event)
282{
283 SetFocus();
284
285 wxClientDC dc(this);
286 PrepareDC(dc);
287 dc.SetFont(GetFont());
7fe8059f 288
5d7836c4
JS
289 long position = 0;
290 int hit = GetBuffer().HitTest(dc, event.GetLogicalPosition(dc), position);
291
292 if (hit != wxRICHTEXT_HITTEST_NONE)
293 {
294 m_dragStart = event.GetLogicalPosition(dc);
295 m_dragging = true;
296 CaptureMouse();
297
298 SelectNone();
299
300 bool caretAtLineStart = false;
301
302 if (hit & wxRICHTEXT_HITTEST_BEFORE)
303 {
304 // If we're at the start of a line (but not first in para)
305 // then we should keep the caret showing at the start of the line
306 // by showing the m_caretAtLineStart flag.
307 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
308 wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
309
1e967276 310 if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
5d7836c4
JS
311 caretAtLineStart = true;
312 position --;
313 }
314
315 MoveCaret(position, caretAtLineStart);
316 SetDefaultStyleToCursorStyle();
317
318#if 0
319 wxWindow* p = GetParent();
320 while (p && !p->IsKindOf(CLASSINFO(wxFrame)))
321 p = p->GetParent();
322
323 wxFrame* frame = wxDynamicCast(p, wxFrame);
324 if (frame)
325 {
326 wxString msg = wxString::Format(wxT("Found position %ld"), position);
327 frame->SetStatusText(msg, 1);
328 }
329#endif
330 }
331
332 event.Skip();
333}
334
335/// Left-up
336void wxRichTextCtrl::OnLeftUp(wxMouseEvent& WXUNUSED(event))
337{
338 if (m_dragging)
339 {
340 m_dragging = false;
341 if (GetCapture() == this)
342 ReleaseMouse();
343 }
344}
345
346/// Left-click
347void wxRichTextCtrl::OnMoveMouse(wxMouseEvent& event)
348{
349 if (!event.Dragging())
350 {
351 event.Skip();
352 return;
353 }
354
355 wxClientDC dc(this);
356 PrepareDC(dc);
357 dc.SetFont(GetFont());
7fe8059f 358
5d7836c4
JS
359 long position = 0;
360 wxPoint logicalPt = event.GetLogicalPosition(dc);
361 int hit = GetBuffer().HitTest(dc, logicalPt, position);
362
363 if (m_dragging && hit != wxRICHTEXT_HITTEST_NONE)
364 {
365 // TODO: test closeness
366
367 bool caretAtLineStart = false;
368
369 if (hit & wxRICHTEXT_HITTEST_BEFORE)
370 {
371 // If we're at the start of a line (but not first in para)
372 // then we should keep the caret showing at the start of the line
373 // by showing the m_caretAtLineStart flag.
374 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
375 wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
376
1e967276 377 if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
5d7836c4
JS
378 caretAtLineStart = true;
379 position --;
380 }
381
382 if (m_caretPosition != position)
383 {
384 bool extendSel = ExtendSelection(m_caretPosition, position, wxRICHTEXT_SHIFT_DOWN);
7fe8059f 385
5d7836c4
JS
386 MoveCaret(position, caretAtLineStart);
387 SetDefaultStyleToCursorStyle();
7fe8059f 388
5d7836c4 389 if (extendSel)
76bcd815 390 Refresh(false);
5d7836c4
JS
391 }
392 }
393}
394
395/// Right-click
396void wxRichTextCtrl::OnRightClick(wxMouseEvent& event)
397{
398 SetFocus();
399 event.Skip();
400}
401
402/// Left-double-click
403void wxRichTextCtrl::OnLeftDClick(wxMouseEvent& event)
404{
405 event.Skip();
406}
407
408/// Middle-click
409void wxRichTextCtrl::OnMiddleClick(wxMouseEvent& event)
410{
411 event.Skip();
412}
413
414/// Key press
415void wxRichTextCtrl::OnChar(wxKeyEvent& event)
416{
417 int flags = 0;
418 if (event.ControlDown())
419 flags |= wxRICHTEXT_CTRL_DOWN;
420 if (event.ShiftDown())
421 flags |= wxRICHTEXT_SHIFT_DOWN;
422 if (event.AltDown())
423 flags |= wxRICHTEXT_ALT_DOWN;
424
425 if (event.GetKeyCode() == WXK_LEFT ||
426 event.GetKeyCode() == WXK_RIGHT ||
427 event.GetKeyCode() == WXK_UP ||
428 event.GetKeyCode() == WXK_DOWN ||
429 event.GetKeyCode() == WXK_HOME ||
430 event.GetKeyCode() == WXK_PAGEUP ||
431 event.GetKeyCode() == WXK_PAGEDOWN ||
432 event.GetKeyCode() == WXK_PRIOR ||
433 event.GetKeyCode() == WXK_NEXT ||
434 event.GetKeyCode() == WXK_END)
435 {
0bab774b 436 KeyboardNavigate(event.GetKeyCode(), flags);
5d7836c4
JS
437 }
438 else if (event.GetKeyCode() == WXK_RETURN)
439 {
440 BeginBatchUndo(_("Insert Text"));
441
442 long newPos = m_caretPosition;
443
444 DeleteSelectedContent(& newPos);
445
446 GetBuffer().InsertNewlineWithUndo(newPos+1, this);
447
448 wxRichTextEvent cmdEvent(
449 wxEVT_COMMAND_RICHTEXT_RETURN,
450 GetId());
451 cmdEvent.SetEventObject(this);
452 cmdEvent.SetFlags(flags);
453 GetEventHandler()->ProcessEvent(cmdEvent);
454
455 EndBatchUndo();
456 SetDefaultStyleToCursorStyle();
f9ed2d16
JS
457
458 ScrollIntoView(m_caretPosition, WXK_RIGHT);
5d7836c4
JS
459 }
460 else if (event.GetKeyCode() == WXK_BACK)
461 {
462 BeginBatchUndo(_("Delete Text"));
463
464 // Submit range in character positions, which are greater than caret positions,
465 // so subtract 1 for deleted character and add 1 for conversion to character position.
466 if (m_caretPosition > -1 && !HasSelection())
467 {
468 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition, m_caretPosition),
469 m_caretPosition, // Current caret position
470 m_caretPosition-1, // New caret position
471 this);
472 }
473 else
474 DeleteSelectedContent();
475
476 EndBatchUndo();
477
478 // Shouldn't this be in Do()?
479 if (GetLastPosition() == -1)
480 {
481 GetBuffer().Reset();
482
483 m_caretPosition = -1;
484 PositionCaret();
485 SetDefaultStyleToCursorStyle();
486 }
487
f9ed2d16 488 ScrollIntoView(m_caretPosition, WXK_LEFT);
5d7836c4
JS
489 }
490 else if (event.GetKeyCode() == WXK_DELETE)
491 {
492 BeginBatchUndo(_("Delete Text"));
493
494 // Submit range in character positions, which are greater than caret positions,
495 if (m_caretPosition < GetBuffer().GetRange().GetEnd()+1 && !HasSelection())
496 {
497 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition+1, m_caretPosition+1),
498 m_caretPosition, // Current caret position
499 m_caretPosition+1, // New caret position
500 this);
501 }
502 else
503 DeleteSelectedContent();
504
505 EndBatchUndo();
506
507 // Shouldn't this be in Do()?
508 if (GetLastPosition() == -1)
509 {
510 GetBuffer().Reset();
511
512 m_caretPosition = -1;
513 PositionCaret();
514 SetDefaultStyleToCursorStyle();
515 }
516 }
517 else
518 {
519 BeginBatchUndo(_("Insert Text"));
520
521 long newPos = m_caretPosition;
522 DeleteSelectedContent(& newPos);
523
524 wxString str = (wxChar) event.GetKeyCode();
525 GetBuffer().InsertTextWithUndo(newPos+1, str, this);
526
527 EndBatchUndo();
528
529 SetDefaultStyleToCursorStyle();
f9ed2d16 530 ScrollIntoView(m_caretPosition, WXK_RIGHT);
5d7836c4
JS
531 }
532#if 0
533 else
534 event.Skip();
535#endif
536}
537
538/// Delete content if there is a selection, e.g. when pressing a key.
539bool wxRichTextCtrl::DeleteSelectedContent(long* newPos)
540{
541 if (HasSelection())
542 {
543 long pos = m_selectionRange.GetStart();
544 GetBuffer().DeleteRangeWithUndo(m_selectionRange,
545 m_caretPosition, // Current caret position
546 pos, // New caret position
547 this);
548 m_selectionRange.SetRange(-2, -2);
549
550 if (newPos)
551 *newPos = pos-1;
552 return true;
553 }
554 else
555 return false;
556}
557
558/// Keyboard navigation
559
560/*
561
562Left: left one character
563Right: right one character
564Up: up one line
565Down: down one line
566Ctrl-Left: left one word
567Ctrl-Right: right one word
568Ctrl-Up: previous paragraph start
569Ctrl-Down: next start of paragraph
570Home: start of line
571End: end of line
572Ctrl-Home: start of document
573Ctrl-End: end of document
574Page-Up: Up a screen
575Page-Down: Down a screen
576
577Maybe:
578
579Ctrl-Alt-PgUp: Start of window
580Ctrl-Alt-PgDn: End of window
581F8: Start selection mode
582Esc: End selection mode
583
584Adding Shift does the above but starts/extends selection.
585
586
587 */
588
0bab774b 589bool wxRichTextCtrl::KeyboardNavigate(int keyCode, int flags)
5d7836c4
JS
590{
591 bool success = false;
5d7836c4
JS
592
593 if (keyCode == WXK_RIGHT)
594 {
595 if (flags & wxRICHTEXT_CTRL_DOWN)
596 success = WordRight(1, flags);
597 else
598 success = MoveRight(1, flags);
599 }
600 else if (keyCode == WXK_LEFT)
601 {
602 if (flags & wxRICHTEXT_CTRL_DOWN)
603 success = WordLeft(1, flags);
604 else
605 success = MoveLeft(1, flags);
606 }
607 else if (keyCode == WXK_UP)
608 {
609 if (flags & wxRICHTEXT_CTRL_DOWN)
610 success = MoveToParagraphStart(flags);
611 else
612 success = MoveUp(1, flags);
613 }
614 else if (keyCode == WXK_DOWN)
615 {
616 if (flags & wxRICHTEXT_CTRL_DOWN)
617 success = MoveToParagraphEnd(flags);
618 else
619 success = MoveDown(1, flags);
620 }
621 else if (keyCode == WXK_PAGEUP || keyCode == WXK_PRIOR)
622 {
623 success = PageUp(1, flags);
624 }
625 else if (keyCode == WXK_PAGEDOWN || keyCode == WXK_NEXT)
626 {
627 success = PageDown(1, flags);
628 }
629 else if (keyCode == WXK_HOME)
630 {
631 if (flags & wxRICHTEXT_CTRL_DOWN)
632 success = MoveHome(flags);
633 else
634 success = MoveToLineStart(flags);
635 }
636 else if (keyCode == WXK_END)
637 {
638 if (flags & wxRICHTEXT_CTRL_DOWN)
639 success = MoveEnd(flags);
640 else
641 success = MoveToLineEnd(flags);
642 }
643
644 if (success)
645 {
646 ScrollIntoView(m_caretPosition, keyCode);
647 SetDefaultStyleToCursorStyle();
648 }
649
5d7836c4
JS
650 return success;
651}
652
653/// Extend the selection. Selections are in caret positions.
654bool wxRichTextCtrl::ExtendSelection(long oldPos, long newPos, int flags)
655{
656 if (flags & wxRICHTEXT_SHIFT_DOWN)
657 {
658 // If not currently selecting, start selecting
659 if (m_selectionRange.GetStart() == -2)
660 {
661 m_selectionAnchor = oldPos;
662
663 if (oldPos > newPos)
664 m_selectionRange.SetRange(newPos+1, oldPos);
665 else
666 m_selectionRange.SetRange(oldPos+1, newPos);
667 }
668 else
669 {
670 // Always ensure that the selection range start is greater than
671 // the end.
672 if (newPos > m_selectionAnchor)
673 m_selectionRange.SetRange(m_selectionAnchor+1, newPos);
674 else
675 m_selectionRange.SetRange(newPos+1, m_selectionAnchor);
676 }
677
678 if (m_selectionRange.GetStart() > m_selectionRange.GetEnd())
679 {
680 wxLogDebug(wxT("Strange selection range"));
681 }
7fe8059f 682
5d7836c4
JS
683 return true;
684 }
685 else
686 return false;
687}
688
689/// Scroll into view, returning true if we scrolled.
690/// This takes a _caret_ position.
691bool wxRichTextCtrl::ScrollIntoView(long position, int keyCode)
692{
693 wxRichTextLine* line = GetVisibleLineForCaretPosition(position);
694
695 if (!line)
696 return false;
697
698 int ppuX, ppuY;
699 GetScrollPixelsPerUnit(& ppuX, & ppuY);
700
701 int startX, startY;
702 GetViewStart(& startX, & startY);
703 startX = 0;
704 startY = startY * ppuY;
705
8d7eaf91 706 int sx = 0, sy = 0;
5d7836c4
JS
707 GetVirtualSize(& sx, & sy);
708 sx = 0;
709 if (ppuY != 0)
710 sy = sy/ppuY;
711
712 wxRect rect = line->GetRect();
713
714 bool scrolled = false;
715
716 wxSize clientSize = GetClientSize();
717
718 // Going down
719 if (keyCode == WXK_DOWN || keyCode == WXK_RIGHT || keyCode == WXK_END || keyCode == WXK_NEXT || keyCode == WXK_PAGEDOWN)
720 {
721 if ((rect.y + rect.height) > (clientSize.y + startY))
722 {
723 // Make it scroll so this item is at the bottom
724 // of the window
725 int y = rect.y - (clientSize.y - rect.height);
c59f6793
JS
726 y = (int) (0.5 + y/ppuY);
727
728 if (startY != y)
729 {
730 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
731 scrolled = true;
732 }
5d7836c4
JS
733 }
734 else if (rect.y < startY)
735 {
736 // Make it scroll so this item is at the top
737 // of the window
738 int y = rect.y ;
c59f6793
JS
739 y = (int) (0.5 + y/ppuY);
740
741 if (startY != y)
742 {
743 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
744 scrolled = true;
745 }
5d7836c4 746 }
5d7836c4
JS
747 }
748 // Going up
749 else if (keyCode == WXK_UP || keyCode == WXK_LEFT || keyCode == WXK_HOME || keyCode == WXK_PRIOR || keyCode == WXK_PAGEUP)
750 {
751 if (rect.y < startY)
752 {
753 // Make it scroll so this item is at the top
754 // of the window
755 int y = rect.y ;
c59f6793
JS
756 y = (int) (0.5 + y/ppuY);
757
758 if (startY != y)
759 {
760 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
761 scrolled = true;
762 }
5d7836c4
JS
763 }
764 else if ((rect.y + rect.height) > (clientSize.y + startY))
765 {
766 // Make it scroll so this item is at the bottom
767 // of the window
768 int y = rect.y - (clientSize.y - rect.height);
c59f6793
JS
769 y = (int) (0.5 + y/ppuY);
770
771 if (startY != y)
772 {
773 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
774 scrolled = true;
775 }
5d7836c4 776 }
5d7836c4
JS
777 }
778 PositionCaret();
779
780 return scrolled;
781}
782
783/// Is the given position visible on the screen?
784bool wxRichTextCtrl::IsPositionVisible(long pos) const
785{
786 wxRichTextLine* line = GetVisibleLineForCaretPosition(pos-1);
787
788 if (!line)
789 return false;
790
791 int ppuX, ppuY;
792 GetScrollPixelsPerUnit(& ppuX, & ppuY);
793
794 int startX, startY;
795 GetViewStart(& startX, & startY);
796 startX = 0;
797 startY = startY * ppuY;
798
8d7eaf91 799 int sx = 0, sy = 0;
5d7836c4
JS
800 GetVirtualSize(& sx, & sy);
801 sx = 0;
802 if (ppuY != 0)
803 sy = sy/ppuY;
804
805 wxRect rect = line->GetRect();
806
807 wxSize clientSize = GetClientSize();
808
809 return !(((rect.y + rect.height) > (clientSize.y + startY)) || rect.y < startY);
810}
811
812void wxRichTextCtrl::SetCaretPosition(long position, bool showAtLineStart)
813{
814 m_caretPosition = position;
815 m_caretAtLineStart = showAtLineStart;
816}
817
818/// Move caret one visual step forward: this may mean setting a flag
819/// and keeping the same position if we're going from the end of one line
820/// to the start of the next, which may be the exact same caret position.
821void wxRichTextCtrl::MoveCaretForward(long oldPosition)
822{
823 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
824
825 // Only do the check if we're not at the end of the paragraph (where things work OK
826 // anyway)
827 if (para && (oldPosition != para->GetRange().GetEnd() - 1))
828 {
829 wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
830
831 if (line)
832 {
1e967276
JS
833 wxRichTextRange lineRange = line->GetAbsoluteRange();
834
5d7836c4
JS
835 // We're at the end of a line. See whether we need to
836 // stay at the same actual caret position but change visual
837 // position, or not.
1e967276 838 if (oldPosition == lineRange.GetEnd())
5d7836c4
JS
839 {
840 if (m_caretAtLineStart)
841 {
842 // We're already at the start of the line, so actually move on now.
843 m_caretPosition = oldPosition + 1;
844 m_caretAtLineStart = false;
845 }
846 else
847 {
848 // We're showing at the end of the line, so keep to
849 // the same position but indicate that we're to show
850 // at the start of the next line.
851 m_caretPosition = oldPosition;
7fe8059f 852 m_caretAtLineStart = true;
5d7836c4
JS
853 }
854 SetDefaultStyleToCursorStyle();
855 return;
856 }
857 }
858 }
859 m_caretPosition ++;
860 SetDefaultStyleToCursorStyle();
861}
862
863/// Move caret one visual step backward: this may mean setting a flag
864/// and keeping the same position if we're going from the end of one line
865/// to the start of the next, which may be the exact same caret position.
866void wxRichTextCtrl::MoveCaretBack(long oldPosition)
867{
868 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
869
870 // Only do the check if we're not at the start of the paragraph (where things work OK
871 // anyway)
872 if (para && (oldPosition != para->GetRange().GetStart()))
873 {
874 wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
875
876 if (line)
877 {
1e967276
JS
878 wxRichTextRange lineRange = line->GetAbsoluteRange();
879
5d7836c4
JS
880 // We're at the start of a line. See whether we need to
881 // stay at the same actual caret position but change visual
882 // position, or not.
1e967276 883 if (oldPosition == lineRange.GetStart())
5d7836c4
JS
884 {
885 m_caretPosition = oldPosition-1;
886 m_caretAtLineStart = true;
887 return;
888 }
1e967276 889 else if (oldPosition == lineRange.GetEnd())
5d7836c4
JS
890 {
891 if (m_caretAtLineStart)
892 {
893 // We're at the start of the line, so keep the same caret position
894 // but clear the start-of-line flag.
895 m_caretPosition = oldPosition;
896 m_caretAtLineStart = false;
897 }
898 else
899 {
900 // We're showing at the end of the line, so go back
901 // to the previous character position.
902 m_caretPosition = oldPosition - 1;
903 }
904 SetDefaultStyleToCursorStyle();
905 return;
906 }
907 }
908 }
909 m_caretPosition --;
910 SetDefaultStyleToCursorStyle();
911}
912
913/// Move right
914bool wxRichTextCtrl::MoveRight(int noPositions, int flags)
915{
916 long endPos = GetBuffer().GetRange().GetEnd();
917
918 if (m_caretPosition + noPositions < endPos)
919 {
920 long oldPos = m_caretPosition;
921 long newPos = m_caretPosition + noPositions;
922
923 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
924 if (!extendSel)
925 SelectNone();
926
927 // Determine by looking at oldPos and m_caretPosition whether
928 // we moved from the end of a line to the start of the next line, in which case
929 // we want to adjust the caret position such that it is positioned at the
930 // start of the next line, rather than jumping past the first character of the
931 // line.
932 if (noPositions == 1 && !extendSel)
933 MoveCaretForward(oldPos);
934 else
935 SetCaretPosition(newPos);
936
937 PositionCaret();
938 SetDefaultStyleToCursorStyle();
939
c59f6793 940 if (extendSel)
76bcd815 941 Refresh(false);
5d7836c4
JS
942 return true;
943 }
944 else
7fe8059f 945 return false;
5d7836c4
JS
946}
947
948/// Move left
949bool wxRichTextCtrl::MoveLeft(int noPositions, int flags)
950{
951 long startPos = -1;
952
953 if (m_caretPosition > startPos - noPositions + 1)
954 {
955 long oldPos = m_caretPosition;
956 long newPos = m_caretPosition - noPositions;
957 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
958 if (!extendSel)
959 SelectNone();
960
961 if (noPositions == 1 && !extendSel)
962 MoveCaretBack(oldPos);
963 else
964 SetCaretPosition(newPos);
965
966 PositionCaret();
967 SetDefaultStyleToCursorStyle();
968
c59f6793 969 if (extendSel)
76bcd815 970 Refresh(false);
5d7836c4
JS
971 return true;
972 }
973 else
7fe8059f 974 return false;
5d7836c4
JS
975}
976
977/// Move up
978bool wxRichTextCtrl::MoveUp(int noLines, int flags)
979{
980 return MoveDown(- noLines, flags);
981}
982
983/// Move up
984bool wxRichTextCtrl::MoveDown(int noLines, int flags)
985{
c59f6793
JS
986 if (!GetCaret())
987 return false;
988
5d7836c4
JS
989 long lineNumber = GetBuffer().GetVisibleLineNumber(m_caretPosition, true, m_caretAtLineStart);
990 wxPoint pt = GetCaret()->GetPosition();
991 long newLine = lineNumber + noLines;
992
993 if (lineNumber != -1)
994 {
995 if (noLines > 0)
996 {
997 long lastLine = GetBuffer().GetVisibleLineNumber(GetBuffer().GetRange().GetEnd());
998
999 if (newLine > lastLine)
1000 return false;
1001 }
1002 else
1003 {
1004 if (newLine < 0)
1005 return false;
1006 }
1007 }
1008
1009 wxRichTextLine* lineObj = GetBuffer().GetLineForVisibleLineNumber(newLine);
1010 if (lineObj)
7fe8059f
WS
1011 {
1012 pt.y = lineObj->GetAbsolutePosition().y + 2;
5d7836c4
JS
1013 }
1014 else
1015 return false;
1016
1017 long newPos = 0;
1018 wxClientDC dc(this);
1019 PrepareDC(dc);
1020 dc.SetFont(GetFont());
7fe8059f 1021
5d7836c4 1022 int hitTest = GetBuffer().HitTest(dc, pt, newPos);
7fe8059f 1023
5d7836c4
JS
1024 if (hitTest != wxRICHTEXT_HITTEST_NONE)
1025 {
1026 // If end of previous line, and hitTest is wxRICHTEXT_HITTEST_BEFORE,
1027 // we want to be at the end of the last line but with m_caretAtLineStart set to true,
1028 // so we view the caret at the start of the line.
1029 bool caretLineStart = false;
1030 if (hitTest == wxRICHTEXT_HITTEST_BEFORE)
1031 {
1032 wxRichTextLine* thisLine = GetBuffer().GetLineAtPosition(newPos-1);
1e967276
JS
1033 wxRichTextRange lineRange;
1034 if (thisLine)
1035 lineRange = thisLine->GetAbsoluteRange();
1036
1037 if (thisLine && (newPos-1) == lineRange.GetEnd())
5d7836c4 1038 {
1e967276
JS
1039 newPos --;
1040 caretLineStart = true;
5d7836c4
JS
1041 }
1042 else
1043 {
1044 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(newPos);
1045 if (para && para->GetRange().GetStart() == newPos)
1046 newPos --;
1047 }
1048 }
1049
1050 long newSelEnd = newPos;
1051
c59f6793
JS
1052 bool extendSel = ExtendSelection(m_caretPosition, newSelEnd, flags);
1053 if (!extendSel)
5d7836c4
JS
1054 SelectNone();
1055
1056 SetCaretPosition(newPos, caretLineStart);
1057 PositionCaret();
1058 SetDefaultStyleToCursorStyle();
1059
c59f6793 1060 if (extendSel)
76bcd815 1061 Refresh(false);
5d7836c4
JS
1062 return true;
1063 }
41e155b4
WS
1064
1065 return false;
5d7836c4
JS
1066}
1067
1068/// Move to the end of the paragraph
1069bool wxRichTextCtrl::MoveToParagraphEnd(int flags)
1070{
1071 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1072 if (para)
1073 {
1074 long newPos = para->GetRange().GetEnd() - 1;
c59f6793
JS
1075 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1076 if (!extendSel)
5d7836c4
JS
1077 SelectNone();
1078
1079 SetCaretPosition(newPos);
1080 PositionCaret();
1081 SetDefaultStyleToCursorStyle();
1082
c59f6793 1083 if (extendSel)
76bcd815 1084 Refresh(false);
5d7836c4
JS
1085 return true;
1086 }
1087
1088 return false;
1089}
1090
1091/// Move to the start of the paragraph
1092bool wxRichTextCtrl::MoveToParagraphStart(int flags)
1093{
1094 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1095 if (para)
1096 {
1097 long newPos = para->GetRange().GetStart() - 1;
c59f6793
JS
1098 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1099 if (!extendSel)
5d7836c4
JS
1100 SelectNone();
1101
1102 SetCaretPosition(newPos);
1103 PositionCaret();
1104 SetDefaultStyleToCursorStyle();
1105
c59f6793 1106 if (extendSel)
76bcd815 1107 Refresh(false);
5d7836c4
JS
1108 return true;
1109 }
1110
1111 return false;
1112}
1113
1114/// Move to the end of the line
1115bool wxRichTextCtrl::MoveToLineEnd(int flags)
1116{
1117 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1118
1119 if (line)
1120 {
1e967276
JS
1121 wxRichTextRange lineRange = line->GetAbsoluteRange();
1122 long newPos = lineRange.GetEnd();
c59f6793
JS
1123 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1124 if (!extendSel)
5d7836c4
JS
1125 SelectNone();
1126
1127 SetCaretPosition(newPos);
1128 PositionCaret();
1129 SetDefaultStyleToCursorStyle();
1130
c59f6793 1131 if (extendSel)
76bcd815 1132 Refresh(false);
5d7836c4
JS
1133 return true;
1134 }
1135
1136 return false;
1137}
1138
1139/// Move to the start of the line
1140bool wxRichTextCtrl::MoveToLineStart(int flags)
1141{
1142 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1143 if (line)
1144 {
1e967276
JS
1145 wxRichTextRange lineRange = line->GetAbsoluteRange();
1146 long newPos = lineRange.GetStart()-1;
5d7836c4 1147
c59f6793
JS
1148 bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1149 if (!extendSel)
5d7836c4
JS
1150 SelectNone();
1151
1152 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(line);
1153
1e967276 1154 SetCaretPosition(newPos, para->GetRange().GetStart() != lineRange.GetStart());
5d7836c4
JS
1155 PositionCaret();
1156 SetDefaultStyleToCursorStyle();
1157
c59f6793 1158 if (extendSel)
76bcd815 1159 Refresh(false);
5d7836c4
JS
1160 return true;
1161 }
1162
1163 return false;
1164}
1165
1166/// Move to the start of the buffer
1167bool wxRichTextCtrl::MoveHome(int flags)
1168{
1169 if (m_caretPosition != -1)
1170 {
c59f6793
JS
1171 bool extendSel = ExtendSelection(m_caretPosition, -1, flags);
1172 if (!extendSel)
5d7836c4
JS
1173 SelectNone();
1174
1175 SetCaretPosition(-1);
1176 PositionCaret();
1177 SetDefaultStyleToCursorStyle();
1178
c59f6793 1179 if (extendSel)
76bcd815 1180 Refresh(false);
5d7836c4
JS
1181 return true;
1182 }
1183 else
7fe8059f 1184 return false;
5d7836c4
JS
1185}
1186
1187/// Move to the end of the buffer
1188bool wxRichTextCtrl::MoveEnd(int flags)
1189{
1190 long endPos = GetBuffer().GetRange().GetEnd()-1;
1191
1192 if (m_caretPosition != endPos)
1193 {
c59f6793
JS
1194 bool extendSel = ExtendSelection(m_caretPosition, endPos, flags);
1195 if (!extendSel)
5d7836c4
JS
1196 SelectNone();
1197
1198 SetCaretPosition(endPos);
1199 PositionCaret();
1200 SetDefaultStyleToCursorStyle();
1201
c59f6793 1202 if (extendSel)
76bcd815 1203 Refresh(false);
5d7836c4
JS
1204 return true;
1205 }
1206 else
7fe8059f 1207 return false;
5d7836c4
JS
1208}
1209
1210/// Move noPages pages up
1211bool wxRichTextCtrl::PageUp(int noPages, int flags)
1212{
1213 return PageDown(- noPages, flags);
1214}
1215
1216/// Move noPages pages down
1217bool wxRichTextCtrl::PageDown(int noPages, int flags)
1218{
1219 // Calculate which line occurs noPages * screen height further down.
1220 wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1221 if (line)
1222 {
1223 wxSize clientSize = GetClientSize();
1224 int newY = line->GetAbsolutePosition().y + noPages*clientSize.y;
1225
1226 wxRichTextLine* newLine = GetBuffer().GetLineAtYPosition(newY);
1227 if (newLine)
1228 {
1e967276
JS
1229 wxRichTextRange lineRange = newLine->GetAbsoluteRange();
1230 long pos = lineRange.GetStart()-1;
5d7836c4
JS
1231 if (pos != m_caretPosition)
1232 {
1233 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(newLine);
1234
c59f6793
JS
1235 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1236 if (!extendSel)
5d7836c4
JS
1237 SelectNone();
1238
1e967276 1239 SetCaretPosition(pos, para->GetRange().GetStart() != lineRange.GetStart());
5d7836c4
JS
1240 PositionCaret();
1241 SetDefaultStyleToCursorStyle();
1242
c59f6793 1243 if (extendSel)
76bcd815 1244 Refresh(false);
5d7836c4
JS
1245 return true;
1246 }
1247 }
1248 }
1249
1250 return false;
1251}
1252
1253// Finds the caret position for the next word
1254long wxRichTextCtrl::FindNextWordPosition(int direction) const
7fe8059f 1255{
5d7836c4
JS
1256 long endPos = GetBuffer().GetRange().GetEnd();
1257
1258 if (direction > 0)
1259 {
1260 long i = m_caretPosition+1+direction; // +1 for conversion to character pos
7fe8059f 1261
5d7836c4
JS
1262 // First skip current text to space
1263 while (i < endPos && i > -1)
1264 {
1265 // i is in character, not caret positions
1266 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
7fe8059f 1267 if (text != wxT(" ") && !text.empty())
5d7836c4
JS
1268 i += direction;
1269 else
1270 {
1271 break;
1272 }
1273 }
1274 while (i < endPos && i > -1)
1275 {
1276 // i is in character, not caret positions
1277 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
7fe8059f 1278 if (text.empty()) // End of paragraph, or maybe an image
5d7836c4 1279 return wxMax(-1, i - 1);
7fe8059f 1280 else if (text == wxT(" ") || text.empty())
5d7836c4
JS
1281 i += direction;
1282 else
1283 {
1284 // Convert to caret position
1285 return wxMax(-1, i - 1);
1286 }
1287 }
1288 if (i >= endPos)
1289 return endPos-1;
1290 return i-1;
1291 }
1292 else
1293 {
1294 long i = m_caretPosition;
1295
1296 // First skip white space
1297 while (i < endPos && i > -1)
1298 {
1299 // i is in character, not caret positions
1300 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
7fe8059f 1301 if (text.empty()) // End of paragraph, or maybe an image
5d7836c4 1302 break;
7fe8059f 1303 else if (text == wxT(" ") || text.empty())
5d7836c4
JS
1304 i += direction;
1305 else
1306 break;
1307 }
1308 // Next skip current text to space
1309 while (i < endPos && i > -1)
1310 {
1311 // i is in character, not caret positions
1312 wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
7fe8059f 1313 if (text != wxT(" ") /* && !text.empty() */)
5d7836c4
JS
1314 i += direction;
1315 else
1316 {
1317 return i;
5d7836c4
JS
1318 }
1319 }
1320 if (i < -1)
1321 return -1;
1322 return i;
1323 }
1324}
1325
1326/// Move n words left
1327bool wxRichTextCtrl::WordLeft(int WXUNUSED(n), int flags)
1328{
1329 long pos = FindNextWordPosition(-1);
1330 if (pos != m_caretPosition)
1331 {
1332 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
7fe8059f 1333
c59f6793
JS
1334 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1335 if (!extendSel)
5d7836c4 1336 SelectNone();
7fe8059f 1337
5d7836c4
JS
1338 SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1339 PositionCaret();
1340 SetDefaultStyleToCursorStyle();
1341
c59f6793 1342 if (extendSel)
76bcd815 1343 Refresh(false);
5d7836c4
JS
1344 return true;
1345 }
7fe8059f 1346
5d7836c4
JS
1347 return false;
1348}
1349
1350/// Move n words right
1351bool wxRichTextCtrl::WordRight(int WXUNUSED(n), int flags)
1352{
1353 long pos = FindNextWordPosition(1);
1354 if (pos != m_caretPosition)
1355 {
1356 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
7fe8059f 1357
c59f6793
JS
1358 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1359 if (!extendSel)
5d7836c4 1360 SelectNone();
7fe8059f 1361
5d7836c4
JS
1362 SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1363 PositionCaret();
1364 SetDefaultStyleToCursorStyle();
1365
c59f6793 1366 if (extendSel)
76bcd815 1367 Refresh(false);
5d7836c4
JS
1368 return true;
1369 }
7fe8059f 1370
5d7836c4
JS
1371 return false;
1372}
1373
1374/// Sizing
1375void wxRichTextCtrl::OnSize(wxSizeEvent& event)
1376{
4d551ad5
JS
1377 // Only do sizing optimization for large buffers
1378 if (GetBuffer().GetRange().GetEnd() > m_delayedLayoutThreshold)
1379 {
1380 m_fullLayoutRequired = true;
1381 m_fullLayoutTime = wxGetLocalTimeMillis();
1382 m_fullLayoutSavedPosition = GetFirstVisiblePosition();
2f36e8dc 1383 LayoutContent(true /* onlyVisibleRect */);
4d551ad5
JS
1384 }
1385 else
1386 GetBuffer().Invalidate(wxRICHTEXT_ALL);
7fe8059f 1387
5d7836c4
JS
1388 RecreateBuffer();
1389
1390 event.Skip();
1391}
1392
4d551ad5
JS
1393
1394/// Idle-time processing
1395void wxRichTextCtrl::OnIdle(wxIdleEvent& event)
1396{
1397 const int layoutInterval = wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL;
1398
1399 if (m_fullLayoutRequired && (wxGetLocalTimeMillis() > (m_fullLayoutTime + layoutInterval)))
1400 {
1401 m_fullLayoutRequired = false;
1402 m_fullLayoutTime = 0;
1403 GetBuffer().Invalidate(wxRICHTEXT_ALL);
1404 ShowPosition(m_fullLayoutSavedPosition);
76bcd815 1405 Refresh(false);
4d551ad5
JS
1406 }
1407 event.Skip();
1408}
1409
c59f6793
JS
1410/// Scrolling
1411void wxRichTextCtrl::OnScroll(wxScrollWinEvent& event)
1412{
1413 // Not used
1414 event.Skip();
1415}
1416
5d7836c4 1417/// Set up scrollbars, e.g. after a resize
169adfa9 1418void wxRichTextCtrl::SetupScrollbars(bool atTop)
5d7836c4
JS
1419{
1420 if (m_freezeCount)
1421 return;
1422
1423 if (GetBuffer().IsEmpty())
1424 {
1425 SetScrollbars(0, 0, 0, 0, 0, 0);
1426 return;
1427 }
1428
1429 // TODO: reimplement scrolling so we scroll by line, not by fixed number
1430 // of pixels. See e.g. wxVScrolledWindow for ideas.
1431 int pixelsPerUnit = 5; // 10;
1432 wxSize clientSize = GetClientSize();
1433
1434 int maxHeight = GetBuffer().GetCachedSize().y;
1435
1436 int unitsY = maxHeight/pixelsPerUnit;
1437
169adfa9
JS
1438 int startX = 0, startY = 0;
1439 if (!atTop)
1440 GetViewStart(& startX, & startY);
7fe8059f 1441
5d7836c4
JS
1442 int maxPositionX = 0; // wxMax(sz.x - clientSize.x, 0);
1443 int maxPositionY = (wxMax(maxHeight - clientSize.y, 0))/pixelsPerUnit;
7fe8059f 1444
5d7836c4
JS
1445 // Move to previous scroll position if
1446 // possible
1447 SetScrollbars(0, pixelsPerUnit,
1448 0, unitsY,
1449 wxMin(maxPositionX, startX), wxMin(maxPositionY, startY));
1450}
1451
1452/// Paint the background
1453void wxRichTextCtrl::PaintBackground(wxDC& dc)
1454{
1455 wxColour backgroundColour = GetBackgroundColour();
1456 if (!backgroundColour.Ok())
1457 backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1458
1459 // Clear the background
1460 dc.SetBrush(wxBrush(backgroundColour));
1461 dc.SetPen(*wxTRANSPARENT_PEN);
7fe8059f 1462 wxRect windowRect(GetClientSize());
5d7836c4
JS
1463 windowRect.x -= 2; windowRect.y -= 2;
1464 windowRect.width += 4; windowRect.height += 4;
7fe8059f 1465
5d7836c4
JS
1466 // We need to shift the rectangle to take into account
1467 // scrolling. Converting device to logical coordinates.
1468 CalcUnscrolledPosition(windowRect.x, windowRect.y, & windowRect.x, & windowRect.y);
1469 dc.DrawRectangle(windowRect);
1470}
1471
1472/// Recreate buffer bitmap if necessary
1473bool wxRichTextCtrl::RecreateBuffer(const wxSize& size)
1474{
1475 wxSize sz = size;
1476 if (sz == wxDefaultSize)
1477 sz = GetClientSize();
7fe8059f 1478
5d7836c4
JS
1479 if (sz.x < 1 || sz.y < 1)
1480 return false;
7fe8059f 1481
5d7836c4
JS
1482 if (!m_bufferBitmap.Ok() || m_bufferBitmap.GetWidth() < sz.x || m_bufferBitmap.GetHeight() < sz.y)
1483 m_bufferBitmap = wxBitmap(sz.x, sz.y);
1484 return m_bufferBitmap.Ok();
1485}
1486
1487// ----------------------------------------------------------------------------
1488// file IO functions
1489// ----------------------------------------------------------------------------
1490
1491bool wxRichTextCtrl::LoadFile(const wxString& filename, int type)
1492{
1493 bool success = GetBuffer().LoadFile(filename, type);
1494 if (success)
1495 m_filename = filename;
1496
1497 DiscardEdits();
1498 SetInsertionPoint(0);
2f36e8dc 1499 LayoutContent();
5d7836c4 1500 PositionCaret();
169adfa9 1501 SetupScrollbars(true);
76bcd815 1502 Refresh(false);
5d7836c4
JS
1503 SendUpdateEvent();
1504
1505 if (success)
1506 return true;
1507 else
1508 {
1509 wxLogError(_("File couldn't be loaded."));
7fe8059f 1510
5d7836c4
JS
1511 return false;
1512 }
1513}
1514
1515bool wxRichTextCtrl::SaveFile(const wxString& filename, int type)
1516{
1517 wxString filenameToUse = filename.empty() ? m_filename : filename;
1518 if ( filenameToUse.empty() )
1519 {
1520 // what kind of message to give? is it an error or a program bug?
1521 wxLogDebug(wxT("Can't save textctrl to file without filename."));
1522
1523 return false;
1524 }
1525
1526 if (GetBuffer().SaveFile(filenameToUse, type))
1527 {
1528 m_filename = filenameToUse;
1529
1530 DiscardEdits();
1531
1532 return true;
1533
1534 }
1535
1536 wxLogError(_("The text couldn't be saved."));
1537
1538 return false;
1539}
1540
1541// ----------------------------------------------------------------------------
1542// wxRichTextCtrl specific functionality
1543// ----------------------------------------------------------------------------
1544
1545/// Add a new paragraph of text to the end of the buffer
1546wxRichTextRange wxRichTextCtrl::AddParagraph(const wxString& text)
1547{
1548 return GetBuffer().AddParagraph(text);
1549}
1550
1551/// Add an image
1552wxRichTextRange wxRichTextCtrl::AddImage(const wxImage& image)
1553{
1554 return GetBuffer().AddImage(image);
1555}
1556
1557// ----------------------------------------------------------------------------
1558// selection and ranges
1559// ----------------------------------------------------------------------------
1560
1561void wxRichTextCtrl::SelectAll()
1562{
1563 SetSelection(0, GetLastPosition());
1564 m_selectionAnchor = -1;
1565}
1566
1567/// Select none
1568void wxRichTextCtrl::SelectNone()
1569{
c59f6793
JS
1570 if (!(GetSelectionRange() == wxRichTextRange(-2, -2)))
1571 SetSelection(-2, -2);
5d7836c4
JS
1572 m_selectionAnchor = -2;
1573}
1574
1575wxString wxRichTextCtrl::GetStringSelection() const
1576{
1577 long from, to;
1578 GetSelection(&from, &to);
1579
1580 return GetRange(from, to);
1581}
1582
1583// do the window-specific processing after processing the update event
a3a4105d 1584#if !wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
5d7836c4
JS
1585void wxRichTextCtrl::DoUpdateWindowUI(wxUpdateUIEvent& event)
1586{
a3a4105d
VZ
1587 // call inherited
1588 wxWindowBase::DoUpdateWindowUI(event);
5d7836c4 1589
a3a4105d 1590 // update text
5d7836c4
JS
1591 if ( event.GetSetText() )
1592 {
1593 if ( event.GetText() != GetValue() )
1594 SetValue(event.GetText());
1595 }
1596}
a3a4105d 1597#endif // !wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
5d7836c4
JS
1598
1599// ----------------------------------------------------------------------------
1600// hit testing
1601// ----------------------------------------------------------------------------
1602
1603wxTextCtrlHitTestResult
1604wxRichTextCtrl::HitTest(const wxPoint& pt, wxTextCoord *x, wxTextCoord *y) const
1605{
1606 // implement in terms of the other overload as the native ports typically
1607 // can get the position and not (x, y) pair directly (although wxUniv
1608 // directly gets x and y -- and so overrides this method as well)
1609 long pos;
1610 wxTextCtrlHitTestResult rc = HitTest(pt, &pos);
1611
1612 if ( rc != wxTE_HT_UNKNOWN )
1613 {
1614 PositionToXY(pos, x, y);
1615 }
1616
1617 return rc;
1618}
1619
1620wxTextCtrlHitTestResult
1621wxRichTextCtrl::HitTest(const wxPoint& pt,
1622 long * pos) const
1623{
1624 wxClientDC dc((wxRichTextCtrl*) this);
1625 ((wxRichTextCtrl*)this)->PrepareDC(dc);
1626
1627 int hit = ((wxRichTextCtrl*)this)->GetBuffer().HitTest(dc, pt, *pos);
41e155b4
WS
1628
1629 switch ( hit )
1630 {
1631 case wxRICHTEXT_HITTEST_BEFORE:
1632 return wxTE_HT_BEFORE;
1633
1634 case wxRICHTEXT_HITTEST_AFTER:
1635 return wxTE_HT_BEYOND;
1636
1637 case wxRICHTEXT_HITTEST_ON:
1638 return wxTE_HT_ON_TEXT;
1639 }
1640
1641 return wxTE_HT_UNKNOWN;
5d7836c4
JS
1642}
1643
1644// ----------------------------------------------------------------------------
1645// set/get the controls text
1646// ----------------------------------------------------------------------------
1647
1648wxString wxRichTextCtrl::GetValue() const
1649{
1650 return GetBuffer().GetText();
1651}
1652
1653wxString wxRichTextCtrl::GetRange(long from, long to) const
1654{
1655 return GetBuffer().GetTextForRange(wxRichTextRange(from, to));
1656}
1657
1658void wxRichTextCtrl::SetValue(const wxString& value)
1659{
1660 Clear();
1661
1662 // if the text is long enough, it's faster to just set it instead of first
1663 // comparing it with the old one (chances are that it will be different
1664 // anyhow, this comparison is there to avoid flicker for small single-line
1665 // edit controls mostly)
1666 if ( (value.length() > 0x400) || (value != GetValue()) )
1667 {
1668 DoWriteText(value, false /* not selection only */);
1669
1670 // for compatibility, don't move the cursor when doing SetValue()
1671 SetInsertionPoint(0);
1672 }
1673 else // same text
1674 {
1675 // still send an event for consistency
1676 SendUpdateEvent();
1677 }
1678
1679 // we should reset the modified flag even if the value didn't really change
1680
1681 // mark the control as being not dirty - we changed its text, not the
1682 // user
1683 DiscardEdits();
1684}
1685
1686void wxRichTextCtrl::WriteText(const wxString& value)
1687{
1688 DoWriteText(value);
1689}
1690
1691void wxRichTextCtrl::DoWriteText(const wxString& value, bool WXUNUSED(selectionOnly))
1692{
1693 GetBuffer().InsertTextWithUndo(m_caretPosition+1, value, this);
1694}
1695
1696void wxRichTextCtrl::AppendText(const wxString& text)
1697{
1698 SetInsertionPointEnd();
1699
1700 WriteText(text);
1701}
1702
1703/// Write an image at the current insertion point
1704bool wxRichTextCtrl::WriteImage(const wxImage& image, int bitmapType)
1705{
1706 wxRichTextImageBlock imageBlock;
1707
1708 wxImage image2 = image;
1709 if (imageBlock.MakeImageBlock(image2, bitmapType))
1710 return WriteImage(imageBlock);
41e155b4
WS
1711
1712 return false;
5d7836c4
JS
1713}
1714
1715bool wxRichTextCtrl::WriteImage(const wxString& filename, int bitmapType)
1716{
1717 wxRichTextImageBlock imageBlock;
1718
1719 wxImage image;
1720 if (imageBlock.MakeImageBlock(filename, bitmapType, image, false))
1721 return WriteImage(imageBlock);
41e155b4
WS
1722
1723 return false;
5d7836c4
JS
1724}
1725
1726bool wxRichTextCtrl::WriteImage(const wxRichTextImageBlock& imageBlock)
1727{
1728 return GetBuffer().InsertImageWithUndo(m_caretPosition+1, imageBlock, this);
1729}
1730
1731bool wxRichTextCtrl::WriteImage(const wxBitmap& bitmap, int bitmapType)
1732{
1733 if (bitmap.Ok())
1734 {
1735 wxRichTextImageBlock imageBlock;
7fe8059f 1736
5d7836c4
JS
1737 wxImage image = bitmap.ConvertToImage();
1738 if (image.Ok() && imageBlock.MakeImageBlock(image, bitmapType))
1739 return WriteImage(imageBlock);
5d7836c4 1740 }
41e155b4 1741
5d7836c4
JS
1742 return false;
1743}
1744
1745/// Insert a newline (actually paragraph) at the current insertion point.
1746bool wxRichTextCtrl::Newline()
1747{
1748 return GetBuffer().InsertNewlineWithUndo(m_caretPosition+1, this);
1749}
1750
1751
1752// ----------------------------------------------------------------------------
1753// Clipboard operations
1754// ----------------------------------------------------------------------------
1755
1756void wxRichTextCtrl::Copy()
1757{
1758 if (CanCopy())
1759 {
1760 wxRichTextRange range = GetSelectionRange();
1761 GetBuffer().CopyToClipboard(range);
1762 }
1763}
1764
1765void wxRichTextCtrl::Cut()
1766{
1767 if (CanCut())
1768 {
1769 wxRichTextRange range = GetSelectionRange();
1770 GetBuffer().CopyToClipboard(range);
1771
1772 DeleteSelectedContent();
2f36e8dc 1773 LayoutContent();
76bcd815 1774 Refresh(false);
5d7836c4
JS
1775 }
1776}
1777
1778void wxRichTextCtrl::Paste()
1779{
1780 if (CanPaste())
1781 {
1782 BeginBatchUndo(_("Paste"));
7fe8059f 1783
5d7836c4
JS
1784 long newPos = m_caretPosition;
1785 DeleteSelectedContent(& newPos);
7fe8059f 1786
5d7836c4
JS
1787 GetBuffer().PasteFromClipboard(newPos);
1788
1789 EndBatchUndo();
1790 }
1791}
1792
1793void wxRichTextCtrl::DeleteSelection()
1794{
1795 if (CanDeleteSelection())
1796 {
1797 DeleteSelectedContent();
1798 }
1799}
1800
1801bool wxRichTextCtrl::HasSelection() const
1802{
1803 return m_selectionRange.GetStart() != -2 && m_selectionRange.GetEnd() != -2;
1804}
1805
1806bool wxRichTextCtrl::CanCopy() const
1807{
1808 // Can copy if there's a selection
1809 return HasSelection();
1810}
1811
1812bool wxRichTextCtrl::CanCut() const
1813{
1814 return HasSelection() && IsEditable();
1815}
1816
1817bool wxRichTextCtrl::CanPaste() const
1818{
1819 if ( !IsEditable() )
1820 return false;
1821
1822 return GetBuffer().CanPasteFromClipboard();
1823}
1824
1825bool wxRichTextCtrl::CanDeleteSelection() const
1826{
1827 return HasSelection() && IsEditable();
1828}
1829
1830
1831// ----------------------------------------------------------------------------
1832// Accessors
1833// ----------------------------------------------------------------------------
1834
1835void wxRichTextCtrl::SetEditable(bool editable)
1836{
1837 m_editable = editable;
1838}
1839
1840void wxRichTextCtrl::SetInsertionPoint(long pos)
1841{
1842 SelectNone();
1843
1844 m_caretPosition = pos - 1;
1845}
1846
1847void wxRichTextCtrl::SetInsertionPointEnd()
1848{
1849 long pos = GetLastPosition();
1850 SetInsertionPoint(pos);
1851}
1852
1853long wxRichTextCtrl::GetInsertionPoint() const
1854{
1855 return m_caretPosition+1;
1856}
1857
1858wxTextPos wxRichTextCtrl::GetLastPosition() const
1859{
1860 return GetBuffer().GetRange().GetEnd();
1861}
1862
1863// If the return values from and to are the same, there is no
1864// selection.
1865void wxRichTextCtrl::GetSelection(long* from, long* to) const
1866{
1867 *from = m_selectionRange.GetStart();
1868 *to = m_selectionRange.GetEnd();
1869}
1870
1871bool wxRichTextCtrl::IsEditable() const
1872{
1873 return m_editable;
1874}
1875
1876// ----------------------------------------------------------------------------
1877// selection
1878// ----------------------------------------------------------------------------
1879
1880void wxRichTextCtrl::SetSelection(long from, long to)
1881{
1882 // if from and to are both -1, it means (in wxWidgets) that all text should
1883 // be selected.
1884 if ( (from == -1) && (to == -1) )
1885 {
1886 from = 0;
1887 to = GetLastPosition();
1888 }
1889
1890 DoSetSelection(from, to);
1891}
1892
1893void wxRichTextCtrl::DoSetSelection(long from, long to, bool WXUNUSED(scrollCaret))
1894{
1895 m_selectionAnchor = from;
1896 m_selectionRange.SetRange(from, to);
76bcd815 1897 Refresh(false);
5d7836c4
JS
1898 PositionCaret();
1899}
1900
1901// ----------------------------------------------------------------------------
1902// Editing
1903// ----------------------------------------------------------------------------
1904
1905void wxRichTextCtrl::Replace(long WXUNUSED(from), long WXUNUSED(to), const wxString& value)
1906{
1907 BeginBatchUndo(_("Replace"));
1908
1909 DeleteSelectedContent();
1910
1911 DoWriteText(value, true /* selection only */);
1912
1913 EndBatchUndo();
1914}
1915
1916void wxRichTextCtrl::Remove(long from, long to)
1917{
1918 SelectNone();
1919
1920 GetBuffer().DeleteRangeWithUndo(wxRichTextRange(from, to),
1921 m_caretPosition, // Current caret position
1922 from, // New caret position
1923 this);
1924
2f36e8dc 1925 LayoutContent();
5d7836c4 1926 if (!IsFrozen())
76bcd815 1927 Refresh(false);
5d7836c4
JS
1928}
1929
1930bool wxRichTextCtrl::IsModified() const
1931{
1932 return m_buffer.IsModified();
1933}
1934
1935void wxRichTextCtrl::MarkDirty()
1936{
1937 m_buffer.Modify(true);
1938}
1939
1940void wxRichTextCtrl::DiscardEdits()
1941{
1942 m_buffer.Modify(false);
1943 m_buffer.GetCommandProcessor()->ClearCommands();
1944}
1945
1946int wxRichTextCtrl::GetNumberOfLines() const
1947{
1948 return GetBuffer().GetParagraphCount();
1949}
1950
1951// ----------------------------------------------------------------------------
1952// Positions <-> coords
1953// ----------------------------------------------------------------------------
1954
1955long wxRichTextCtrl::XYToPosition(long x, long y) const
1956{
1957 return GetBuffer().XYToPosition(x, y);
1958}
1959
1960bool wxRichTextCtrl::PositionToXY(long pos, long *x, long *y) const
1961{
1962 return GetBuffer().PositionToXY(pos, x, y);
1963}
1964
1965// ----------------------------------------------------------------------------
1966//
1967// ----------------------------------------------------------------------------
1968
1969void wxRichTextCtrl::ShowPosition(long pos)
1970{
1971 if (!IsPositionVisible(pos))
1972 ScrollIntoView(pos-1, WXK_DOWN);
1973}
1974
1975int wxRichTextCtrl::GetLineLength(long lineNo) const
1976{
1977 return GetBuffer().GetParagraphLength(lineNo);
1978}
1979
1980wxString wxRichTextCtrl::GetLineText(long lineNo) const
1981{
1982 return GetBuffer().GetParagraphText(lineNo);
1983}
1984
1985// ----------------------------------------------------------------------------
1986// Undo/redo
1987// ----------------------------------------------------------------------------
1988
1989void wxRichTextCtrl::Undo()
1990{
1991 if (CanUndo())
1992 {
1993 GetCommandProcessor()->Undo();
1994 }
1995}
1996
1997void wxRichTextCtrl::Redo()
1998{
1999 if (CanRedo())
2000 {
2001 GetCommandProcessor()->Redo();
2002 }
2003}
2004
2005bool wxRichTextCtrl::CanUndo() const
2006{
2007 return GetCommandProcessor()->CanUndo();
2008}
2009
2010bool wxRichTextCtrl::CanRedo() const
2011{
2012 return GetCommandProcessor()->CanRedo();
2013}
2014
2015// ----------------------------------------------------------------------------
2016// implemenation details
2017// ----------------------------------------------------------------------------
2018
2019void wxRichTextCtrl::Command(wxCommandEvent & event)
2020{
2021 SetValue(event.GetString());
2022 GetEventHandler()->ProcessEvent(event);
2023}
2024
2025void wxRichTextCtrl::OnDropFiles(wxDropFilesEvent& event)
2026{
2027 // By default, load the first file into the text window.
2028 if (event.GetNumberOfFiles() > 0)
2029 {
2030 LoadFile(event.GetFiles()[0]);
2031 }
2032}
2033
2034// ----------------------------------------------------------------------------
2035// text control event processing
2036// ----------------------------------------------------------------------------
2037
2038bool wxRichTextCtrl::SendUpdateEvent()
2039{
2040 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
2041 InitCommandEvent(event);
2042
2043 return GetEventHandler()->ProcessEvent(event);
2044}
2045
2046void wxRichTextCtrl::InitCommandEvent(wxCommandEvent& event) const
2047{
2048 event.SetEventObject((wxControlBase *)this); // const_cast
2049
2050 switch ( m_clientDataType )
2051 {
2052 case wxClientData_Void:
2053 event.SetClientData(GetClientData());
2054 break;
2055
2056 case wxClientData_Object:
2057 event.SetClientObject(GetClientObject());
2058 break;
2059
2060 case wxClientData_None:
2061 // nothing to do
2062 ;
2063 }
2064}
2065
2066
2067wxSize wxRichTextCtrl::DoGetBestSize() const
2068{
2069 return wxSize(10, 10);
2070}
2071
2072// ----------------------------------------------------------------------------
2073// standard handlers for standard edit menu events
2074// ----------------------------------------------------------------------------
2075
2076void wxRichTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2077{
2078 Cut();
2079}
2080
2081void wxRichTextCtrl::OnClear(wxCommandEvent& WXUNUSED(event))
2082{
2083 DeleteSelection();
2084}
2085
2086void wxRichTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2087{
2088 Copy();
2089}
2090
2091void wxRichTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2092{
2093 Paste();
2094}
2095
2096void wxRichTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2097{
2098 Undo();
2099}
2100
2101void wxRichTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2102{
2103 Redo();
2104}
2105
2106void wxRichTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2107{
2108 event.Enable( CanCut() );
2109}
2110
2111void wxRichTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2112{
2113 event.Enable( CanCopy() );
2114}
2115
2116void wxRichTextCtrl::OnUpdateClear(wxUpdateUIEvent& event)
2117{
2118 event.Enable( CanDeleteSelection() );
2119}
2120
2121void wxRichTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2122{
2123 event.Enable( CanPaste() );
2124}
2125
2126void wxRichTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2127{
2128 event.Enable( CanUndo() );
2129 event.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
2130}
2131
2132void wxRichTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2133{
2134 event.Enable( CanRedo() );
2135 event.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
2136}
2137
2138void wxRichTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
2139{
2140 SelectAll();
2141}
2142
2143void wxRichTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
2144{
2145 event.Enable(GetLastPosition() > 0);
2146}
2147
2148void wxRichTextCtrl::OnContextMenu(wxContextMenuEvent& WXUNUSED(event))
2149{
2150 if (!m_contextMenu)
2151 {
2152 m_contextMenu = new wxMenu;
2153 m_contextMenu->Append(wxID_UNDO, _("&Undo"));
2154 m_contextMenu->Append(wxID_REDO, _("&Redo"));
2155 m_contextMenu->AppendSeparator();
2156 m_contextMenu->Append(wxID_CUT, _("Cu&t"));
2157 m_contextMenu->Append(wxID_COPY, _("&Copy"));
2158 m_contextMenu->Append(wxID_PASTE, _("&Paste"));
2159 m_contextMenu->Append(wxID_CLEAR, _("&Delete"));
2160 m_contextMenu->AppendSeparator();
2161 m_contextMenu->Append(wxID_SELECTALL, _("Select &All"));
2162 }
2163 PopupMenu(m_contextMenu);
2164 return;
2165}
2166
2167bool wxRichTextCtrl::SetStyle(long start, long end, const wxTextAttrEx& style)
2168{
2169 return GetBuffer().SetStyle(wxRichTextRange(start, end), style);
2170}
2171
2172bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style)
2173{
2174 return GetBuffer().SetStyle(range, style);
2175}
2176
2177bool wxRichTextCtrl::SetDefaultStyle(const wxTextAttrEx& style)
2178{
2179 return GetBuffer().SetDefaultStyle(style);
2180}
2181
2182const wxTextAttrEx& wxRichTextCtrl::GetDefaultStyleEx() const
2183{
2184 return GetBuffer().GetDefaultStyle();
2185}
2186
2187bool wxRichTextCtrl::GetStyle(long position, wxTextAttrEx& style) const
2188{
2189 return GetBuffer().GetStyle(position, style);
2190}
2191
2192bool wxRichTextCtrl::GetStyle(long position, wxRichTextAttr& style) const
2193{
2194 return GetBuffer().GetStyle(position, style);
2195}
2196
2197/// Set font, and also the buffer attributes
2198bool wxRichTextCtrl::SetFont(const wxFont& font)
2199{
2200#if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
2201 wxControl::SetFont(font);
2202#else
2203 wxScrolledWindow::SetFont(font);
2204#endif
2205
2206 wxTextAttrEx attr = GetBuffer().GetAttributes();
2207 attr.SetFont(font);
2208 GetBuffer().SetBasicStyle(attr);
2209 GetBuffer().SetDefaultStyle(attr);
2210
2211 return true;
2212}
2213
4d551ad5
JS
2214/// Transform logical to physical
2215wxPoint wxRichTextCtrl::GetPhysicalPoint(const wxPoint& ptLogical) const
5d7836c4
JS
2216{
2217 wxPoint pt;
2218 CalcScrolledPosition(ptLogical.x, ptLogical.y, & pt.x, & pt.y);
2219
2220 return pt;
2221}
2222
2223/// Transform physical to logical
4d551ad5 2224wxPoint wxRichTextCtrl::GetLogicalPoint(const wxPoint& ptPhysical) const
5d7836c4
JS
2225{
2226 wxPoint pt;
2227 CalcUnscrolledPosition(ptPhysical.x, ptPhysical.y, & pt.x, & pt.y);
2228
2229 return pt;
2230}
2231
2232/// Position the caret
2233void wxRichTextCtrl::PositionCaret()
2234{
c59f6793
JS
2235 if (!GetCaret())
2236 return;
2237
2238 //wxLogDebug(wxT("PositionCaret"));
2239
5d7836c4
JS
2240 wxRect caretRect;
2241 if (GetCaretPositionForIndex(GetCaretPosition(), caretRect))
2242 {
2243 wxPoint originalPt = caretRect.GetPosition();
2244 wxPoint pt = GetPhysicalPoint(originalPt);
c59f6793
JS
2245 if (GetCaret()->GetPosition() != pt)
2246 {
2247 GetCaret()->Move(pt);
2248 GetCaret()->SetSize(caretRect.GetSize());
2249 }
5d7836c4
JS
2250 }
2251}
2252
2253/// Get the caret height and position for the given character position
2254bool wxRichTextCtrl::GetCaretPositionForIndex(long position, wxRect& rect)
2255{
2256 wxClientDC dc(this);
2257 dc.SetFont(GetFont());
7fe8059f 2258
5d7836c4
JS
2259 PrepareDC(dc);
2260
2261 wxPoint pt;
2262 int height = 0;
2263
2264 if (GetBuffer().FindPosition(dc, position, pt, & height, m_caretAtLineStart))
2265 {
2266 rect = wxRect(pt, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH, height));
2267 return true;
2268 }
41e155b4
WS
2269
2270 return false;
5d7836c4
JS
2271}
2272
2273/// Gets the line for the visible caret position. If the caret is
2274/// shown at the very end of the line, it means the next character is actually
2275/// on the following line. So let's get the line we're expecting to find
2276/// if this is the case.
2277wxRichTextLine* wxRichTextCtrl::GetVisibleLineForCaretPosition(long caretPosition) const
2278{
2279 wxRichTextLine* line = GetBuffer().GetLineAtPosition(caretPosition, true);
2280 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(caretPosition, true);
2281 if (line)
2282 {
1e967276
JS
2283 wxRichTextRange lineRange = line->GetAbsoluteRange();
2284 if (caretPosition == lineRange.GetStart()-1 &&
2285 (para->GetRange().GetStart() != lineRange.GetStart()))
5d7836c4
JS
2286 {
2287 if (!m_caretAtLineStart)
2288 line = GetBuffer().GetLineAtPosition(caretPosition-1, true);
2289 }
2290 }
2291 return line;
2292}
2293
2294
2295/// Move the caret to the given character position
2296bool wxRichTextCtrl::MoveCaret(long pos, bool showAtLineStart)
2297{
2298 if (GetBuffer().GetDirty())
2f36e8dc 2299 LayoutContent();
5d7836c4
JS
2300
2301 if (pos <= GetBuffer().GetRange().GetEnd())
2302 {
2303 SetCaretPosition(pos, showAtLineStart);
2304
2305 PositionCaret();
2306
2307 return true;
2308 }
2309 else
2310 return false;
2311}
2312
2313/// Layout the buffer: which we must do before certain operations, such as
2314/// setting the caret position.
2f36e8dc 2315bool wxRichTextCtrl::LayoutContent(bool onlyVisibleRect)
5d7836c4 2316{
4d551ad5 2317 if (GetBuffer().GetDirty() || onlyVisibleRect)
1e967276
JS
2318 {
2319 wxRect availableSpace(GetClientSize());
2320 if (availableSpace.width == 0)
2321 availableSpace.width = 10;
2322 if (availableSpace.height == 0)
2323 availableSpace.height = 10;
4d551ad5
JS
2324
2325 int flags = wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT;
2326 if (onlyVisibleRect)
2327 {
2328 flags |= wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
2329 availableSpace.SetPosition(GetLogicalPoint(wxPoint(0, 0)));
2330 }
41e155b4 2331
1e967276
JS
2332 wxClientDC dc(this);
2333 dc.SetFont(GetFont());
41e155b4 2334
1e967276 2335 PrepareDC(dc);
41e155b4 2336
1e967276
JS
2337 GetBuffer().Defragment();
2338 GetBuffer().UpdateRanges(); // If items were deleted, ranges need recalculation
4d551ad5 2339 GetBuffer().Layout(dc, availableSpace, flags);
1e967276 2340 GetBuffer().SetDirty(false);
41e155b4 2341
1e967276
JS
2342 if (!IsFrozen())
2343 SetupScrollbars();
2344 }
5d7836c4
JS
2345
2346 return true;
2347}
2348
2349/// Is all of the selection bold?
2350bool wxRichTextCtrl::IsSelectionBold() const
2351{
2352 if (HasSelection())
2353 {
2354 wxRichTextAttr attr;
2355 wxRichTextRange range = GetSelectionRange();
2356 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2357 attr.SetFontWeight(wxBOLD);
7fe8059f 2358
5d7836c4
JS
2359 return HasCharacterAttributes(range, attr);
2360 }
2361 else
2362 {
2363 // If no selection, then we need to combine current style with default style
2364 // to see what the effect would be if we started typing.
2365 wxRichTextAttr attr;
2366 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2367 if (GetStyle(GetCaretPosition()+1, attr))
2368 {
2369 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2370 return attr.GetFontWeight() == wxBOLD;
2371 }
2372 }
2373 return false;
2374}
2375
2376/// Is all of the selection italics?
2377bool wxRichTextCtrl::IsSelectionItalics() const
2378{
2379 if (HasSelection())
2380 {
2381 wxRichTextRange range = GetSelectionRange();
2382 wxRichTextAttr attr;
2383 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2384 attr.SetFontStyle(wxITALIC);
7fe8059f 2385
5d7836c4
JS
2386 return HasCharacterAttributes(range, attr);
2387 }
2388 else
2389 {
2390 // If no selection, then we need to combine current style with default style
2391 // to see what the effect would be if we started typing.
2392 wxRichTextAttr attr;
2393 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2394 if (GetStyle(GetCaretPosition()+1, attr))
2395 {
2396 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2397 return attr.GetFontStyle() == wxITALIC;
2398 }
2399 }
2400 return false;
2401}
2402
2403/// Is all of the selection underlined?
2404bool wxRichTextCtrl::IsSelectionUnderlined() const
2405{
2406 if (HasSelection())
2407 {
2408 wxRichTextRange range = GetSelectionRange();
2409 wxRichTextAttr attr;
2410 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2411 attr.SetFontUnderlined(true);
7fe8059f 2412
5d7836c4
JS
2413 return HasCharacterAttributes(range, attr);
2414 }
2415 else
2416 {
2417 // If no selection, then we need to combine current style with default style
2418 // to see what the effect would be if we started typing.
2419 wxRichTextAttr attr;
2420 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2421 if (GetStyle(GetCaretPosition()+1, attr))
2422 {
2423 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2424 return attr.GetFontUnderlined();
2425 }
2426 }
2427 return false;
2428}
2429
2430/// Apply bold to the selection
2431bool wxRichTextCtrl::ApplyBoldToSelection()
2432{
2433 wxRichTextAttr attr;
2434 attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2435 attr.SetFontWeight(IsSelectionBold() ? wxNORMAL : wxBOLD);
2436
2437 if (HasSelection())
2438 return SetStyle(GetSelectionRange(), attr);
2439 else
2440 SetDefaultStyle(attr);
2441 return true;
2442}
2443
2444/// Apply italic to the selection
2445bool wxRichTextCtrl::ApplyItalicToSelection()
2446{
2447 wxRichTextAttr attr;
2448 attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2449 attr.SetFontStyle(IsSelectionItalics() ? wxNORMAL : wxITALIC);
2450
2451 if (HasSelection())
2452 return SetStyle(GetSelectionRange(), attr);
2453 else
2454 SetDefaultStyle(attr);
2455 return true;
2456}
2457
2458/// Apply underline to the selection
2459bool wxRichTextCtrl::ApplyUnderlineToSelection()
2460{
2461 wxRichTextAttr attr;
2462 attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
4d551ad5 2463 attr.SetFontUnderlined(!IsSelectionUnderlined());
5d7836c4
JS
2464
2465 if (HasSelection())
2466 return SetStyle(GetSelectionRange(), attr);
2467 else
2468 SetDefaultStyle(attr);
2469 return true;
2470}
2471
2472/// Is all of the selection aligned according to the specified flag?
2473bool wxRichTextCtrl::IsSelectionAligned(wxTextAttrAlignment alignment) const
2474{
2475 if (HasSelection())
2476 {
2477 wxRichTextRange range = GetSelectionRange();
2478 wxRichTextAttr attr;
2479 attr.SetAlignment(alignment);
7fe8059f 2480
5d7836c4
JS
2481 return HasParagraphAttributes(range, attr);
2482 }
2483 else
2484 {
2485 // If no selection, then we need to get information from the current paragraph.
2486 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2487 if (para)
2488 return para->GetAttributes().GetAlignment() == alignment;
2489 }
2490 return false;
2491}
2492
2493/// Apply alignment to the selection
2494bool wxRichTextCtrl::ApplyAlignmentToSelection(wxTextAttrAlignment alignment)
2495{
2496 wxRichTextAttr attr;
2497 attr.SetAlignment(alignment);
2498 if (HasSelection())
2499 return SetStyle(GetSelectionRange(), attr);
2500 else
2501 {
2502 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2503 if (para)
2504 return SetStyle(para->GetRange(), attr);
2505 }
2506 return true;
2507}
2508
2509/// Sets the default style to the style under the cursor
2510bool wxRichTextCtrl::SetDefaultStyleToCursorStyle()
2511{
2512 wxTextAttrEx attr;
2513 attr.SetFlags(wxTEXT_ATTR_CHARACTER);
2514
2515 if (GetStyle(GetCaretPosition(), attr))
2516 {
2517 SetDefaultStyle(attr);
2518 return true;
2519 }
41e155b4
WS
2520
2521 return false;
5d7836c4
JS
2522}
2523
4d551ad5
JS
2524/// Returns the first visible position in the current view
2525long wxRichTextCtrl::GetFirstVisiblePosition() const
2526{
2527 wxRichTextLine* line = GetBuffer().GetLineAtYPosition(GetLogicalPoint(wxPoint(0, 0)).y);
2528 if (line)
2529 return line->GetAbsoluteRange().GetStart();
2530 else
2531 return 0;
2532}
2533
5d7836c4
JS
2534#endif
2535 // wxUSE_RICHTEXT
2536