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