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