src/richtext/richtextctrl.cpp

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