src/richtext/richtextctrl.cpp

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