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