]> git.saurik.com Git - wxWidgets.git/blob - src/richtext/richtextctrl.cpp
projects / wxWidgets.git / blob
? search:


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