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     // The object returned is the one actually inserted into the buffer,
3013     // while the original one is deleted.
3014     wxRichTextObject* obj = GetFocusObject()->InsertObjectWithUndo(& GetBuffer(), m_caretPosition+1, textBox, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
3015     wxRichTextBox* box = wxDynamicCast(obj, wxRichTextBox);
3016     return box;
3017 }
3018
3019 wxRichTextField* wxRichTextCtrl::WriteField(const wxString& fieldType, const wxRichTextProperties& properties,
3020                             const wxRichTextAttr& textAttr)
3021 {
3022     return GetFocusObject()->InsertFieldWithUndo(& GetBuffer(), m_caretPosition+1, fieldType, properties,
3023                 this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE, textAttr);
3024 }
3025
3026 // Write a table at the current insertion point, returning the table.
3027 wxRichTextTable* wxRichTextCtrl::WriteTable(int rows, int cols, const wxRichTextAttr& tableAttr, const wxRichTextAttr& cellAttr)
3028 {
3029     wxASSERT(rows > 0 && cols > 0);
3030
3031     if (rows <= 0 || cols <= 0)
3032         return NULL;
3033
3034     wxRichTextTable* table = new wxRichTextTable;
3035     table->SetAttributes(tableAttr);
3036     table->SetParent(& GetBuffer()); // set parent temporarily for AddParagraph to use correct style
3037
3038     table->CreateTable(rows, cols);
3039
3040     table->SetParent(NULL);
3041
3042     int i, j;
3043     for (j = 0; j < rows; j++)
3044     {
3045         for (i = 0; i < cols; i++)
3046         {
3047             table->GetCell(j, i)->GetAttributes() = cellAttr;
3048         }
3049     }
3050
3051     // The object returned is the one actually inserted into the buffer,
3052     // while the original one is deleted.
3053     wxRichTextObject* obj = GetFocusObject()->InsertObjectWithUndo(& GetBuffer(), m_caretPosition+1, table, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
3054     wxRichTextTable* tableResult = wxDynamicCast(obj, wxRichTextTable);
3055     return tableResult;
3056 }
3057
3058
3059 /// Insert a newline (actually paragraph) at the current insertion point.
3060 bool wxRichTextCtrl::Newline()
3061 {
3062     return GetFocusObject()->InsertNewlineWithUndo(& GetBuffer(), m_caretPosition+1, this, wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
3063 }
3064
3065 /// Insert a line break at the current insertion point.
3066 bool wxRichTextCtrl::LineBreak()
3067 {
3068     wxString text;
3069     text = wxRichTextLineBreakChar;
3070     return GetFocusObject()->InsertTextWithUndo(& GetBuffer(), m_caretPosition+1, text, this);
3071 }
3072
3073 // ----------------------------------------------------------------------------
3074 // Clipboard operations
3075 // ----------------------------------------------------------------------------
3076
3077 void wxRichTextCtrl::Copy()
3078 {
3079     if (CanCopy())
3080     {
3081         wxRichTextRange range = GetInternalSelectionRange();
3082         GetBuffer().CopyToClipboard(range);
3083     }
3084 }
3085
3086 void wxRichTextCtrl::Cut()
3087 {
3088     if (CanCut())
3089     {
3090         wxRichTextRange range = GetInternalSelectionRange();
3091         GetBuffer().CopyToClipboard(range);
3092
3093         DeleteSelectedContent();
3094         LayoutContent();
3095         Refresh(false);
3096     }
3097 }
3098
3099 void wxRichTextCtrl::Paste()
3100 {
3101     if (CanPaste())
3102     {
3103         BeginBatchUndo(_("Paste"));
3104
3105         long newPos = m_caretPosition;
3106         DeleteSelectedContent(& newPos);
3107
3108         GetBuffer().PasteFromClipboard(newPos);
3109
3110         EndBatchUndo();
3111     }
3112 }
3113
3114 void wxRichTextCtrl::DeleteSelection()
3115 {
3116     if (CanDeleteSelection())
3117     {
3118         DeleteSelectedContent();
3119     }
3120 }
3121
3122 bool wxRichTextCtrl::HasSelection() const
3123 {
3124     return (m_selection.IsValid() && m_selection.GetContainer() == GetFocusObject());
3125 }
3126
3127 bool wxRichTextCtrl::HasUnfocusedSelection() const
3128 {
3129     return m_selection.IsValid();
3130 }
3131
3132 bool wxRichTextCtrl::CanCopy() const
3133 {
3134     // Can copy if there's a selection
3135     return HasSelection();
3136 }
3137
3138 bool wxRichTextCtrl::CanCut() const
3139 {
3140     return CanDeleteSelection();
3141 }
3142
3143 bool wxRichTextCtrl::CanPaste() const
3144 {
3145     if ( !IsEditable() || !GetFocusObject() || !CanInsertContent(* GetFocusObject(), m_caretPosition+1))
3146         return false;
3147
3148     return GetBuffer().CanPasteFromClipboard();
3149 }
3150
3151 bool wxRichTextCtrl::CanDeleteSelection() const
3152 {
3153     return HasSelection() && IsEditable() && CanDeleteRange(* GetFocusObject(), GetSelectionRange());
3154 }
3155
3156
3157 // ----------------------------------------------------------------------------
3158 // Accessors
3159 // ----------------------------------------------------------------------------
3160
3161 void wxRichTextCtrl::SetContextMenu(wxMenu* menu)
3162 {
3163     if (m_contextMenu && m_contextMenu != menu)
3164         delete m_contextMenu;
3165     m_contextMenu = menu;
3166 }
3167
3168 void wxRichTextCtrl::SetEditable(bool editable)
3169 {
3170     m_editable = editable;
3171 }
3172
3173 void wxRichTextCtrl::SetInsertionPoint(long pos)
3174 {
3175     SelectNone();
3176
3177     m_caretPosition = pos - 1;
3178     m_caretAtLineStart = true;
3179
3180     PositionCaret();
3181
3182     SetDefaultStyleToCursorStyle();
3183 }
3184
3185 void wxRichTextCtrl::SetInsertionPointEnd()
3186 {
3187     long pos = GetLastPosition();
3188     SetInsertionPoint(pos);
3189 }
3190
3191 long wxRichTextCtrl::GetInsertionPoint() const
3192 {
3193     return m_caretPosition+1;
3194 }
3195
3196 wxTextPos wxRichTextCtrl::GetLastPosition() const
3197 {
3198     return GetFocusObject()->GetOwnRange().GetEnd();
3199 }
3200
3201 // If the return values from and to are the same, there is no
3202 // selection.
3203 void wxRichTextCtrl::GetSelection(long* from, long* to) const
3204 {
3205     if (m_selection.IsValid())
3206     {
3207         *from = m_selection.GetRange().GetStart();
3208         *to = m_selection.GetRange().GetEnd();
3209         (*to) ++;
3210     }
3211     else
3212     {
3213         *from = -2;
3214         *to = -2;
3215     }
3216 }
3217
3218 bool wxRichTextCtrl::IsEditable() const
3219 {
3220     return m_editable;
3221 }
3222
3223 // ----------------------------------------------------------------------------
3224 // selection
3225 // ----------------------------------------------------------------------------
3226
3227 void wxRichTextCtrl::SetSelection(long from, long to)
3228 {
3229     // if from and to are both -1, it means (in wxWidgets) that all text should
3230     // be selected.
3231     if ( (from == -1) && (to == -1) )
3232     {
3233         from = 0;
3234         to = GetLastPosition()+1;
3235     }
3236
3237     if (from == to)
3238     {
3239         SelectNone();
3240     }
3241     else
3242     {
3243         wxRichTextSelection oldSelection = m_selection;
3244
3245         m_selectionAnchor = from-1;
3246         m_selectionAnchorObject = NULL;
3247         m_selection.Set(wxRichTextRange(from, to-1), GetFocusObject());
3248
3249         m_caretPosition = wxMax(-1, to-1);
3250
3251         RefreshForSelectionChange(oldSelection, m_selection);
3252         PositionCaret();
3253     }
3254 }
3255
3256 // ----------------------------------------------------------------------------
3257 // Editing
3258 // ----------------------------------------------------------------------------
3259
3260 void wxRichTextCtrl::Replace(long from, long to,
3261                              const wxString& value)
3262 {
3263     BeginBatchUndo(_("Replace"));
3264
3265     SetSelection(from, to);
3266
3267     wxRichTextAttr attr(GetDefaultStyle());
3268
3269     DeleteSelectedContent();
3270
3271     SetDefaultStyle(attr);
3272
3273     if (!value.IsEmpty())
3274         DoWriteText(value, SetValue_SelectionOnly);
3275
3276     EndBatchUndo();
3277 }
3278
3279 void wxRichTextCtrl::Remove(long from, long to)
3280 {
3281     SelectNone();
3282
3283     GetFocusObject()->DeleteRangeWithUndo(wxRichTextRange(from, to-1), this, & GetBuffer());
3284
3285     LayoutContent();
3286     if (!IsFrozen())
3287         Refresh(false);
3288 }
3289
3290 bool wxRichTextCtrl::IsModified() const
3291 {
3292     return m_buffer.IsModified();
3293 }
3294
3295 void wxRichTextCtrl::MarkDirty()
3296 {
3297     m_buffer.Modify(true);
3298 }
3299
3300 void wxRichTextCtrl::DiscardEdits()
3301 {
3302     m_caretPositionForDefaultStyle = -2;
3303     m_buffer.Modify(false);
3304     m_buffer.GetCommandProcessor()->ClearCommands();
3305 }
3306
3307 int wxRichTextCtrl::GetNumberOfLines() const
3308 {
3309     return GetFocusObject()->GetParagraphCount();
3310 }
3311
3312 // ----------------------------------------------------------------------------
3313 // Positions <-> coords
3314 // ----------------------------------------------------------------------------
3315
3316 long wxRichTextCtrl::XYToPosition(long x, long y) const
3317 {
3318     return GetFocusObject()->XYToPosition(x, y);
3319 }
3320
3321 bool wxRichTextCtrl::PositionToXY(long pos, long *x, long *y) const
3322 {
3323     return GetFocusObject()->PositionToXY(pos, x, y);
3324 }
3325
3326 // ----------------------------------------------------------------------------
3327 //
3328 // ----------------------------------------------------------------------------
3329
3330 void wxRichTextCtrl::ShowPosition(long pos)
3331 {
3332     if (!IsPositionVisible(pos))
3333         ScrollIntoView(pos-1, WXK_DOWN);
3334 }
3335
3336 int wxRichTextCtrl::GetLineLength(long lineNo) const
3337 {
3338     return GetFocusObject()->GetParagraphLength(lineNo);
3339 }
3340
3341 wxString wxRichTextCtrl::GetLineText(long lineNo) const
3342 {
3343     return GetFocusObject()->GetParagraphText(lineNo);
3344 }
3345
3346 // ----------------------------------------------------------------------------
3347 // Undo/redo
3348 // ----------------------------------------------------------------------------
3349
3350 void wxRichTextCtrl::Undo()
3351 {
3352     if (CanUndo())
3353     {
3354         GetCommandProcessor()->Undo();
3355     }
3356 }
3357
3358 void wxRichTextCtrl::Redo()
3359 {
3360     if (CanRedo())
3361     {
3362         GetCommandProcessor()->Redo();
3363     }
3364 }
3365
3366 bool wxRichTextCtrl::CanUndo() const
3367 {
3368     return GetCommandProcessor()->CanUndo() && IsEditable();
3369 }
3370
3371 bool wxRichTextCtrl::CanRedo() const
3372 {
3373     return GetCommandProcessor()->CanRedo() && IsEditable();
3374 }
3375
3376 // ----------------------------------------------------------------------------
3377 // implementation details
3378 // ----------------------------------------------------------------------------
3379
3380 void wxRichTextCtrl::Command(wxCommandEvent& event)
3381 {
3382     SetValue(event.GetString());
3383     GetEventHandler()->ProcessEvent(event);
3384 }
3385
3386 void wxRichTextCtrl::OnDropFiles(wxDropFilesEvent& event)
3387 {
3388     // By default, load the first file into the text window.
3389     if (event.GetNumberOfFiles() > 0)
3390     {
3391         LoadFile(event.GetFiles()[0]);
3392     }
3393 }
3394
3395 wxSize wxRichTextCtrl::DoGetBestSize() const
3396 {
3397     return wxSize(10, 10);
3398 }
3399
3400 // ----------------------------------------------------------------------------
3401 // standard handlers for standard edit menu events
3402 // ----------------------------------------------------------------------------
3403
3404 void wxRichTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
3405 {
3406     Cut();
3407 }
3408
3409 void wxRichTextCtrl::OnClear(wxCommandEvent& WXUNUSED(event))
3410 {
3411     DeleteSelection();
3412 }
3413
3414 void wxRichTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
3415 {
3416     Copy();
3417 }
3418
3419 void wxRichTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
3420 {
3421     Paste();
3422 }
3423
3424 void wxRichTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
3425 {
3426     Undo();
3427 }
3428
3429 void wxRichTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
3430 {
3431     Redo();
3432 }
3433
3434 void wxRichTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
3435 {
3436     event.Enable( CanCut() );
3437 }
3438
3439 void wxRichTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
3440 {
3441     event.Enable( CanCopy() );
3442 }
3443
3444 void wxRichTextCtrl::OnUpdateClear(wxUpdateUIEvent& event)
3445 {
3446     event.Enable( CanDeleteSelection() );
3447 }
3448
3449 void wxRichTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
3450 {
3451     event.Enable( CanPaste() );
3452 }
3453
3454 void wxRichTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
3455 {
3456     event.Enable( CanUndo() );
3457     event.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
3458 }
3459
3460 void wxRichTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
3461 {
3462     event.Enable( CanRedo() );
3463     event.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
3464 }
3465
3466 void wxRichTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
3467 {
3468     if (GetLastPosition() > 0)
3469         SelectAll();
3470 }
3471
3472 void wxRichTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
3473 {
3474     event.Enable(GetLastPosition() > 0);
3475 }
3476
3477 void wxRichTextCtrl::OnProperties(wxCommandEvent& event)
3478 {
3479     int idx = event.GetId() - wxID_RICHTEXT_PROPERTIES1;
3480     if (idx >= 0 && idx < m_contextMenuPropertiesInfo.GetCount())
3481     {
3482         wxRichTextObject* obj = m_contextMenuPropertiesInfo.GetObject(idx);
3483         if (obj && CanEditProperties(obj))
3484             EditProperties(obj, this);
3485
3486         m_contextMenuPropertiesInfo.Clear();
3487     }
3488 }
3489
3490 void wxRichTextCtrl::OnUpdateProperties(wxUpdateUIEvent& event)
3491 {
3492     int idx = event.GetId() - wxID_RICHTEXT_PROPERTIES1;
3493     event.Enable(idx >= 0 && idx < m_contextMenuPropertiesInfo.GetCount());
3494 }
3495
3496 void wxRichTextCtrl::OnContextMenu(wxContextMenuEvent& event)
3497 {
3498     if (event.GetEventObject() != this)
3499     {
3500         event.Skip();
3501         return;
3502     }
3503
3504     ShowContextMenu(m_contextMenu, event.GetPosition());
3505 }
3506
3507 // Prepares the context menu, adding appropriate property-editing commands.
3508 // Returns the number of property commands added.
3509 int wxRichTextCtrl::PrepareContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands)
3510 {
3511     wxClientDC dc(this);
3512     PrepareDC(dc);
3513     dc.SetFont(GetFont());
3514
3515     m_contextMenuPropertiesInfo.Clear();
3516
3517     long position = 0;
3518     wxRichTextObject* hitObj = NULL;
3519     wxRichTextObject* contextObj = NULL;
3520     if (pt != wxDefaultPosition)
3521     {
3522         wxPoint logicalPt = GetLogicalPoint(ScreenToClient(pt));
3523         wxRichTextDrawingContext context(& GetBuffer());
3524         int hit = GetBuffer().HitTest(dc, context, GetUnscaledPoint(logicalPt), position, & hitObj, & contextObj);
3525
3526         if (hit == wxRICHTEXT_HITTEST_ON || hit == wxRICHTEXT_HITTEST_BEFORE || hit == wxRICHTEXT_HITTEST_AFTER)
3527         {
3528             wxRichTextParagraphLayoutBox* actualContainer = wxDynamicCast(contextObj, wxRichTextParagraphLayoutBox);
3529             if (hitObj && actualContainer)
3530             {
3531                 if (actualContainer->AcceptsFocus())
3532                 {
3533                     SetFocusObject(actualContainer, false /* don't set caret position yet */);
3534                     SetCaretPositionAfterClick(actualContainer, position, hit);
3535                 }
3536
3537                 if (addPropertyCommands)
3538                     m_contextMenuPropertiesInfo.AddItems(this, actualContainer, hitObj);
3539             }
3540             else
3541             {
3542                 if (addPropertyCommands)
3543                     m_contextMenuPropertiesInfo.AddItems(this, GetFocusObject(), NULL);
3544             }
3545         }
3546         else
3547         {
3548             if (addPropertyCommands)
3549                 m_contextMenuPropertiesInfo.AddItems(this, GetFocusObject(), NULL);
3550         }
3551     }
3552     else
3553     {
3554         // Invoked from the keyboard, so don't set the caret position and don't use the event
3555         // position
3556         hitObj = GetFocusObject()->GetLeafObjectAtPosition(m_caretPosition+1);
3557         if (hitObj)
3558             contextObj = hitObj->GetParentContainer();
3559         else
3560             contextObj = GetFocusObject();
3561
3562         wxRichTextParagraphLayoutBox* actualContainer = wxDynamicCast(contextObj, wxRichTextParagraphLayoutBox);
3563         if (hitObj && actualContainer)
3564         {
3565             if (addPropertyCommands)
3566                 m_contextMenuPropertiesInfo.AddItems(this, actualContainer, hitObj);
3567         }
3568         else
3569         {
3570             if (addPropertyCommands)
3571                 m_contextMenuPropertiesInfo.AddItems(this, GetFocusObject(), NULL);
3572         }
3573     }
3574
3575     if (menu)
3576     {
3577         if (addPropertyCommands)
3578             m_contextMenuPropertiesInfo.AddMenuItems(menu);
3579         return m_contextMenuPropertiesInfo.GetCount();
3580     }
3581     else
3582         return 0;
3583 }
3584
3585 // Shows the context menu, adding appropriate property-editing commands
3586 bool wxRichTextCtrl::ShowContextMenu(wxMenu* menu, const wxPoint& pt, bool addPropertyCommands)
3587 {
3588     if (menu)
3589     {
3590         PrepareContextMenu(menu, pt, addPropertyCommands);
3591         PopupMenu(menu);
3592         return true;
3593     }
3594     else
3595         return false;
3596 }
3597
3598 bool wxRichTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
3599 {
3600     return GetFocusObject()->SetStyle(wxRichTextRange(start, end-1), wxRichTextAttr(style));
3601 }
3602
3603 bool wxRichTextCtrl::SetStyle(long start, long end, const wxRichTextAttr& style)
3604 {
3605     return GetFocusObject()->SetStyle(wxRichTextRange(start, end-1), style);
3606 }
3607
3608 bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxTextAttr& style)
3609 {
3610     return GetFocusObject()->SetStyle(range.ToInternal(), wxRichTextAttr(style));
3611 }
3612
3613 bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style)
3614 {
3615     return GetFocusObject()->SetStyle(range.ToInternal(), style);
3616 }
3617
3618 void wxRichTextCtrl::SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags)
3619 {
3620     GetFocusObject()->SetStyle(obj, textAttr, flags);
3621 }
3622
3623 // extended style setting operation with flags including:
3624 // wxRICHTEXT_SETSTYLE_WITH_UNDO, wxRICHTEXT_SETSTYLE_OPTIMIZE, wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY.
3625 // see richtextbuffer.h for more details.
3626
3627 bool wxRichTextCtrl::SetStyleEx(const wxRichTextRange& range, const wxRichTextAttr& style, int flags)
3628 {
3629     return GetFocusObject()->SetStyle(range.ToInternal(), style, flags);
3630 }
3631
3632 bool wxRichTextCtrl::SetDefaultStyle(const wxTextAttr& style)
3633 {
3634     return GetBuffer().SetDefaultStyle(style);
3635 }
3636
3637 bool wxRichTextCtrl::SetDefaultStyle(const wxRichTextAttr& style)
3638 {
3639     wxRichTextAttr attr1(style);
3640     attr1.GetTextBoxAttr().Reset();
3641     return GetBuffer().SetDefaultStyle(attr1);
3642 }
3643
3644 const wxRichTextAttr& wxRichTextCtrl::GetDefaultStyleEx() const
3645 {
3646     return GetBuffer().GetDefaultStyle();
3647 }
3648
3649 bool wxRichTextCtrl::GetStyle(long position, wxTextAttr& style)
3650 {
3651     wxRichTextAttr attr;
3652     if (GetFocusObject()->GetStyle(position, attr))
3653     {
3654         style = attr;
3655         return true;
3656     }
3657     else
3658         return false;
3659 }
3660
3661 bool wxRichTextCtrl::GetStyle(long position, wxRichTextAttr& style)
3662 {
3663     return GetFocusObject()->GetStyle(position, style);
3664 }
3665
3666 bool wxRichTextCtrl::GetStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container)
3667 {
3668     wxRichTextAttr attr;
3669     if (container->GetStyle(position, attr))
3670     {
3671         style = attr;
3672         return true;
3673     }
3674     else
3675         return false;
3676 }
3677
3678 // get the common set of styles for the range
3679 bool wxRichTextCtrl::GetStyleForRange(const wxRichTextRange& range, wxTextAttr& style)
3680 {
3681     wxRichTextAttr attr;
3682     if (GetFocusObject()->GetStyleForRange(range.ToInternal(), attr))
3683     {
3684         style = attr;
3685         return true;
3686     }
3687     else
3688         return false;
3689 }
3690
3691 bool wxRichTextCtrl::GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style)
3692 {
3693     return GetFocusObject()->GetStyleForRange(range.ToInternal(), style);
3694 }
3695
3696 bool wxRichTextCtrl::GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container)
3697 {
3698     return container->GetStyleForRange(range.ToInternal(), style);
3699 }
3700
3701 /// Get the content (uncombined) attributes for this position.
3702 bool wxRichTextCtrl::GetUncombinedStyle(long position, wxRichTextAttr& style)
3703 {
3704     return GetFocusObject()->GetUncombinedStyle(position, style);
3705 }
3706
3707 /// Get the content (uncombined) attributes for this position.
3708 bool wxRichTextCtrl::GetUncombinedStyle(long position, wxRichTextAttr& style, wxRichTextParagraphLayoutBox* container)
3709 {
3710     return container->GetUncombinedStyle(position, style);
3711 }
3712
3713 bool wxRichTextCtrl::SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags)
3714 {
3715     return GetFocusObject()->SetProperties(range.ToInternal(), properties, flags);
3716 }
3717
3718 /// Set font, and also the buffer attributes
3719 bool wxRichTextCtrl::SetFont(const wxFont& font)
3720 {
3721     wxControl::SetFont(font);
3722
3723     wxRichTextAttr attr = GetBuffer().GetAttributes();
3724     attr.SetFont(font);
3725     GetBuffer().SetBasicStyle(attr);
3726
3727     GetBuffer().Invalidate(wxRICHTEXT_ALL);
3728     Refresh(false);
3729
3730     return true;
3731 }
3732
3733 /// Transform logical to physical
3734 wxPoint wxRichTextCtrl::GetPhysicalPoint(const wxPoint& ptLogical) const
3735 {
3736     wxPoint pt;
3737     CalcScrolledPosition(ptLogical.x, ptLogical.y, & pt.x, & pt.y);
3738
3739     return pt;
3740 }
3741
3742 /// Transform physical to logical
3743 wxPoint wxRichTextCtrl::GetLogicalPoint(const wxPoint& ptPhysical) const
3744 {
3745     wxPoint pt;
3746     CalcUnscrolledPosition(ptPhysical.x, ptPhysical.y, & pt.x, & pt.y);
3747
3748     return pt;
3749 }
3750
3751 /// Position the caret
3752 void wxRichTextCtrl::PositionCaret(wxRichTextParagraphLayoutBox* container)
3753 {
3754     if (!GetCaret())
3755         return;
3756
3757     //wxLogDebug(wxT("PositionCaret"));
3758
3759     wxRect caretRect;
3760     if (GetCaretPositionForIndex(GetCaretPosition(), caretRect, container))
3761     {
3762 #if !wxRICHTEXT_USE_OWN_CARET
3763         caretRect = GetScaledRect(caretRect);
3764 #endif
3765         int topMargin = (int) (0.5 + GetScale()*GetBuffer().GetTopMargin());
3766         int bottomMargin = (int) (0.5 + GetScale()*GetBuffer().GetBottomMargin());
3767         wxPoint newPt = caretRect.GetPosition();
3768         wxSize newSz = caretRect.GetSize();
3769         wxPoint pt = GetPhysicalPoint(newPt);
3770         if (GetCaret()->GetPosition() != pt || GetCaret()->GetSize() != newSz)
3771         {
3772             GetCaret()->Hide();
3773             if (GetCaret()->GetSize() != newSz)
3774                 GetCaret()->SetSize(newSz);
3775
3776             // Adjust size so the caret size and position doesn't appear in the margins
3777             if (((pt.y + newSz.y) <= topMargin) || (pt.y >= (GetClientSize().y - bottomMargin)))
3778             {
3779                 pt.x = -200;
3780                 pt.y = -200;
3781             }
3782             else if (pt.y < topMargin && (pt.y + newSz.y) > topMargin)
3783             {
3784                 newSz.y -= (topMargin - pt.y);
3785                 if (newSz.y > 0)
3786                 {
3787                     pt.y = topMargin;
3788                     GetCaret()->SetSize(newSz);
3789                 }
3790             }
3791             else if (pt.y < (GetClientSize().y - bottomMargin) && (pt.y + newSz.y) > (GetClientSize().y - bottomMargin))
3792             {
3793                 newSz.y = GetClientSize().y - bottomMargin - pt.y;
3794                 GetCaret()->SetSize(newSz);
3795             }
3796
3797             GetCaret()->Move(pt);
3798             GetCaret()->Show();
3799         }
3800     }
3801 }
3802
3803 /// Get the caret height and position for the given character position
3804 bool wxRichTextCtrl::GetCaretPositionForIndex(long position, wxRect& rect, wxRichTextParagraphLayoutBox* container)
3805 {
3806     wxClientDC dc(this);
3807     PrepareDC(dc);
3808     dc.SetUserScale(GetScale(), GetScale());
3809     dc.SetFont(GetFont());
3810
3811     wxPoint pt;
3812     int height = 0;
3813
3814     if (!container)
3815         container = GetFocusObject();
3816
3817     wxRichTextDrawingContext context(& GetBuffer());
3818     if (container->FindPosition(dc, context, position, pt, & height, m_caretAtLineStart))
3819     {
3820         // Caret height can't be zero
3821         if (height == 0)
3822             height = dc.GetCharHeight();
3823
3824         rect = wxRect(pt, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH, height));
3825         return true;
3826     }
3827
3828     return false;
3829 }
3830
3831 /// Gets the line for the visible caret position. If the caret is
3832 /// shown at the very end of the line, it means the next character is actually
3833 /// on the following line. So let's get the line we're expecting to find
3834 /// if this is the case.
3835 wxRichTextLine* wxRichTextCtrl::GetVisibleLineForCaretPosition(long caretPosition) const
3836 {
3837     wxRichTextLine* line = GetFocusObject()->GetLineAtPosition(caretPosition, true);
3838     wxRichTextParagraph* para = GetFocusObject()->GetParagraphAtPosition(caretPosition, true);
3839     if (line)
3840     {
3841         wxRichTextRange lineRange = line->GetAbsoluteRange();
3842         if (caretPosition == lineRange.GetStart()-1 &&
3843             (para->GetRange().GetStart() != lineRange.GetStart()))
3844         {
3845             if (!m_caretAtLineStart)
3846                 line = GetFocusObject()->GetLineAtPosition(caretPosition-1, true);
3847         }
3848     }
3849     return line;
3850 }
3851
3852
3853 /// Move the caret to the given character position
3854 bool wxRichTextCtrl::MoveCaret(long pos, bool showAtLineStart, wxRichTextParagraphLayoutBox* container)
3855 {
3856     if (GetBuffer().IsDirty())
3857         LayoutContent();
3858
3859     if (!container)
3860         container = GetFocusObject();
3861
3862     if (pos <= container->GetOwnRange().GetEnd())
3863     {
3864         SetCaretPosition(pos, showAtLineStart);
3865
3866         PositionCaret(container);
3867
3868         return true;
3869     }
3870     else
3871         return false;
3872 }
3873
3874 /// Layout the buffer: which we must do before certain operations, such as
3875 /// setting the caret position.
3876 bool wxRichTextCtrl::LayoutContent(bool onlyVisibleRect)
3877 {
3878     if (GetBuffer().IsDirty() || onlyVisibleRect)
3879     {
3880         wxRect availableSpace(GetUnscaledSize(GetClientSize()));
3881         if (availableSpace.width == 0)
3882             availableSpace.width = 10;
3883         if (availableSpace.height == 0)
3884             availableSpace.height = 10;
3885
3886         int flags = wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT;
3887         if (onlyVisibleRect)
3888         {
3889             flags |= wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
3890             availableSpace.SetPosition(GetUnscaledPoint(GetLogicalPoint(wxPoint(0, 0))));
3891         }
3892
3893         wxClientDC dc(this);
3894
3895         PrepareDC(dc);
3896         dc.SetFont(GetFont());
3897         dc.SetUserScale(GetScale(), GetScale());
3898
3899         wxRichTextDrawingContext context(& GetBuffer());
3900         GetBuffer().Defragment(context);
3901         GetBuffer().UpdateRanges();     // If items were deleted, ranges need recalculation
3902         GetBuffer().Layout(dc, context, availableSpace, availableSpace, flags);
3903         GetBuffer().Invalidate(wxRICHTEXT_NONE);
3904
3905         dc.SetUserScale(1.0, 1.0);
3906
3907         if (!IsFrozen() && !onlyVisibleRect)
3908             SetupScrollbars();
3909     }
3910
3911     return true;
3912 }
3913
3914 /// Is all of the selection, or the current caret position, bold?
3915 bool wxRichTextCtrl::IsSelectionBold()
3916 {
3917     if (HasSelection())
3918     {
3919         wxRichTextAttr attr;
3920         wxRichTextRange range = GetSelectionRange();
3921         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
3922         attr.SetFontWeight(wxFONTWEIGHT_BOLD);
3923
3924         return HasCharacterAttributes(range, attr);
3925     }
3926     else
3927     {
3928         // If no selection, then we need to combine current style with default style
3929         // to see what the effect would be if we started typing.
3930         wxRichTextAttr attr;
3931         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
3932
3933         long pos = GetAdjustedCaretPosition(GetCaretPosition());
3934         if (GetStyle(pos, attr))
3935         {
3936             if (IsDefaultStyleShowing())
3937                 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3938             return attr.GetFontWeight() == wxFONTWEIGHT_BOLD;
3939         }
3940     }
3941     return false;
3942 }
3943
3944 /// Is all of the selection, or the current caret position, italics?
3945 bool wxRichTextCtrl::IsSelectionItalics()
3946 {
3947     if (HasSelection())
3948     {
3949         wxRichTextRange range = GetSelectionRange();
3950         wxRichTextAttr attr;
3951         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
3952         attr.SetFontStyle(wxFONTSTYLE_ITALIC);
3953
3954         return HasCharacterAttributes(range, attr);
3955     }
3956     else
3957     {
3958         // If no selection, then we need to combine current style with default style
3959         // to see what the effect would be if we started typing.
3960         wxRichTextAttr attr;
3961         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
3962
3963         long pos = GetAdjustedCaretPosition(GetCaretPosition());
3964         if (GetStyle(pos, attr))
3965         {
3966             if (IsDefaultStyleShowing())
3967                 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3968             return attr.GetFontStyle() == wxFONTSTYLE_ITALIC;
3969         }
3970     }
3971     return false;
3972 }
3973
3974 /// Is all of the selection, or the current caret position, underlined?
3975 bool wxRichTextCtrl::IsSelectionUnderlined()
3976 {
3977     if (HasSelection())
3978     {
3979         wxRichTextRange range = GetSelectionRange();
3980         wxRichTextAttr attr;
3981         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
3982         attr.SetFontUnderlined(true);
3983
3984         return HasCharacterAttributes(range, attr);
3985     }
3986     else
3987     {
3988         // If no selection, then we need to combine current style with default style
3989         // to see what the effect would be if we started typing.
3990         wxRichTextAttr attr;
3991         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
3992         long pos = GetAdjustedCaretPosition(GetCaretPosition());
3993
3994         if (GetStyle(pos, attr))
3995         {
3996             if (IsDefaultStyleShowing())
3997                 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
3998             return attr.GetFontUnderlined();
3999         }
4000     }
4001     return false;
4002 }
4003
4004 /// Does all of the selection, or the current caret position, have this wxTextAttrEffects flag(s)?
4005 bool wxRichTextCtrl::DoesSelectionHaveTextEffectFlag(int flag)
4006 {
4007     wxRichTextAttr attr;
4008     attr.SetFlags(wxTEXT_ATTR_EFFECTS);
4009     attr.SetTextEffectFlags(flag);
4010     attr.SetTextEffects(flag);
4011
4012     if (HasSelection())
4013     {
4014         return HasCharacterAttributes(GetSelectionRange(), attr);
4015     }
4016     else
4017     {
4018         // If no selection, then we need to combine current style with default style
4019         // to see what the effect would be if we started typing.
4020         long pos = GetAdjustedCaretPosition(GetCaretPosition());
4021         if (GetStyle(pos, attr))
4022         {
4023             if (IsDefaultStyleShowing())
4024                 wxRichTextApplyStyle(attr, GetDefaultStyleEx());
4025             return (attr.GetTextEffectFlags() & flag) != 0;
4026         }
4027     }
4028     return false;
4029 }
4030
4031 /// Apply bold to the selection
4032 bool wxRichTextCtrl::ApplyBoldToSelection()
4033 {
4034     wxRichTextAttr attr;
4035     attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
4036     attr.SetFontWeight(IsSelectionBold() ? wxFONTWEIGHT_NORMAL : wxFONTWEIGHT_BOLD);
4037
4038     if (HasSelection())
4039         return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
4040     else
4041     {
4042         wxRichTextAttr current = GetDefaultStyleEx();
4043         current.Apply(attr);
4044         SetAndShowDefaultStyle(current);
4045     }
4046     return true;
4047 }
4048
4049 /// Apply italic to the selection
4050 bool wxRichTextCtrl::ApplyItalicToSelection()
4051 {
4052     wxRichTextAttr attr;
4053     attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
4054     attr.SetFontStyle(IsSelectionItalics() ? wxFONTSTYLE_NORMAL : wxFONTSTYLE_ITALIC);
4055
4056     if (HasSelection())
4057         return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
4058     else
4059     {
4060         wxRichTextAttr current = GetDefaultStyleEx();
4061         current.Apply(attr);
4062         SetAndShowDefaultStyle(current);
4063     }
4064     return true;
4065 }
4066
4067 /// Apply underline to the selection
4068 bool wxRichTextCtrl::ApplyUnderlineToSelection()
4069 {
4070     wxRichTextAttr attr;
4071     attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
4072     attr.SetFontUnderlined(!IsSelectionUnderlined());
4073
4074     if (HasSelection())
4075         return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
4076     else
4077     {
4078         wxRichTextAttr current = GetDefaultStyleEx();
4079         current.Apply(attr);
4080         SetAndShowDefaultStyle(current);
4081     }
4082     return true;
4083 }
4084
4085 /// Apply the wxTextAttrEffects flag(s) to the selection, or the current caret position if there's no selection
4086 bool wxRichTextCtrl::ApplyTextEffectToSelection(int flags)
4087 {
4088     wxRichTextAttr attr;
4089     attr.SetFlags(wxTEXT_ATTR_EFFECTS);
4090     attr.SetTextEffectFlags(flags);
4091     if (!DoesSelectionHaveTextEffectFlag(flags))
4092         attr.SetTextEffects(flags);
4093      else
4094         attr.SetTextEffects(attr.GetTextEffectFlags() & ~flags);
4095
4096     if (HasSelection())
4097         return SetStyleEx(GetSelectionRange(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY);
4098     else
4099     {
4100         wxRichTextAttr current = GetDefaultStyleEx();
4101         current.Apply(attr);
4102         SetAndShowDefaultStyle(current);
4103     }
4104     return true;
4105 }
4106
4107 /// Is all of the selection aligned according to the specified flag?
4108 bool wxRichTextCtrl::IsSelectionAligned(wxTextAttrAlignment alignment)
4109 {
4110     wxRichTextRange range;
4111     if (HasSelection())
4112         range = GetSelectionRange();
4113     else
4114         range = wxRichTextRange(GetCaretPosition()+1, GetCaretPosition()+2);
4115
4116     wxRichTextAttr attr;
4117     attr.SetAlignment(alignment);
4118
4119     return HasParagraphAttributes(range, attr);
4120 }
4121
4122 /// Apply alignment to the selection
4123 bool wxRichTextCtrl::ApplyAlignmentToSelection(wxTextAttrAlignment alignment)
4124 {
4125     wxRichTextAttr attr;
4126     attr.SetAlignment(alignment);
4127     if (HasSelection())
4128         return SetStyle(GetSelectionRange(), attr);
4129     else
4130     {
4131         wxRichTextParagraph* para = GetFocusObject()->GetParagraphAtPosition(GetCaretPosition()+1);
4132         if (para)
4133             return SetStyleEx(para->GetRange().FromInternal(), attr, wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY);
4134     }
4135     return true;
4136 }
4137
4138 /// Apply a named style to the selection
4139 bool wxRichTextCtrl::ApplyStyle(wxRichTextStyleDefinition* def)
4140 {
4141     // Flags are defined within each definition, so only certain
4142     // attributes are applied.
4143     wxRichTextAttr attr(GetStyleSheet() ? def->GetStyleMergedWithBase(GetStyleSheet()) : def->GetStyle());
4144
4145     int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE|wxRICHTEXT_SETSTYLE_RESET;
4146
4147     if (wxDynamicCast(def, wxRichTextListStyleDefinition))
4148     {
4149         flags |= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY;
4150
4151         wxRichTextRange range;
4152
4153         if (HasSelection())
4154             range = GetSelectionRange();
4155         else
4156         {
4157             long pos = GetAdjustedCaretPosition(GetCaretPosition());
4158             range = wxRichTextRange(pos, pos+1);
4159         }
4160
4161         return SetListStyle(range, (wxRichTextListStyleDefinition*) def, flags);
4162     }
4163
4164     bool isPara = false;
4165
4166     // Make sure the attr has the style name
4167     if (wxDynamicCast(def, wxRichTextParagraphStyleDefinition))
4168     {
4169         isPara = true;
4170         attr.SetParagraphStyleName(def->GetName());
4171
4172         // If applying a paragraph style, we only want the paragraph nodes to adopt these
4173         // attributes, and not the leaf nodes. This will allow the content (e.g. text)
4174         // to change its style independently.
4175         flags |= wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY;
4176     }
4177     else if (wxDynamicCast(def, wxRichTextCharacterStyleDefinition))
4178         attr.SetCharacterStyleName(def->GetName());
4179     else if (wxDynamicCast(def, wxRichTextBoxStyleDefinition))
4180         attr.GetTextBoxAttr().SetBoxStyleName(def->GetName());
4181
4182     if (wxDynamicCast(def, wxRichTextBoxStyleDefinition))
4183     {
4184         if (GetFocusObject() && (GetFocusObject() != & GetBuffer()))
4185         {
4186             SetStyle(GetFocusObject(), attr);
4187             return true;
4188         }
4189         else
4190             return false;
4191     }
4192     else if (HasSelection())
4193         return SetStyleEx(GetSelectionRange(), attr, flags);
4194     else
4195     {
4196         wxRichTextAttr current = GetDefaultStyleEx();
4197         wxRichTextAttr defaultStyle(attr);
4198         if (isPara)
4199         {
4200             // Don't apply extra character styles since they are already implied
4201             // in the paragraph style
4202             defaultStyle.SetFlags(defaultStyle.GetFlags() & ~wxTEXT_ATTR_CHARACTER);
4203         }
4204         current.Apply(defaultStyle);
4205         SetAndShowDefaultStyle(current);
4206
4207         // If it's a paragraph style, we want to apply the style to the
4208         // current paragraph even if we didn't select any text.
4209         if (isPara)
4210         {
4211             long pos = GetAdjustedCaretPosition(GetCaretPosition());
4212             wxRichTextParagraph* para = GetFocusObject()->GetParagraphAtPosition(pos);
4213             if (para)
4214             {
4215                 return SetStyleEx(para->GetRange().FromInternal(), attr, flags);
4216             }
4217         }
4218         return true;
4219     }
4220 }
4221
4222 /// Apply the style sheet to the buffer, for example if the styles have changed.
4223 bool wxRichTextCtrl::ApplyStyleSheet(wxRichTextStyleSheet* styleSheet)
4224 {
4225     if (!styleSheet)
4226         styleSheet = GetBuffer().GetStyleSheet();
4227     if (!styleSheet)
4228         return false;
4229
4230     if (GetBuffer().ApplyStyleSheet(styleSheet))
4231     {
4232         GetBuffer().Invalidate(wxRICHTEXT_ALL);
4233         Refresh(false);
4234         return true;
4235     }
4236     else
4237         return false;
4238 }
4239
4240 /// Sets the default style to the style under the cursor
4241 bool wxRichTextCtrl::SetDefaultStyleToCursorStyle()
4242 {
4243     wxRichTextAttr attr;
4244     attr.SetFlags(wxTEXT_ATTR_CHARACTER);
4245
4246     // If at the start of a paragraph, use the next position.
4247     long pos = GetAdjustedCaretPosition(GetCaretPosition());
4248
4249     wxRichTextObject* obj = GetFocusObject()->GetLeafObjectAtPosition(pos);
4250     if (obj && obj->IsTopLevel())
4251     {
4252         // Don't use the attributes of a top-level object, since they might apply
4253         // to content of the object, e.g. background colour.
4254         SetDefaultStyle(wxRichTextAttr());
4255         return true;
4256     }
4257     else if (GetUncombinedStyle(pos, attr))
4258     {
4259         SetDefaultStyle(attr);
4260         return true;
4261     }
4262
4263     return false;
4264 }
4265
4266 /// Returns the first visible position in the current view
4267 long wxRichTextCtrl::GetFirstVisiblePosition() const
4268 {
4269     wxRichTextLine* line = GetFocusObject()->GetLineAtYPosition(GetUnscaledPoint(GetLogicalPoint(wxPoint(0, 0))).y);
4270     if (line)
4271         return line->GetAbsoluteRange().GetStart();
4272     else
4273         return 0;
4274 }
4275
4276 /// Get the first visible point in the window
4277 wxPoint wxRichTextCtrl::GetFirstVisiblePoint() const
4278 {
4279     int ppuX, ppuY;
4280     int startXUnits, startYUnits;
4281
4282     GetScrollPixelsPerUnit(& ppuX, & ppuY);
4283     GetViewStart(& startXUnits, & startYUnits);
4284
4285     return wxPoint(startXUnits * ppuX, startYUnits * ppuY);
4286 }
4287
4288 /// The adjusted caret position is the character position adjusted to take
4289 /// into account whether we're at the start of a paragraph, in which case
4290 /// style information should be taken from the next position, not current one.
4291 long wxRichTextCtrl::GetAdjustedCaretPosition(long caretPos) const
4292 {
4293     wxRichTextParagraph* para = GetFocusObject()->GetParagraphAtPosition(caretPos+1);
4294
4295     if (para && (caretPos+1 == para->GetRange().GetStart()))
4296         caretPos ++;
4297     return caretPos;
4298 }
4299
4300 /// Get/set the selection range in character positions. -1, -1 means no selection.
4301 /// The range is in API convention, i.e. a single character selection is denoted
4302 /// by (n, n+1)
4303 wxRichTextRange wxRichTextCtrl::GetSelectionRange() const
4304 {
4305     wxRichTextRange range = GetInternalSelectionRange();
4306     if (range != wxRichTextRange(-2,-2) && range != wxRichTextRange(-1,-1))
4307         range.SetEnd(range.GetEnd() + 1);
4308     return range;
4309 }
4310
4311 void wxRichTextCtrl::SetSelectionRange(const wxRichTextRange& range)
4312 {
4313     SetSelection(range.GetStart(), range.GetEnd());
4314 }
4315
4316 /// Set list style
4317 bool wxRichTextCtrl::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
4318 {
4319     return GetFocusObject()->SetListStyle(range.ToInternal(), def, flags, startFrom, specifiedLevel);
4320 }
4321
4322 bool wxRichTextCtrl::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
4323 {
4324     return GetFocusObject()->SetListStyle(range.ToInternal(), defName, flags, startFrom, specifiedLevel);
4325 }
4326
4327 /// Clear list for given range
4328 bool wxRichTextCtrl::ClearListStyle(const wxRichTextRange& range, int flags)
4329 {
4330     return GetFocusObject()->ClearListStyle(range.ToInternal(), flags);
4331 }
4332
4333 /// Number/renumber any list elements in the given range
4334 bool wxRichTextCtrl::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
4335 {
4336     return GetFocusObject()->NumberList(range.ToInternal(), def, flags, startFrom, specifiedLevel);
4337 }
4338
4339 bool wxRichTextCtrl::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
4340 {
4341     return GetFocusObject()->NumberList(range.ToInternal(), defName, flags, startFrom, specifiedLevel);
4342 }
4343
4344 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
4345 bool wxRichTextCtrl::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
4346 {
4347     return GetFocusObject()->PromoteList(promoteBy, range.ToInternal(), def, flags, specifiedLevel);
4348 }
4349
4350 bool wxRichTextCtrl::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
4351 {
4352     return GetFocusObject()->PromoteList(promoteBy, range.ToInternal(), defName, flags, specifiedLevel);
4353 }
4354
4355 // Given a character position at which there is a list style, find the range
4356 // encompassing the same list style by looking backwards and forwards.
4357 wxRichTextRange wxRichTextCtrl::FindRangeForList(long pos, bool& isNumberedList)
4358 {
4359     wxRichTextParagraphLayoutBox* focusObject = GetFocusObject();
4360     wxRichTextRange range = wxRichTextRange(-1, -1);
4361     wxRichTextParagraph* para = focusObject->GetParagraphAtPosition(pos);
4362     if (!para || !para->GetAttributes().HasListStyleName())
4363         return range;
4364     else
4365     {
4366         wxString listStyle = para->GetAttributes().GetListStyleName();
4367         range = para->GetRange();
4368
4369         isNumberedList = para->GetAttributes().HasBulletNumber();
4370
4371         // Search back
4372         wxRichTextObjectList::compatibility_iterator initialNode = focusObject->GetChildren().Find(para);
4373         if (initialNode)
4374         {
4375             wxRichTextObjectList::compatibility_iterator startNode = initialNode->GetPrevious();
4376             while (startNode)
4377             {
4378                 wxRichTextParagraph* p = wxDynamicCast(startNode->GetData(), wxRichTextParagraph);
4379                 if (p)
4380                 {
4381                     if (!p->GetAttributes().HasListStyleName() || p->GetAttributes().GetListStyleName() != listStyle)
4382                         break;
4383                     else
4384                         range.SetStart(p->GetRange().GetStart());
4385                 }
4386
4387                 startNode = startNode->GetPrevious();
4388             }
4389
4390             // Search forward
4391             wxRichTextObjectList::compatibility_iterator endNode = initialNode->GetNext();
4392             while (endNode)
4393             {
4394                 wxRichTextParagraph* p = wxDynamicCast(endNode->GetData(), wxRichTextParagraph);
4395                 if (p)
4396                 {
4397                     if (!p->GetAttributes().HasListStyleName() || p->GetAttributes().GetListStyleName() != listStyle)
4398                         break;
4399                     else
4400                         range.SetEnd(p->GetRange().GetEnd());
4401                 }
4402
4403                 endNode = endNode->GetNext();
4404             }
4405         }
4406     }
4407     return range;
4408 }
4409
4410 /// Deletes the content in the given range
4411 bool wxRichTextCtrl::Delete(const wxRichTextRange& range)
4412 {
4413     return GetFocusObject()->DeleteRangeWithUndo(range.ToInternal(), this, & GetBuffer());
4414 }
4415
4416 const wxArrayString& wxRichTextCtrl::GetAvailableFontNames()
4417 {
4418     if (sm_availableFontNames.GetCount() == 0)
4419     {
4420         sm_availableFontNames = wxFontEnumerator::GetFacenames();
4421         sm_availableFontNames.Sort();
4422     }
4423     return sm_availableFontNames;
4424 }
4425
4426 void wxRichTextCtrl::ClearAvailableFontNames()
4427 {
4428     sm_availableFontNames.Clear();
4429 }
4430
4431 void wxRichTextCtrl::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
4432 {
4433     //wxLogDebug(wxT("wxRichTextCtrl::OnSysColourChanged"));
4434
4435     wxTextAttrEx basicStyle = GetBasicStyle();
4436     basicStyle.SetTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
4437     SetBasicStyle(basicStyle);
4438     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
4439
4440     Refresh();
4441 }
4442
4443 // Refresh the area affected by a selection change
4444 bool wxRichTextCtrl::RefreshForSelectionChange(const wxRichTextSelection& oldSelection, const wxRichTextSelection& newSelection)
4445 {
4446     // If the selection is not part of the focus object, or we have multiple ranges, then the chances are that
4447     // the selection contains whole containers rather than just text, so refresh everything
4448     // for now as it would be hard to compute the rectangle bounding all selections.
4449     // TODO: improve on this.
4450     if ((oldSelection.IsValid() && (oldSelection.GetContainer() != GetFocusObject() || oldSelection.GetCount() > 1)) ||
4451         (newSelection.IsValid() && (newSelection.GetContainer() != GetFocusObject() || newSelection.GetCount() > 1)))
4452     {
4453         Refresh(false);
4454         return true;
4455     }
4456
4457     wxRichTextRange oldRange, newRange;
4458     if (oldSelection.IsValid())
4459         oldRange = oldSelection.GetRange();
4460     else
4461         oldRange = wxRICHTEXT_NO_SELECTION;
4462     if (newSelection.IsValid())
4463         newRange = newSelection.GetRange();
4464     else
4465         newRange = wxRICHTEXT_NO_SELECTION;
4466
4467     // Calculate the refresh rectangle - just the affected lines
4468     long firstPos, lastPos;
4469     if (oldRange.GetStart() == -2 && newRange.GetStart() != -2)
4470     {
4471         firstPos = newRange.GetStart();
4472         lastPos = newRange.GetEnd();
4473     }
4474     else if (oldRange.GetStart() != -2 && newRange.GetStart() == -2)
4475     {
4476         firstPos = oldRange.GetStart();
4477         lastPos = oldRange.GetEnd();
4478     }
4479     else if (oldRange.GetStart() == -2 && newRange.GetStart() == -2)
4480     {
4481         return false;
4482     }
4483     else
4484     {
4485         firstPos = wxMin(oldRange.GetStart(), newRange.GetStart());
4486         lastPos = wxMax(oldRange.GetEnd(), newRange.GetEnd());
4487     }
4488
4489     wxRichTextLine* firstLine = GetFocusObject()->GetLineAtPosition(firstPos);
4490     wxRichTextLine* lastLine = GetFocusObject()->GetLineAtPosition(lastPos);
4491
4492     if (firstLine && lastLine)
4493     {
4494         wxSize clientSize = GetClientSize();
4495         wxPoint pt1 = GetPhysicalPoint(GetScaledPoint(firstLine->GetAbsolutePosition()));
4496         wxPoint pt2 = GetPhysicalPoint(GetScaledPoint(lastLine->GetAbsolutePosition())) + wxPoint(0, (int) (0.5 + lastLine->GetSize().y * GetScale()));
4497
4498         pt1.x = 0;
4499         pt1.y = wxMax(0, pt1.y);
4500         pt2.x = 0;
4501         pt2.y = wxMin(clientSize.y, pt2.y);
4502
4503         wxRect rect(pt1, wxSize(clientSize.x, pt2.y - pt1.y));
4504         RefreshRect(rect, false);
4505     }
4506     else
4507         Refresh(false);
4508
4509     return true;
4510 }
4511
4512 // margins functions
4513 bool wxRichTextCtrl::DoSetMargins(const wxPoint& pt)
4514 {
4515     GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetLeft().SetValue(pt.x, wxTEXT_ATTR_UNITS_PIXELS);
4516     GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetRight().SetValue(pt.x, wxTEXT_ATTR_UNITS_PIXELS);
4517     GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetTop().SetValue(pt.y, wxTEXT_ATTR_UNITS_PIXELS);
4518     GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetBottom().SetValue(pt.y, wxTEXT_ATTR_UNITS_PIXELS);
4519
4520     return true;
4521 }
4522
4523 wxPoint wxRichTextCtrl::DoGetMargins() const
4524 {
4525     return wxPoint(GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetLeft().GetValue(),
4526                    GetBuffer().GetAttributes().GetTextBoxAttr().GetMargins().GetTop().GetValue());
4527 }
4528
4529 bool wxRichTextCtrl::SetFocusObject(wxRichTextParagraphLayoutBox* obj, bool setCaretPosition)
4530 {
4531     if (obj && !obj->AcceptsFocus())
4532         return false;
4533
4534     wxRichTextParagraphLayoutBox* oldContainer = GetFocusObject();
4535     bool changingContainer = (m_focusObject != obj);
4536
4537     if (changingContainer && HasSelection())
4538         SelectNone();
4539
4540     m_focusObject = obj;
4541
4542     if (!obj)
4543         m_focusObject = & m_buffer;
4544
4545     if (setCaretPosition && changingContainer)
4546     {
4547         m_selection.Reset();
4548         m_selectionAnchor = -2;
4549         m_selectionAnchorObject = NULL;
4550         m_selectionState = wxRichTextCtrlSelectionState_Normal;
4551
4552         long pos = -1;
4553
4554         m_caretAtLineStart = false;
4555         MoveCaret(pos, m_caretAtLineStart);
4556         SetDefaultStyleToCursorStyle();
4557
4558         wxRichTextEvent cmdEvent(
4559             wxEVT_RICHTEXT_FOCUS_OBJECT_CHANGED,
4560             GetId());
4561         cmdEvent.SetEventObject(this);
4562         cmdEvent.SetPosition(m_caretPosition+1);
4563         cmdEvent.SetOldContainer(oldContainer);
4564         cmdEvent.SetContainer(m_focusObject);
4565
4566         GetEventHandler()->ProcessEvent(cmdEvent);
4567     }
4568     return true;
4569 }
4570
4571 #if wxUSE_DRAG_AND_DROP
4572 void wxRichTextCtrl::OnDrop(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxDragResult def, wxDataObject* DataObj)
4573 {
4574     m_preDrag = false;
4575
4576     if ((def != wxDragCopy) && (def != wxDragMove))
4577     {
4578         return;
4579     }
4580
4581     if (!GetSelection().IsValid())
4582     {
4583         return;
4584     }
4585
4586     wxRichTextParagraphLayoutBox* originContainer = GetSelection().GetContainer();
4587     wxRichTextParagraphLayoutBox* destContainer = GetFocusObject(); // This will be the drop container, not necessarily the same as the origin one
4588
4589     wxRichTextBuffer* richTextBuffer = ((wxRichTextBufferDataObject*)DataObj)->GetRichTextBuffer();
4590     if (richTextBuffer)
4591     {
4592         long position = GetCaretPosition();
4593         wxRichTextRange selectionrange = GetInternalSelectionRange();
4594         if (selectionrange.Contains(position) && (def == wxDragMove))
4595         {
4596             // It doesn't make sense to move onto itself
4597             return;
4598         }
4599
4600         // If we're moving, and the data is being moved forward, we need to drop first, then delete the selection
4601         // If moving backwards, we need to delete then drop. If we're copying (or doing nothing) we don't delete anyway
4602         bool DeleteAfter = (def == wxDragMove) && (position > selectionrange.GetEnd());
4603         if ((def == wxDragMove) && !DeleteAfter)
4604         {
4605             // We can't use e.g. DeleteSelectedContent() as it uses the focus container
4606             originContainer->DeleteRangeWithUndo(selectionrange, this, &GetBuffer());
4607         }
4608
4609         destContainer->InsertParagraphsWithUndo(&GetBuffer(), position+1, *richTextBuffer, this, 0);
4610         ShowPosition(position + richTextBuffer->GetOwnRange().GetEnd());
4611
4612         delete richTextBuffer;
4613
4614         if (DeleteAfter)
4615         {
4616             // We can't use e.g. DeleteSelectedContent() as it uses the focus container
4617             originContainer->DeleteRangeWithUndo(selectionrange, this, &GetBuffer());
4618         }
4619
4620         SelectNone();
4621         Refresh();
4622     }
4623 }
4624 #endif // wxUSE_DRAG_AND_DROP
4625
4626
4627 #if wxUSE_DRAG_AND_DROP
4628 bool wxRichTextDropSource::GiveFeedback(wxDragResult WXUNUSED(effect))
4629 {
4630     wxCHECK_MSG(m_rtc, false, wxT("NULL m_rtc"));
4631
4632     long position = 0;
4633     int hit = 0;
4634     wxRichTextObject* hitObj = NULL;
4635     wxRichTextParagraphLayoutBox* container = m_rtc->FindContainerAtPoint(m_rtc->GetUnscaledPoint(m_rtc->ScreenToClient(wxGetMousePosition())), position, hit, hitObj);
4636
4637     if (!(hit & wxRICHTEXT_HITTEST_NONE) && container && container->AcceptsFocus())
4638     {
4639         m_rtc->StoreFocusObject(container);
4640         m_rtc->SetCaretPositionAfterClick(container, position, hit);
4641     }
4642
4643     return false;  // so that the base-class sets a cursor
4644 }
4645 #endif // wxUSE_DRAG_AND_DROP
4646
4647 bool wxRichTextCtrl::CanDeleteRange(wxRichTextParagraphLayoutBox& WXUNUSED(container), const wxRichTextRange& WXUNUSED(range)) const
4648 {
4649     return true;
4650 }
4651
4652 bool wxRichTextCtrl::CanInsertContent(wxRichTextParagraphLayoutBox& WXUNUSED(container), long WXUNUSED(pos)) const
4653 {
4654     return true;
4655 }
4656
4657 void wxRichTextCtrl::EnableVerticalScrollbar(bool enable)
4658 {
4659     m_verticalScrollbarEnabled = enable;
4660     SetupScrollbars();
4661 }
4662
4663 void wxRichTextCtrl::SetFontScale(double fontScale, bool refresh)
4664 {
4665     GetBuffer().SetFontScale(fontScale);
4666     if (refresh)
4667     {
4668         GetBuffer().Invalidate(wxRICHTEXT_ALL);
4669         Refresh();
4670     }
4671 }
4672
4673 void wxRichTextCtrl::SetDimensionScale(double dimScale, bool refresh)
4674 {
4675     GetBuffer().SetDimensionScale(dimScale);
4676     if (refresh)
4677     {
4678         GetBuffer().Invalidate(wxRICHTEXT_ALL);
4679         Refresh();
4680     }
4681 }
4682
4683 // Sets an overall scale factor for displaying and editing the content.
4684 void wxRichTextCtrl::SetScale(double scale, bool refresh)
4685 {
4686     m_scale = scale;
4687     if (refresh)
4688     {
4689         GetBuffer().Invalidate(wxRICHTEXT_ALL);
4690         Refresh();
4691     }
4692 }
4693
4694 // Get an unscaled point
4695 wxPoint wxRichTextCtrl::GetUnscaledPoint(const wxPoint& pt) const
4696 {
4697     if (GetScale() == 1.0)
4698         return pt;
4699     else
4700         return wxPoint((int) (0.5 + double(pt.x) / GetScale()), (int) (0.5 + double(pt.y) / GetScale()));
4701 }
4702
4703 // Get a scaled point
4704 wxPoint wxRichTextCtrl::GetScaledPoint(const wxPoint& pt) const
4705 {
4706     if (GetScale() == 1.0)
4707         return pt;
4708     else
4709         return wxPoint((int) (0.5 + double(pt.x) * GetScale()), (int) (0.5 + double(pt.y) * GetScale()));
4710 }
4711
4712 // Get an unscaled size
4713 wxSize wxRichTextCtrl::GetUnscaledSize(const wxSize& sz) const
4714 {
4715     if (GetScale() == 1.0)
4716         return sz;
4717     else
4718         return wxSize((int) (0.5 + double(sz.x) / GetScale()), (int) (0.5 + double(sz.y) / GetScale()));
4719 }
4720
4721 // Get a scaled size
4722 wxSize wxRichTextCtrl::GetScaledSize(const wxSize& sz) const
4723 {
4724     if (GetScale() == 1.0)
4725         return sz;
4726     else
4727         return wxSize((int) (0.5 + double(sz.x) * GetScale()), (int) (0.5 + double(sz.y) * GetScale()));
4728 }
4729
4730 // Get an unscaled rect
4731 wxRect wxRichTextCtrl::GetUnscaledRect(const wxRect& rect) const
4732 {
4733     if (GetScale() == 1.0)
4734         return rect;
4735     else
4736         return wxRect((int) (0.5 + double(rect.x) / GetScale()), (int) (0.5 + double(rect.y) / GetScale()),
4737                       (int) (0.5 + double(rect.width) / GetScale()), (int) (0.5 + double(rect.height) / GetScale()));
4738 }
4739
4740 // Get a scaled rect
4741 wxRect wxRichTextCtrl::GetScaledRect(const wxRect& rect) const
4742 {
4743     if (GetScale() == 1.0)
4744         return rect;
4745     else
4746         return wxRect((int) (0.5 + double(rect.x) * GetScale()), (int) (0.5 + double(rect.y) * GetScale()),
4747                       (int) (0.5 + double(rect.width) * GetScale()), (int) (0.5 + double(rect.height) * GetScale()));
4748 }
4749
4750 #if wxRICHTEXT_USE_OWN_CARET
4751
4752 // ----------------------------------------------------------------------------
4753 // initialization and destruction
4754 // ----------------------------------------------------------------------------
4755
4756 void wxRichTextCaret::Init()
4757 {
4758     m_hasFocus = true;
4759     m_refreshEnabled = true;
4760
4761     m_xOld =
4762     m_yOld = -1;
4763     m_richTextCtrl = NULL;
4764     m_needsUpdate = false;
4765     m_flashOn = true;
4766 }
4767
4768 wxRichTextCaret::~wxRichTextCaret()
4769 {
4770     if (m_timer.IsRunning())
4771         m_timer.Stop();
4772 }
4773
4774 // ----------------------------------------------------------------------------
4775 // showing/hiding/moving the caret (base class interface)
4776 // ----------------------------------------------------------------------------
4777
4778 void wxRichTextCaret::DoShow()
4779 {
4780     m_flashOn = true;
4781
4782     if (!m_timer.IsRunning() && GetBlinkTime() > 0)
4783         m_timer.Start(GetBlinkTime());
4784
4785     Refresh();
4786 }
4787
4788 void wxRichTextCaret::DoHide()
4789 {
4790     if (m_timer.IsRunning())
4791         m_timer.Stop();
4792
4793     Refresh();
4794 }
4795
4796 void wxRichTextCaret::DoMove()
4797 {
4798     if (IsVisible())
4799     {
4800         Refresh();
4801
4802         if (m_xOld != -1 && m_yOld != -1)
4803         {
4804             if (m_richTextCtrl && m_refreshEnabled)
4805             {
4806                 wxRect rect(wxPoint(m_xOld, m_yOld), GetSize());
4807                 wxRect scaledRect = m_richTextCtrl->GetScaledRect(rect);
4808                 m_richTextCtrl->RefreshRect(scaledRect, false);
4809             }
4810         }
4811     }
4812
4813     m_xOld = m_x;
4814     m_yOld = m_y;
4815 }
4816
4817 void wxRichTextCaret::DoSize()
4818 {
4819     int countVisible = m_countVisible;
4820     if (countVisible > 0)
4821     {
4822         m_countVisible = 0;
4823         DoHide();
4824     }
4825
4826     if (countVisible > 0)
4827     {
4828         m_countVisible = countVisible;
4829         DoShow();
4830     }
4831 }
4832
4833 // ----------------------------------------------------------------------------
4834 // handling the focus
4835 // ----------------------------------------------------------------------------
4836
4837 void wxRichTextCaret::OnSetFocus()
4838 {
4839     m_hasFocus = true;
4840
4841     if ( IsVisible() )
4842         Refresh();
4843 }
4844
4845 void wxRichTextCaret::OnKillFocus()
4846 {
4847     m_hasFocus = false;
4848 }
4849
4850 // ----------------------------------------------------------------------------
4851 // drawing the caret
4852 // ----------------------------------------------------------------------------
4853
4854 void wxRichTextCaret::Refresh()
4855 {
4856     if (m_richTextCtrl && m_refreshEnabled)
4857     {
4858         wxRect rect(GetPosition(), GetSize());
4859         wxRect rectScaled = m_richTextCtrl->GetScaledRect(rect);
4860         m_richTextCtrl->RefreshRect(rectScaled, false);
4861     }
4862 }
4863
4864 void wxRichTextCaret::DoDraw(wxDC *dc)
4865 {
4866     wxBrush brush(m_caretBrush);
4867     wxPen pen(m_caretPen);
4868     if (m_richTextCtrl && m_richTextCtrl->GetBasicStyle().HasTextColour())
4869     {
4870         brush = wxBrush(m_richTextCtrl->GetBasicStyle().GetTextColour());
4871         pen = wxPen(m_richTextCtrl->GetBasicStyle().GetTextColour());
4872     }
4873     dc->SetBrush((m_hasFocus ? brush : *wxTRANSPARENT_BRUSH));
4874     dc->SetPen(pen);
4875
4876     wxPoint pt(m_x, m_y);
4877
4878     if (m_richTextCtrl)
4879     {
4880         pt = m_richTextCtrl->GetLogicalPoint(pt);
4881     }
4882     if (IsVisible() && m_flashOn)
4883         dc->DrawRectangle(pt.x, pt.y, m_width, m_height);
4884 }
4885
4886 void wxRichTextCaret::Notify()
4887 {
4888     m_flashOn = !m_flashOn;
4889     Refresh();
4890 }
4891
4892 void wxRichTextCaretTimer::Notify()
4893 {
4894     m_caret->Notify();
4895 }
4896 #endif
4897     // wxRICHTEXT_USE_OWN_CARET
4898
4899 // Add an item
4900 bool wxRichTextContextMenuPropertiesInfo::AddItem(const wxString& label, wxRichTextObject* obj)
4901 {
4902     if (GetCount() < 3)
4903     {
4904         m_labels.Add(label);
4905         m_objects.Add(obj);
4906         return true;
4907     }
4908     else
4909         return false;
4910 }
4911
4912 // Returns number of menu items were added.
4913 int wxRichTextContextMenuPropertiesInfo::AddMenuItems(wxMenu* menu, int startCmd) const
4914 {
4915     wxMenuItem* item = menu->FindItem(startCmd);
4916     // If none of the standard properties identifiers are in the menu, add them if necessary.
4917     // If no items to add, just set the text to something generic
4918     if (GetCount() == 0)
4919     {
4920         if (item)
4921         {
4922             menu->SetLabel(startCmd, _("&Properties"));
4923
4924             // Delete the others if necessary
4925             int i;
4926             for (i = startCmd+1; i < startCmd+3; i++)
4927             {
4928                 if (menu->FindItem(i))
4929                 {
4930                     menu->Delete(i);
4931                 }
4932             }
4933         }
4934     }
4935     else
4936     {
4937         int i;
4938         int pos = -1;
4939         // Find the position of the first properties item
4940         for (i = 0; i < (int) menu->GetMenuItemCount(); i++)
4941         {
4942             wxMenuItem* item = menu->FindItemByPosition(i);
4943             if (item && item->GetId() == startCmd)
4944             {
4945                 pos = i;
4946                 break;
4947             }
4948         }
4949
4950         if (pos != -1)
4951         {
4952             int insertBefore = pos+1;
4953             for (i = startCmd; i < startCmd+GetCount(); i++)
4954             {
4955                 if (menu->FindItem(i))
4956                 {
4957                     menu->SetLabel(i, m_labels[i - startCmd]);
4958                 }
4959                 else
4960                 {
4961                     if (insertBefore >= (int) menu->GetMenuItemCount())
4962                         menu->Append(i, m_labels[i - startCmd]);
4963                     else
4964                         menu->Insert(insertBefore, i, m_labels[i - startCmd]);
4965                 }
4966                 insertBefore ++;
4967             }
4968
4969             // Delete any old items still left on the menu
4970             for (i = startCmd + GetCount(); i < startCmd+3; i++)
4971             {
4972                 if (menu->FindItem(i))
4973                 {
4974                     menu->Delete(i);
4975                 }
4976             }
4977         }
4978         else
4979         {
4980             // No existing property identifiers were found, so append to the end of the menu.
4981             menu->AppendSeparator();
4982             for (i = startCmd; i < startCmd+GetCount(); i++)
4983             {
4984                 menu->Append(i, m_labels[i - startCmd]);
4985             }
4986         }
4987     }
4988
4989     return GetCount();
4990 }
4991
4992 // Add appropriate menu items for the current container and clicked on object
4993 // (and container's parent, if appropriate).
4994 int wxRichTextContextMenuPropertiesInfo::AddItems(wxRichTextCtrl* ctrl, wxRichTextObject* container, wxRichTextObject* obj)
4995 {
4996     Clear();
4997     if (obj && ctrl->CanEditProperties(obj))
4998         AddItem(ctrl->GetPropertiesMenuLabel(obj), obj);
4999
5000     if (container && container != obj && ctrl->CanEditProperties(container) && m_labels.Index(ctrl->GetPropertiesMenuLabel(container)) == wxNOT_FOUND)
5001         AddItem(ctrl->GetPropertiesMenuLabel(container), container);
5002
5003     if (container && container->GetParent() && ctrl->CanEditProperties(container->GetParent()) && m_labels.Index(ctrl->GetPropertiesMenuLabel(container->GetParent())) == wxNOT_FOUND)
5004         AddItem(ctrl->GetPropertiesMenuLabel(container->GetParent()), container->GetParent());
5005
5006     return GetCount();
5007 }
5008
5009 #endif
5010     // wxUSE_RICHTEXT