src/richtext/richtextctrl.cpp

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