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