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