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