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