src/richtext/richtextctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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
  23 #ifndef WX_PRECOMP
  24   #include "wx/wx.h"
  25 #endif
  26
  27 #include "wx/textfile.h"
  28 #include "wx/ffile.h"
  29 #include "wx/settings.h"
  30 #include "wx/filename.h"
  31 #include "wx/dcbuffer.h"
  32 #include "wx/arrimpl.cpp"
  33
  34 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED)
  35 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED)
  36 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK)
  37 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK)
  38 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK)
  39 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK)
  40 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RICHTEXT_RETURN)
  41
  42 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
  43 IMPLEMENT_CLASS( wxRichTextCtrl, wxControl )
  44 #else
  45 IMPLEMENT_CLASS( wxRichTextCtrl, wxScrolledWindow )
  46 #endif
  47
  48 IMPLEMENT_CLASS( wxRichTextEvent, wxNotifyEvent )
  49
  50 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
  51 BEGIN_EVENT_TABLE( wxRichTextCtrl, wxControl )
  52 #else
  53 BEGIN_EVENT_TABLE( wxRichTextCtrl, wxScrolledWindow )
  54 #endif
  55     EVT_PAINT(wxRichTextCtrl::OnPaint)
  56     EVT_ERASE_BACKGROUND(wxRichTextCtrl::OnEraseBackground)
  57     EVT_IDLE(wxRichTextCtrl::OnIdle)
  58     EVT_SCROLLWIN(wxRichTextCtrl::OnScroll)
  59     EVT_LEFT_DOWN(wxRichTextCtrl::OnLeftClick)
  60     EVT_MOTION(wxRichTextCtrl::OnMoveMouse)
  61     EVT_LEFT_UP(wxRichTextCtrl::OnLeftUp)
  62     EVT_RIGHT_DOWN(wxRichTextCtrl::OnRightClick)
  63     EVT_MIDDLE_DOWN(wxRichTextCtrl::OnMiddleClick)
  64     EVT_LEFT_DCLICK(wxRichTextCtrl::OnLeftDClick)
  65     EVT_CHAR(wxRichTextCtrl::OnChar)
  66     EVT_SIZE(wxRichTextCtrl::OnSize)
  67     EVT_SET_FOCUS(wxRichTextCtrl::OnSetFocus)
  68     EVT_KILL_FOCUS(wxRichTextCtrl::OnKillFocus)
  69     EVT_CONTEXT_MENU(wxRichTextCtrl::OnContextMenu)
  70
  71     EVT_MENU(wxID_UNDO, wxRichTextCtrl::OnUndo)
  72     EVT_UPDATE_UI(wxID_UNDO, wxRichTextCtrl::OnUpdateUndo)
  73
  74     EVT_MENU(wxID_REDO, wxRichTextCtrl::OnRedo)
  75     EVT_UPDATE_UI(wxID_REDO, wxRichTextCtrl::OnUpdateRedo)
  76
  77     EVT_MENU(wxID_COPY, wxRichTextCtrl::OnCopy)
  78     EVT_UPDATE_UI(wxID_COPY, wxRichTextCtrl::OnUpdateCopy)
  79
  80     EVT_MENU(wxID_PASTE, wxRichTextCtrl::OnPaste)
  81     EVT_UPDATE_UI(wxID_PASTE, wxRichTextCtrl::OnUpdatePaste)
  82
  83     EVT_MENU(wxID_CUT, wxRichTextCtrl::OnCut)
  84     EVT_UPDATE_UI(wxID_CUT, wxRichTextCtrl::OnUpdateCut)
  85
  86     EVT_MENU(wxID_CLEAR, wxRichTextCtrl::OnClear)
  87     EVT_UPDATE_UI(wxID_CLEAR, wxRichTextCtrl::OnUpdateClear)
  88
  89     EVT_MENU(wxID_SELECTALL, wxRichTextCtrl::OnSelectAll)
  90     EVT_UPDATE_UI(wxID_SELECTALL, wxRichTextCtrl::OnUpdateSelectAll)
  91 END_EVENT_TABLE()
  92
  93 /*!
  94  * wxRichTextCtrl
  95  */
  96
  97 wxRichTextCtrl::wxRichTextCtrl()
  98 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
  99     : wxScrollHelper(this)
 100 #endif
 101 {
 102     Init();
 103 }
 104
 105 wxRichTextCtrl::wxRichTextCtrl( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
 106 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 107     : wxScrollHelper(this)
 108 #endif
 109 {
 110     Init();
 111     Create(parent, id, pos, size, style);
 112 }
 113
 114 /// Creation
 115 bool wxRichTextCtrl::Create( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
 116 {
 117 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
 118     if (!wxTextCtrlBase::Create(parent, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE
 119         ))
 120         return false;
 121 #else
 122     if (!wxScrolledWindow::Create(parent, id, pos, size, style|wxFULL_REPAINT_ON_RESIZE
 123         ))
 124         return false;
 125 #endif
 126
 127     if (!GetFont().Ok())
 128     {
 129         SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 130     }
 131
 132     GetBuffer().SetRichTextCtrl(this);
 133
 134     wxTextAttrEx attributes;
 135     attributes.SetFont(GetFont());
 136     attributes.SetTextColour(*wxBLACK);
 137     attributes.SetBackgroundColour(*wxWHITE);
 138     attributes.SetAlignment(wxTEXT_ALIGNMENT_LEFT);
 139     attributes.SetFlags(wxTEXT_ATTR_ALL);
 140
 141     SetDefaultStyle(attributes);
 142     SetBasicStyle(attributes);
 143
 144     SetBackgroundColour(*wxWHITE);
 145     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
 146
 147     // Tell the sizers to use the given or best size
 148     SetBestFittingSize(size);
 149
 150     // Create a buffer
 151     RecreateBuffer(size);
 152
 153     SetCursor(wxCursor(wxCURSOR_IBEAM));
 154
 155     return true;
 156 }
 157
 158 wxRichTextCtrl::~wxRichTextCtrl()
 159 {
 160     delete m_contextMenu;
 161 }
 162
 163 /// Member initialisation
 164 void wxRichTextCtrl::Init()
 165 {
 166     m_freezeCount = 0;
 167     m_contextMenu = NULL;
 168     m_caret = NULL;
 169     m_caretPosition = -1;
 170     m_selectionRange.SetRange(-2, -2);
 171     m_selectionAnchor = -2;
 172     m_editable = true;
 173     m_caretAtLineStart = false;
 174     m_dragging = false;
 175     m_fullLayoutRequired = false;
 176     m_fullLayoutTime = 0;
 177     m_fullLayoutSavedPosition = 0;
 178     m_delayedLayoutThreshold = wxRICHTEXT_DEFAULT_DELAYED_LAYOUT_THRESHOLD;
 179 }
 180
 181 /// Call Freeze to prevent refresh
 182 void wxRichTextCtrl::Freeze()
 183 {
 184     m_freezeCount ++;
 185 }
 186
 187 /// Call Thaw to refresh
 188 void wxRichTextCtrl::Thaw()
 189 {
 190     m_freezeCount --;
 191
 192     if (m_freezeCount == 0)
 193     {
 194         SetupScrollbars();
 195         Refresh(false);
 196     }
 197 }
 198
 199 /// Clear all text
 200 void wxRichTextCtrl::Clear()
 201 {
 202     m_buffer.Reset();
 203     m_buffer.SetDirty(true);
 204     m_caretPosition = -1;
 205     m_caretAtLineStart = false;
 206     m_selectionRange.SetRange(-2, -2);
 207
 208     if (m_freezeCount == 0)
 209     {
 210         SetupScrollbars();
 211         Refresh(false);
 212     }
 213     SendUpdateEvent();
 214 }
 215
 216 /// Painting
 217 void wxRichTextCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
 218 {
 219     if (GetCaret())
 220         GetCaret()->Hide();
 221
 222     {
 223         wxBufferedPaintDC dc(this, m_bufferBitmap);
 224         //wxLogDebug(wxT("OnPaint"));
 225
 226         PrepareDC(dc);
 227
 228         if (m_freezeCount > 0)
 229             return;
 230
 231         dc.SetFont(GetFont());
 232
 233         // Paint the background
 234         PaintBackground(dc);
 235
 236         wxRegion dirtyRegion = GetUpdateRegion();
 237
 238         wxRect drawingArea(GetLogicalPoint(wxPoint(0, 0)), GetClientSize());
 239         wxRect availableSpace(GetClientSize());
 240         if (GetBuffer().GetDirty())
 241         {
 242             GetBuffer().Layout(dc, availableSpace, wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT);
 243             GetBuffer().SetDirty(false);
 244             SetupScrollbars();
 245         }
 246
 247         GetBuffer().Draw(dc, GetBuffer().GetRange(), GetSelectionRange(), drawingArea, 0 /* descent */, 0 /* flags */);
 248     }
 249
 250     if (GetCaret())
 251         GetCaret()->Show();
 252
 253     PositionCaret();
 254 }
 255
 256 // Empty implementation, to prevent flicker
 257 void wxRichTextCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 258 {
 259 }
 260
 261 void wxRichTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
 262 {
 263     wxCaret* caret = new wxCaret(this, wxRICHTEXT_DEFAULT_CARET_WIDTH, 16);
 264     SetCaret(caret);
 265     caret->Show();
 266     PositionCaret();
 267
 268     if (!IsFrozen())
 269         Refresh(false);
 270 }
 271
 272 void wxRichTextCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
 273 {
 274     SetCaret(NULL);
 275
 276     if (!IsFrozen())
 277         Refresh(false);
 278 }
 279
 280 /// Left-click
 281 void wxRichTextCtrl::OnLeftClick(wxMouseEvent& event)
 282 {
 283     SetFocus();
 284
 285     wxClientDC dc(this);
 286     PrepareDC(dc);
 287     dc.SetFont(GetFont());
 288
 289     long position = 0;
 290     int hit = GetBuffer().HitTest(dc, event.GetLogicalPosition(dc), position);
 291
 292     if (hit != wxRICHTEXT_HITTEST_NONE)
 293     {
 294         m_dragStart = event.GetLogicalPosition(dc);
 295         m_dragging = true;
 296         CaptureMouse();
 297
 298         SelectNone();
 299
 300         bool caretAtLineStart = false;
 301
 302         if (hit & wxRICHTEXT_HITTEST_BEFORE)
 303         {
 304             // If we're at the start of a line (but not first in para)
 305             // then we should keep the caret showing at the start of the line
 306             // by showing the m_caretAtLineStart flag.
 307             wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
 308             wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
 309
 310             if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
 311                 caretAtLineStart = true;
 312             position --;
 313         }
 314
 315         MoveCaret(position, caretAtLineStart);
 316         SetDefaultStyleToCursorStyle();
 317
 318 #if 0
 319         wxWindow* p = GetParent();
 320         while (p && !p->IsKindOf(CLASSINFO(wxFrame)))
 321             p = p->GetParent();
 322
 323         wxFrame* frame = wxDynamicCast(p, wxFrame);
 324         if (frame)
 325         {
 326             wxString msg = wxString::Format(wxT("Found position %ld"), position);
 327             frame->SetStatusText(msg, 1);
 328         }
 329 #endif
 330     }
 331
 332     event.Skip();
 333 }
 334
 335 /// Left-up
 336 void wxRichTextCtrl::OnLeftUp(wxMouseEvent& WXUNUSED(event))
 337 {
 338     if (m_dragging)
 339     {
 340         m_dragging = false;
 341         if (GetCapture() == this)
 342             ReleaseMouse();
 343     }
 344 }
 345
 346 /// Left-click
 347 void wxRichTextCtrl::OnMoveMouse(wxMouseEvent& event)
 348 {
 349     if (!event.Dragging())
 350     {
 351         event.Skip();
 352         return;
 353     }
 354
 355     wxClientDC dc(this);
 356     PrepareDC(dc);
 357     dc.SetFont(GetFont());
 358
 359     long position = 0;
 360     wxPoint logicalPt = event.GetLogicalPosition(dc);
 361     int hit = GetBuffer().HitTest(dc, logicalPt, position);
 362
 363     if (m_dragging && hit != wxRICHTEXT_HITTEST_NONE)
 364     {
 365         // TODO: test closeness
 366
 367         bool caretAtLineStart = false;
 368
 369         if (hit & wxRICHTEXT_HITTEST_BEFORE)
 370         {
 371             // If we're at the start of a line (but not first in para)
 372             // then we should keep the caret showing at the start of the line
 373             // by showing the m_caretAtLineStart flag.
 374             wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(position);
 375             wxRichTextLine* line = GetBuffer().GetLineAtPosition(position);
 376
 377             if (line && para && line->GetAbsoluteRange().GetStart() == position && para->GetRange().GetStart() != position)
 378                 caretAtLineStart = true;
 379             position --;
 380         }
 381
 382         if (m_caretPosition != position)
 383         {
 384             bool extendSel = ExtendSelection(m_caretPosition, position, wxRICHTEXT_SHIFT_DOWN);
 385
 386             MoveCaret(position, caretAtLineStart);
 387             SetDefaultStyleToCursorStyle();
 388
 389             if (extendSel)
 390                 Refresh(false);
 391         }
 392     }
 393 }
 394
 395 /// Right-click
 396 void wxRichTextCtrl::OnRightClick(wxMouseEvent& event)
 397 {
 398     SetFocus();
 399     event.Skip();
 400 }
 401
 402 /// Left-double-click
 403 void wxRichTextCtrl::OnLeftDClick(wxMouseEvent& event)
 404 {
 405     event.Skip();
 406 }
 407
 408 /// Middle-click
 409 void wxRichTextCtrl::OnMiddleClick(wxMouseEvent& event)
 410 {
 411     event.Skip();
 412 }
 413
 414 /// Key press
 415 void wxRichTextCtrl::OnChar(wxKeyEvent& event)
 416 {
 417     int flags = 0;
 418     if (event.ControlDown())
 419         flags |= wxRICHTEXT_CTRL_DOWN;
 420     if (event.ShiftDown())
 421         flags |= wxRICHTEXT_SHIFT_DOWN;
 422     if (event.AltDown())
 423         flags |= wxRICHTEXT_ALT_DOWN;
 424
 425     if (event.GetKeyCode() == WXK_LEFT ||
 426         event.GetKeyCode() == WXK_RIGHT ||
 427         event.GetKeyCode() == WXK_UP ||
 428         event.GetKeyCode() == WXK_DOWN ||
 429         event.GetKeyCode() == WXK_HOME ||
 430         event.GetKeyCode() == WXK_PAGEUP ||
 431         event.GetKeyCode() == WXK_PAGEDOWN ||
 432         event.GetKeyCode() == WXK_PRIOR ||
 433         event.GetKeyCode() == WXK_NEXT ||
 434         event.GetKeyCode() == WXK_END)
 435     {
 436         KeyboardNavigate(event.GetKeyCode(), flags);
 437     }
 438     else if (event.GetKeyCode() == WXK_RETURN)
 439     {
 440         BeginBatchUndo(_("Insert Text"));
 441
 442         long newPos = m_caretPosition;
 443
 444         DeleteSelectedContent(& newPos);
 445
 446         GetBuffer().InsertNewlineWithUndo(newPos+1, this);
 447
 448         wxRichTextEvent cmdEvent(
 449             wxEVT_COMMAND_RICHTEXT_RETURN,
 450             GetId());
 451         cmdEvent.SetEventObject(this);
 452         cmdEvent.SetFlags(flags);
 453         GetEventHandler()->ProcessEvent(cmdEvent);
 454
 455         EndBatchUndo();
 456         SetDefaultStyleToCursorStyle();
 457     }
 458     else if (event.GetKeyCode() == WXK_BACK)
 459     {
 460         BeginBatchUndo(_("Delete Text"));
 461
 462         // Submit range in character positions, which are greater than caret positions,
 463         // so subtract 1 for deleted character and add 1 for conversion to character position.
 464         if (m_caretPosition > -1 && !HasSelection())
 465         {
 466             GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition, m_caretPosition),
 467                 m_caretPosition,   // Current caret position
 468                 m_caretPosition-1, // New caret position
 469                 this);
 470         }
 471         else
 472             DeleteSelectedContent();
 473
 474         EndBatchUndo();
 475
 476         // Shouldn't this be in Do()?
 477         if (GetLastPosition() == -1)
 478         {
 479             GetBuffer().Reset();
 480
 481             m_caretPosition = -1;
 482             PositionCaret();
 483             SetDefaultStyleToCursorStyle();
 484         }
 485
 486     }
 487     else if (event.GetKeyCode() == WXK_DELETE)
 488     {
 489         BeginBatchUndo(_("Delete Text"));
 490
 491         // Submit range in character positions, which are greater than caret positions,
 492         if (m_caretPosition < GetBuffer().GetRange().GetEnd()+1 && !HasSelection())
 493         {
 494             GetBuffer().DeleteRangeWithUndo(wxRichTextRange(m_caretPosition+1, m_caretPosition+1),
 495                 m_caretPosition,   // Current caret position
 496                 m_caretPosition+1, // New caret position
 497                 this);
 498         }
 499         else
 500             DeleteSelectedContent();
 501
 502         EndBatchUndo();
 503
 504         // Shouldn't this be in Do()?
 505         if (GetLastPosition() == -1)
 506         {
 507             GetBuffer().Reset();
 508
 509             m_caretPosition = -1;
 510             PositionCaret();
 511             SetDefaultStyleToCursorStyle();
 512         }
 513     }
 514     else
 515     {
 516         BeginBatchUndo(_("Insert Text"));
 517
 518         long newPos = m_caretPosition;
 519         DeleteSelectedContent(& newPos);
 520
 521         wxString str = (wxChar) event.GetKeyCode();
 522         GetBuffer().InsertTextWithUndo(newPos+1, str, this);
 523
 524         EndBatchUndo();
 525
 526         SetDefaultStyleToCursorStyle();
 527     }
 528 #if 0
 529     else
 530         event.Skip();
 531 #endif
 532 }
 533
 534 /// Delete content if there is a selection, e.g. when pressing a key.
 535 bool wxRichTextCtrl::DeleteSelectedContent(long* newPos)
 536 {
 537     if (HasSelection())
 538     {
 539         long pos = m_selectionRange.GetStart();
 540         GetBuffer().DeleteRangeWithUndo(m_selectionRange,
 541             m_caretPosition,       // Current caret position
 542             pos,    // New caret position
 543             this);
 544         m_selectionRange.SetRange(-2, -2);
 545
 546         if (newPos)
 547             *newPos = pos-1;
 548         return true;
 549     }
 550     else
 551         return false;
 552 }
 553
 554 /// Keyboard navigation
 555
 556 /*
 557
 558 Left:       left one character
 559 Right:      right one character
 560 Up:         up one line
 561 Down:       down one line
 562 Ctrl-Left:  left one word
 563 Ctrl-Right: right one word
 564 Ctrl-Up:    previous paragraph start
 565 Ctrl-Down:  next start of paragraph
 566 Home:       start of line
 567 End:        end of line
 568 Ctrl-Home:  start of document
 569 Ctrl-End:   end of document
 570 Page-Up:    Up a screen
 571 Page-Down:  Down a screen
 572
 573 Maybe:
 574
 575 Ctrl-Alt-PgUp: Start of window
 576 Ctrl-Alt-PgDn: End of window
 577 F8:         Start selection mode
 578 Esc:        End selection mode
 579
 580 Adding Shift does the above but starts/extends selection.
 581
 582
 583  */
 584
 585 bool wxRichTextCtrl::KeyboardNavigate(int keyCode, int flags)
 586 {
 587     bool success = false;
 588
 589     if (keyCode == WXK_RIGHT)
 590     {
 591         if (flags & wxRICHTEXT_CTRL_DOWN)
 592             success = WordRight(1, flags);
 593         else
 594             success = MoveRight(1, flags);
 595     }
 596     else if (keyCode == WXK_LEFT)
 597     {
 598         if (flags & wxRICHTEXT_CTRL_DOWN)
 599             success = WordLeft(1, flags);
 600         else
 601             success = MoveLeft(1, flags);
 602     }
 603     else if (keyCode == WXK_UP)
 604     {
 605         if (flags & wxRICHTEXT_CTRL_DOWN)
 606             success = MoveToParagraphStart(flags);
 607         else
 608             success = MoveUp(1, flags);
 609     }
 610     else if (keyCode == WXK_DOWN)
 611     {
 612         if (flags & wxRICHTEXT_CTRL_DOWN)
 613             success = MoveToParagraphEnd(flags);
 614         else
 615             success = MoveDown(1, flags);
 616     }
 617     else if (keyCode == WXK_PAGEUP || keyCode == WXK_PRIOR)
 618     {
 619         success = PageUp(1, flags);
 620     }
 621     else if (keyCode == WXK_PAGEDOWN || keyCode == WXK_NEXT)
 622     {
 623         success = PageDown(1, flags);
 624     }
 625     else if (keyCode == WXK_HOME)
 626     {
 627         if (flags & wxRICHTEXT_CTRL_DOWN)
 628             success = MoveHome(flags);
 629         else
 630             success = MoveToLineStart(flags);
 631     }
 632     else if (keyCode == WXK_END)
 633     {
 634         if (flags & wxRICHTEXT_CTRL_DOWN)
 635             success = MoveEnd(flags);
 636         else
 637             success = MoveToLineEnd(flags);
 638     }
 639
 640     if (success)
 641     {
 642         ScrollIntoView(m_caretPosition, keyCode);
 643         SetDefaultStyleToCursorStyle();
 644     }
 645
 646     return success;
 647 }
 648
 649 /// Extend the selection. Selections are in caret positions.
 650 bool wxRichTextCtrl::ExtendSelection(long oldPos, long newPos, int flags)
 651 {
 652     if (flags & wxRICHTEXT_SHIFT_DOWN)
 653     {
 654         // If not currently selecting, start selecting
 655         if (m_selectionRange.GetStart() == -2)
 656         {
 657             m_selectionAnchor = oldPos;
 658
 659             if (oldPos > newPos)
 660                 m_selectionRange.SetRange(newPos+1, oldPos);
 661             else
 662                 m_selectionRange.SetRange(oldPos+1, newPos);
 663         }
 664         else
 665         {
 666             // Always ensure that the selection range start is greater than
 667             // the end.
 668             if (newPos > m_selectionAnchor)
 669                 m_selectionRange.SetRange(m_selectionAnchor+1, newPos);
 670             else
 671                 m_selectionRange.SetRange(newPos+1, m_selectionAnchor);
 672         }
 673
 674         if (m_selectionRange.GetStart() > m_selectionRange.GetEnd())
 675         {
 676             wxLogDebug(wxT("Strange selection range"));
 677         }
 678
 679         return true;
 680     }
 681     else
 682         return false;
 683 }
 684
 685 /// Scroll into view, returning true if we scrolled.
 686 /// This takes a _caret_ position.
 687 bool wxRichTextCtrl::ScrollIntoView(long position, int keyCode)
 688 {
 689     wxRichTextLine* line = GetVisibleLineForCaretPosition(position);
 690
 691     if (!line)
 692         return false;
 693
 694     int ppuX, ppuY;
 695     GetScrollPixelsPerUnit(& ppuX, & ppuY);
 696
 697     int startX, startY;
 698     GetViewStart(& startX, & startY);
 699     startX = 0;
 700     startY = startY * ppuY;
 701
 702     int sx, sy;
 703     GetVirtualSize(& sx, & sy);
 704     sx = 0;
 705     if (ppuY != 0)
 706         sy = sy/ppuY;
 707
 708     wxRect rect = line->GetRect();
 709
 710     bool scrolled = false;
 711
 712     wxSize clientSize = GetClientSize();
 713
 714     // Going down
 715     if (keyCode == WXK_DOWN || keyCode == WXK_RIGHT || keyCode == WXK_END || keyCode == WXK_NEXT || keyCode == WXK_PAGEDOWN)
 716     {
 717         if ((rect.y + rect.height) > (clientSize.y + startY))
 718         {
 719             // Make it scroll so this item is at the bottom
 720             // of the window
 721             int y = rect.y - (clientSize.y - rect.height);
 722             y = (int) (0.5 + y/ppuY);
 723
 724             if (startY != y)
 725             {
 726                 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
 727                 scrolled = true;
 728             }
 729         }
 730         else if (rect.y < startY)
 731         {
 732             // Make it scroll so this item is at the top
 733             // of the window
 734             int y = rect.y ;
 735             y = (int) (0.5 + y/ppuY);
 736
 737             if (startY != y)
 738             {
 739                 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
 740                 scrolled = true;
 741             }
 742         }
 743     }
 744     // Going up
 745     else if (keyCode == WXK_UP || keyCode == WXK_LEFT || keyCode == WXK_HOME || keyCode == WXK_PRIOR || keyCode == WXK_PAGEUP)
 746     {
 747         if (rect.y < startY)
 748         {
 749             // Make it scroll so this item is at the top
 750             // of the window
 751             int y = rect.y ;
 752             y = (int) (0.5 + y/ppuY);
 753
 754             if (startY != y)
 755             {
 756                 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
 757                 scrolled = true;
 758             }
 759         }
 760         else if ((rect.y + rect.height) > (clientSize.y + startY))
 761         {
 762             // Make it scroll so this item is at the bottom
 763             // of the window
 764             int y = rect.y - (clientSize.y - rect.height);
 765             y = (int) (0.5 + y/ppuY);
 766
 767             if (startY != y)
 768             {
 769                 SetScrollbars(ppuX, ppuY, sx, sy, 0, y);
 770                 scrolled = true;
 771             }
 772         }
 773     }
 774     PositionCaret();
 775
 776     return scrolled;
 777 }
 778
 779 /// Is the given position visible on the screen?
 780 bool wxRichTextCtrl::IsPositionVisible(long pos) const
 781 {
 782     wxRichTextLine* line = GetVisibleLineForCaretPosition(pos-1);
 783
 784     if (!line)
 785         return false;
 786
 787     int ppuX, ppuY;
 788     GetScrollPixelsPerUnit(& ppuX, & ppuY);
 789
 790     int startX, startY;
 791     GetViewStart(& startX, & startY);
 792     startX = 0;
 793     startY = startY * ppuY;
 794
 795     int sx, sy;
 796     GetVirtualSize(& sx, & sy);
 797     sx = 0;
 798     if (ppuY != 0)
 799         sy = sy/ppuY;
 800
 801     wxRect rect = line->GetRect();
 802
 803     wxSize clientSize = GetClientSize();
 804
 805     return !(((rect.y + rect.height) > (clientSize.y + startY)) || rect.y < startY);
 806 }
 807
 808 void wxRichTextCtrl::SetCaretPosition(long position, bool showAtLineStart)
 809 {
 810     m_caretPosition = position;
 811     m_caretAtLineStart = showAtLineStart;
 812 }
 813
 814 /// Move caret one visual step forward: this may mean setting a flag
 815 /// and keeping the same position if we're going from the end of one line
 816 /// to the start of the next, which may be the exact same caret position.
 817 void wxRichTextCtrl::MoveCaretForward(long oldPosition)
 818 {
 819     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
 820
 821     // Only do the check if we're not at the end of the paragraph (where things work OK
 822     // anyway)
 823     if (para && (oldPosition != para->GetRange().GetEnd() - 1))
 824     {
 825         wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
 826
 827         if (line)
 828         {
 829             wxRichTextRange lineRange = line->GetAbsoluteRange();
 830
 831             // We're at the end of a line. See whether we need to
 832             // stay at the same actual caret position but change visual
 833             // position, or not.
 834             if (oldPosition == lineRange.GetEnd())
 835             {
 836                 if (m_caretAtLineStart)
 837                 {
 838                     // We're already at the start of the line, so actually move on now.
 839                     m_caretPosition = oldPosition + 1;
 840                     m_caretAtLineStart = false;
 841                 }
 842                 else
 843                 {
 844                     // We're showing at the end of the line, so keep to
 845                     // the same position but indicate that we're to show
 846                     // at the start of the next line.
 847                     m_caretPosition = oldPosition;
 848                     m_caretAtLineStart = true;
 849                 }
 850                 SetDefaultStyleToCursorStyle();
 851                 return;
 852             }
 853         }
 854     }
 855     m_caretPosition ++;
 856     SetDefaultStyleToCursorStyle();
 857 }
 858
 859 /// Move caret one visual step backward: this may mean setting a flag
 860 /// and keeping the same position if we're going from the end of one line
 861 /// to the start of the next, which may be the exact same caret position.
 862 void wxRichTextCtrl::MoveCaretBack(long oldPosition)
 863 {
 864     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
 865
 866     // Only do the check if we're not at the start of the paragraph (where things work OK
 867     // anyway)
 868     if (para && (oldPosition != para->GetRange().GetStart()))
 869     {
 870         wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
 871
 872         if (line)
 873         {
 874             wxRichTextRange lineRange = line->GetAbsoluteRange();
 875
 876             // We're at the start of a line. See whether we need to
 877             // stay at the same actual caret position but change visual
 878             // position, or not.
 879             if (oldPosition == lineRange.GetStart())
 880             {
 881                 m_caretPosition = oldPosition-1;
 882                 m_caretAtLineStart = true;
 883                 return;
 884             }
 885             else if (oldPosition == lineRange.GetEnd())
 886             {
 887                 if (m_caretAtLineStart)
 888                 {
 889                     // We're at the start of the line, so keep the same caret position
 890                     // but clear the start-of-line flag.
 891                     m_caretPosition = oldPosition;
 892                     m_caretAtLineStart = false;
 893                 }
 894                 else
 895                 {
 896                     // We're showing at the end of the line, so go back
 897                     // to the previous character position.
 898                     m_caretPosition = oldPosition - 1;
 899                 }
 900                 SetDefaultStyleToCursorStyle();
 901                 return;
 902             }
 903         }
 904     }
 905     m_caretPosition --;
 906     SetDefaultStyleToCursorStyle();
 907 }
 908
 909 /// Move right
 910 bool wxRichTextCtrl::MoveRight(int noPositions, int flags)
 911 {
 912     long endPos = GetBuffer().GetRange().GetEnd();
 913
 914     if (m_caretPosition + noPositions < endPos)
 915     {
 916         long oldPos = m_caretPosition;
 917         long newPos = m_caretPosition + noPositions;
 918
 919         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
 920         if (!extendSel)
 921             SelectNone();
 922
 923         // Determine by looking at oldPos and m_caretPosition whether
 924         // we moved from the end of a line to the start of the next line, in which case
 925         // we want to adjust the caret position such that it is positioned at the
 926         // start of the next line, rather than jumping past the first character of the
 927         // line.
 928         if (noPositions == 1 && !extendSel)
 929             MoveCaretForward(oldPos);
 930         else
 931             SetCaretPosition(newPos);
 932
 933         PositionCaret();
 934         SetDefaultStyleToCursorStyle();
 935
 936         if (extendSel)
 937             Refresh(false);
 938         return true;
 939     }
 940     else
 941         return false;
 942 }
 943
 944 /// Move left
 945 bool wxRichTextCtrl::MoveLeft(int noPositions, int flags)
 946 {
 947     long startPos = -1;
 948
 949     if (m_caretPosition > startPos - noPositions + 1)
 950     {
 951         long oldPos = m_caretPosition;
 952         long newPos = m_caretPosition - noPositions;
 953         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
 954         if (!extendSel)
 955             SelectNone();
 956
 957         if (noPositions == 1 && !extendSel)
 958             MoveCaretBack(oldPos);
 959         else
 960             SetCaretPosition(newPos);
 961
 962         PositionCaret();
 963         SetDefaultStyleToCursorStyle();
 964
 965         if (extendSel)
 966             Refresh(false);
 967         return true;
 968     }
 969     else
 970         return false;
 971 }
 972
 973 /// Move up
 974 bool wxRichTextCtrl::MoveUp(int noLines, int flags)
 975 {
 976     return MoveDown(- noLines, flags);
 977 }
 978
 979 /// Move up
 980 bool wxRichTextCtrl::MoveDown(int noLines, int flags)
 981 {
 982     if (!GetCaret())
 983         return false;
 984
 985     long lineNumber = GetBuffer().GetVisibleLineNumber(m_caretPosition, true, m_caretAtLineStart);
 986     wxPoint pt = GetCaret()->GetPosition();
 987     long newLine = lineNumber + noLines;
 988
 989     if (lineNumber != -1)
 990     {
 991         if (noLines > 0)
 992         {
 993             long lastLine = GetBuffer().GetVisibleLineNumber(GetBuffer().GetRange().GetEnd());
 994
 995             if (newLine > lastLine)
 996                 return false;
 997         }
 998         else
 999         {
1000             if (newLine < 0)
1001                 return false;
1002         }
1003     }
1004
1005     wxRichTextLine* lineObj = GetBuffer().GetLineForVisibleLineNumber(newLine);
1006     if (lineObj)
1007     {
1008         pt.y = lineObj->GetAbsolutePosition().y + 2;
1009     }
1010     else
1011         return false;
1012
1013     long newPos = 0;
1014     wxClientDC dc(this);
1015     PrepareDC(dc);
1016     dc.SetFont(GetFont());
1017
1018     int hitTest = GetBuffer().HitTest(dc, pt, newPos);
1019
1020     if (hitTest != wxRICHTEXT_HITTEST_NONE)
1021     {
1022         // If end of previous line, and hitTest is wxRICHTEXT_HITTEST_BEFORE,
1023         // we want to be at the end of the last line but with m_caretAtLineStart set to true,
1024         // so we view the caret at the start of the line.
1025         bool caretLineStart = false;
1026         if (hitTest == wxRICHTEXT_HITTEST_BEFORE)
1027         {
1028             wxRichTextLine* thisLine = GetBuffer().GetLineAtPosition(newPos-1);
1029             wxRichTextRange lineRange;
1030             if (thisLine)
1031                 lineRange = thisLine->GetAbsoluteRange();
1032
1033             if (thisLine && (newPos-1) == lineRange.GetEnd())
1034             {
1035                 newPos --;
1036                 caretLineStart = true;
1037             }
1038             else
1039             {
1040                 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(newPos);
1041                 if (para && para->GetRange().GetStart() == newPos)
1042                     newPos --;
1043             }
1044         }
1045
1046         long newSelEnd = newPos;
1047
1048         bool extendSel = ExtendSelection(m_caretPosition, newSelEnd, flags);
1049         if (!extendSel)
1050             SelectNone();
1051
1052         SetCaretPosition(newPos, caretLineStart);
1053         PositionCaret();
1054         SetDefaultStyleToCursorStyle();
1055
1056         if (extendSel)
1057             Refresh(false);
1058         return true;
1059     }
1060
1061     return false;
1062 }
1063
1064 /// Move to the end of the paragraph
1065 bool wxRichTextCtrl::MoveToParagraphEnd(int flags)
1066 {
1067     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1068     if (para)
1069     {
1070         long newPos = para->GetRange().GetEnd() - 1;
1071         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1072         if (!extendSel)
1073             SelectNone();
1074
1075         SetCaretPosition(newPos);
1076         PositionCaret();
1077         SetDefaultStyleToCursorStyle();
1078
1079         if (extendSel)
1080             Refresh(false);
1081         return true;
1082     }
1083
1084     return false;
1085 }
1086
1087 /// Move to the start of the paragraph
1088 bool wxRichTextCtrl::MoveToParagraphStart(int flags)
1089 {
1090     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1091     if (para)
1092     {
1093         long newPos = para->GetRange().GetStart() - 1;
1094         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1095         if (!extendSel)
1096             SelectNone();
1097
1098         SetCaretPosition(newPos);
1099         PositionCaret();
1100         SetDefaultStyleToCursorStyle();
1101
1102         if (extendSel)
1103             Refresh(false);
1104         return true;
1105     }
1106
1107     return false;
1108 }
1109
1110 /// Move to the end of the line
1111 bool wxRichTextCtrl::MoveToLineEnd(int flags)
1112 {
1113     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1114
1115     if (line)
1116     {
1117         wxRichTextRange lineRange = line->GetAbsoluteRange();
1118         long newPos = lineRange.GetEnd();
1119         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1120         if (!extendSel)
1121             SelectNone();
1122
1123         SetCaretPosition(newPos);
1124         PositionCaret();
1125         SetDefaultStyleToCursorStyle();
1126
1127         if (extendSel)
1128             Refresh(false);
1129         return true;
1130     }
1131
1132     return false;
1133 }
1134
1135 /// Move to the start of the line
1136 bool wxRichTextCtrl::MoveToLineStart(int flags)
1137 {
1138     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1139     if (line)
1140     {
1141         wxRichTextRange lineRange = line->GetAbsoluteRange();
1142         long newPos = lineRange.GetStart()-1;
1143
1144         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
1145         if (!extendSel)
1146             SelectNone();
1147
1148         wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(line);
1149
1150         SetCaretPosition(newPos, para->GetRange().GetStart() != lineRange.GetStart());
1151         PositionCaret();
1152         SetDefaultStyleToCursorStyle();
1153
1154         if (extendSel)
1155             Refresh(false);
1156         return true;
1157     }
1158
1159     return false;
1160 }
1161
1162 /// Move to the start of the buffer
1163 bool wxRichTextCtrl::MoveHome(int flags)
1164 {
1165     if (m_caretPosition != -1)
1166     {
1167         bool extendSel = ExtendSelection(m_caretPosition, -1, flags);
1168         if (!extendSel)
1169             SelectNone();
1170
1171         SetCaretPosition(-1);
1172         PositionCaret();
1173         SetDefaultStyleToCursorStyle();
1174
1175         if (extendSel)
1176             Refresh(false);
1177         return true;
1178     }
1179     else
1180         return false;
1181 }
1182
1183 /// Move to the end of the buffer
1184 bool wxRichTextCtrl::MoveEnd(int flags)
1185 {
1186     long endPos = GetBuffer().GetRange().GetEnd()-1;
1187
1188     if (m_caretPosition != endPos)
1189     {
1190         bool extendSel = ExtendSelection(m_caretPosition, endPos, flags);
1191         if (!extendSel)
1192             SelectNone();
1193
1194         SetCaretPosition(endPos);
1195         PositionCaret();
1196         SetDefaultStyleToCursorStyle();
1197
1198         if (extendSel)
1199             Refresh(false);
1200         return true;
1201     }
1202     else
1203         return false;
1204 }
1205
1206 /// Move noPages pages up
1207 bool wxRichTextCtrl::PageUp(int noPages, int flags)
1208 {
1209     return PageDown(- noPages, flags);
1210 }
1211
1212 /// Move noPages pages down
1213 bool wxRichTextCtrl::PageDown(int noPages, int flags)
1214 {
1215     // Calculate which line occurs noPages * screen height further down.
1216     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1217     if (line)
1218     {
1219         wxSize clientSize = GetClientSize();
1220         int newY = line->GetAbsolutePosition().y + noPages*clientSize.y;
1221
1222         wxRichTextLine* newLine = GetBuffer().GetLineAtYPosition(newY);
1223         if (newLine)
1224         {
1225             wxRichTextRange lineRange = newLine->GetAbsoluteRange();
1226             long pos = lineRange.GetStart()-1;
1227             if (pos != m_caretPosition)
1228             {
1229                 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(newLine);
1230
1231                 bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1232                 if (!extendSel)
1233                     SelectNone();
1234
1235                 SetCaretPosition(pos, para->GetRange().GetStart() != lineRange.GetStart());
1236                 PositionCaret();
1237                 SetDefaultStyleToCursorStyle();
1238
1239                 if (extendSel)
1240                     Refresh(false);
1241                 return true;
1242             }
1243         }
1244     }
1245
1246     return false;
1247 }
1248
1249 // Finds the caret position for the next word
1250 long wxRichTextCtrl::FindNextWordPosition(int direction) const
1251 {
1252     long endPos = GetBuffer().GetRange().GetEnd();
1253
1254     if (direction > 0)
1255     {
1256         long i = m_caretPosition+1+direction; // +1 for conversion to character pos
1257
1258         // First skip current text to space
1259         while (i < endPos && i > -1)
1260         {
1261             // i is in character, not caret positions
1262             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1263             if (text != wxT(" ") && !text.empty())
1264                 i += direction;
1265             else
1266             {
1267                 break;
1268             }
1269         }
1270         while (i < endPos && i > -1)
1271         {
1272             // i is in character, not caret positions
1273             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1274             if (text.empty()) // End of paragraph, or maybe an image
1275                 return wxMax(-1, i - 1);
1276             else if (text == wxT(" ") || text.empty())
1277                 i += direction;
1278             else
1279             {
1280                 // Convert to caret position
1281                 return wxMax(-1, i - 1);
1282             }
1283         }
1284         if (i >= endPos)
1285             return endPos-1;
1286         return i-1;
1287     }
1288     else
1289     {
1290         long i = m_caretPosition;
1291
1292         // First skip white space
1293         while (i < endPos && i > -1)
1294         {
1295             // i is in character, not caret positions
1296             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1297             if (text.empty()) // End of paragraph, or maybe an image
1298                 break;
1299             else if (text == wxT(" ") || text.empty())
1300                 i += direction;
1301             else
1302                 break;
1303         }
1304         // Next skip current text to space
1305         while (i < endPos && i > -1)
1306         {
1307             // i is in character, not caret positions
1308             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1309             if (text != wxT(" ") /* && !text.empty() */)
1310                 i += direction;
1311             else
1312             {
1313                 return i;
1314             }
1315         }
1316         if (i < -1)
1317             return -1;
1318         return i;
1319     }
1320 }
1321
1322 /// Move n words left
1323 bool wxRichTextCtrl::WordLeft(int WXUNUSED(n), int flags)
1324 {
1325     long pos = FindNextWordPosition(-1);
1326     if (pos != m_caretPosition)
1327     {
1328         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1329
1330         bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1331         if (!extendSel)
1332             SelectNone();
1333
1334         SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1335         PositionCaret();
1336         SetDefaultStyleToCursorStyle();
1337
1338         if (extendSel)
1339             Refresh(false);
1340         return true;
1341     }
1342
1343     return false;
1344 }
1345
1346 /// Move n words right
1347 bool wxRichTextCtrl::WordRight(int WXUNUSED(n), int flags)
1348 {
1349     long pos = FindNextWordPosition(1);
1350     if (pos != m_caretPosition)
1351     {
1352         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1353
1354         bool extendSel = ExtendSelection(m_caretPosition, pos, flags);
1355         if (!extendSel)
1356             SelectNone();
1357
1358         SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1359         PositionCaret();
1360         SetDefaultStyleToCursorStyle();
1361
1362         if (extendSel)
1363             Refresh(false);
1364         return true;
1365     }
1366
1367     return false;
1368 }
1369
1370 /// Sizing
1371 void wxRichTextCtrl::OnSize(wxSizeEvent& event)
1372 {
1373     // Only do sizing optimization for large buffers
1374     if (GetBuffer().GetRange().GetEnd() > m_delayedLayoutThreshold)
1375     {
1376         m_fullLayoutRequired = true;
1377         m_fullLayoutTime = wxGetLocalTimeMillis();
1378         m_fullLayoutSavedPosition = GetFirstVisiblePosition();
1379         LayoutContent(true /* onlyVisibleRect */);
1380     }
1381     else
1382         GetBuffer().Invalidate(wxRICHTEXT_ALL);
1383
1384     RecreateBuffer();
1385
1386     event.Skip();
1387 }
1388
1389
1390 /// Idle-time processing
1391 void wxRichTextCtrl::OnIdle(wxIdleEvent& event)
1392 {
1393     const int layoutInterval = wxRICHTEXT_DEFAULT_LAYOUT_INTERVAL;
1394
1395     if (m_fullLayoutRequired && (wxGetLocalTimeMillis() > (m_fullLayoutTime + layoutInterval)))
1396     {
1397         m_fullLayoutRequired = false;
1398         m_fullLayoutTime = 0;
1399         GetBuffer().Invalidate(wxRICHTEXT_ALL);
1400         ShowPosition(m_fullLayoutSavedPosition);
1401         Refresh(false);
1402     }
1403     event.Skip();
1404 }
1405
1406 /// Scrolling
1407 void wxRichTextCtrl::OnScroll(wxScrollWinEvent& event)
1408 {
1409     // Not used
1410     event.Skip();
1411 }
1412
1413 /// Set up scrollbars, e.g. after a resize
1414 void wxRichTextCtrl::SetupScrollbars(bool atTop)
1415 {
1416     if (m_freezeCount)
1417         return;
1418
1419     if (GetBuffer().IsEmpty())
1420     {
1421         SetScrollbars(0, 0, 0, 0, 0, 0);
1422         return;
1423     }
1424
1425     // TODO: reimplement scrolling so we scroll by line, not by fixed number
1426     // of pixels. See e.g. wxVScrolledWindow for ideas.
1427     int pixelsPerUnit = 5; // 10;
1428     wxSize clientSize = GetClientSize();
1429
1430     int maxHeight = GetBuffer().GetCachedSize().y;
1431
1432     int unitsY = maxHeight/pixelsPerUnit;
1433
1434     int startX = 0, startY = 0;
1435     if (!atTop)
1436         GetViewStart(& startX, & startY);
1437
1438     int maxPositionX = 0; // wxMax(sz.x - clientSize.x, 0);
1439     int maxPositionY = (wxMax(maxHeight - clientSize.y, 0))/pixelsPerUnit;
1440
1441     // Move to previous scroll position if
1442     // possible
1443     SetScrollbars(0, pixelsPerUnit,
1444         0, unitsY,
1445         wxMin(maxPositionX, startX), wxMin(maxPositionY, startY));
1446 }
1447
1448 /// Paint the background
1449 void wxRichTextCtrl::PaintBackground(wxDC& dc)
1450 {
1451     wxColour backgroundColour = GetBackgroundColour();
1452     if (!backgroundColour.Ok())
1453         backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1454
1455     // Clear the background
1456     dc.SetBrush(wxBrush(backgroundColour));
1457     dc.SetPen(*wxTRANSPARENT_PEN);
1458     wxRect windowRect(GetClientSize());
1459     windowRect.x -= 2; windowRect.y -= 2;
1460     windowRect.width += 4; windowRect.height += 4;
1461
1462     // We need to shift the rectangle to take into account
1463     // scrolling. Converting device to logical coordinates.
1464     CalcUnscrolledPosition(windowRect.x, windowRect.y, & windowRect.x, & windowRect.y);
1465     dc.DrawRectangle(windowRect);
1466 }
1467
1468 /// Recreate buffer bitmap if necessary
1469 bool wxRichTextCtrl::RecreateBuffer(const wxSize& size)
1470 {
1471     wxSize sz = size;
1472     if (sz == wxDefaultSize)
1473         sz = GetClientSize();
1474
1475     if (sz.x < 1 || sz.y < 1)
1476         return false;
1477
1478     if (!m_bufferBitmap.Ok() || m_bufferBitmap.GetWidth() < sz.x || m_bufferBitmap.GetHeight() < sz.y)
1479         m_bufferBitmap = wxBitmap(sz.x, sz.y);
1480     return m_bufferBitmap.Ok();
1481 }
1482
1483 // ----------------------------------------------------------------------------
1484 // file IO functions
1485 // ----------------------------------------------------------------------------
1486
1487 bool wxRichTextCtrl::LoadFile(const wxString& filename, int type)
1488 {
1489     bool success = GetBuffer().LoadFile(filename, type);
1490     if (success)
1491         m_filename = filename;
1492
1493     DiscardEdits();
1494     SetInsertionPoint(0);
1495     LayoutContent();
1496     PositionCaret();
1497     SetupScrollbars(true);
1498     Refresh(false);
1499     SendUpdateEvent();
1500
1501     if (success)
1502         return true;
1503     else
1504     {
1505         wxLogError(_("File couldn't be loaded."));
1506
1507         return false;
1508     }
1509 }
1510
1511 bool wxRichTextCtrl::SaveFile(const wxString& filename, int type)
1512 {
1513     wxString filenameToUse = filename.empty() ? m_filename : filename;
1514     if ( filenameToUse.empty() )
1515     {
1516         // what kind of message to give? is it an error or a program bug?
1517         wxLogDebug(wxT("Can't save textctrl to file without filename."));
1518
1519         return false;
1520     }
1521
1522     if (GetBuffer().SaveFile(filenameToUse, type))
1523     {
1524         m_filename = filenameToUse;
1525
1526         DiscardEdits();
1527
1528         return true;
1529
1530     }
1531
1532     wxLogError(_("The text couldn't be saved."));
1533
1534     return false;
1535 }
1536
1537 // ----------------------------------------------------------------------------
1538 // wxRichTextCtrl specific functionality
1539 // ----------------------------------------------------------------------------
1540
1541 /// Add a new paragraph of text to the end of the buffer
1542 wxRichTextRange wxRichTextCtrl::AddParagraph(const wxString& text)
1543 {
1544     return GetBuffer().AddParagraph(text);
1545 }
1546
1547 /// Add an image
1548 wxRichTextRange wxRichTextCtrl::AddImage(const wxImage& image)
1549 {
1550     return GetBuffer().AddImage(image);
1551 }
1552
1553 // ----------------------------------------------------------------------------
1554 // selection and ranges
1555 // ----------------------------------------------------------------------------
1556
1557 void wxRichTextCtrl::SelectAll()
1558 {
1559     SetSelection(0, GetLastPosition());
1560     m_selectionAnchor = -1;
1561 }
1562
1563 /// Select none
1564 void wxRichTextCtrl::SelectNone()
1565 {
1566     if (!(GetSelectionRange() == wxRichTextRange(-2, -2)))
1567         SetSelection(-2, -2);
1568     m_selectionAnchor = -2;
1569 }
1570
1571 wxString wxRichTextCtrl::GetStringSelection() const
1572 {
1573     long from, to;
1574     GetSelection(&from, &to);
1575
1576     return GetRange(from, to);
1577 }
1578
1579 // do the window-specific processing after processing the update event
1580 void wxRichTextCtrl::DoUpdateWindowUI(wxUpdateUIEvent& event)
1581 {
1582     if ( event.GetSetEnabled() )
1583         Enable(event.GetEnabled());
1584
1585     if ( event.GetSetText() )
1586     {
1587         if ( event.GetText() != GetValue() )
1588             SetValue(event.GetText());
1589     }
1590 }
1591
1592 // ----------------------------------------------------------------------------
1593 // hit testing
1594 // ----------------------------------------------------------------------------
1595
1596 wxTextCtrlHitTestResult
1597 wxRichTextCtrl::HitTest(const wxPoint& pt, wxTextCoord *x, wxTextCoord *y) const
1598 {
1599     // implement in terms of the other overload as the native ports typically
1600     // can get the position and not (x, y) pair directly (although wxUniv
1601     // directly gets x and y -- and so overrides this method as well)
1602     long pos;
1603     wxTextCtrlHitTestResult rc = HitTest(pt, &pos);
1604
1605     if ( rc != wxTE_HT_UNKNOWN )
1606     {
1607         PositionToXY(pos, x, y);
1608     }
1609
1610     return rc;
1611 }
1612
1613 wxTextCtrlHitTestResult
1614 wxRichTextCtrl::HitTest(const wxPoint& pt,
1615                         long * pos) const
1616 {
1617     wxClientDC dc((wxRichTextCtrl*) this);
1618     ((wxRichTextCtrl*)this)->PrepareDC(dc);
1619
1620     int hit = ((wxRichTextCtrl*)this)->GetBuffer().HitTest(dc, pt, *pos);
1621
1622     switch ( hit )
1623     {
1624         case wxRICHTEXT_HITTEST_BEFORE:
1625             return wxTE_HT_BEFORE;
1626
1627         case wxRICHTEXT_HITTEST_AFTER:
1628             return wxTE_HT_BEYOND;
1629
1630         case wxRICHTEXT_HITTEST_ON:
1631             return wxTE_HT_ON_TEXT;
1632     }
1633
1634     return wxTE_HT_UNKNOWN;
1635 }
1636
1637 // ----------------------------------------------------------------------------
1638 // set/get the controls text
1639 // ----------------------------------------------------------------------------
1640
1641 wxString wxRichTextCtrl::GetValue() const
1642 {
1643     return GetBuffer().GetText();
1644 }
1645
1646 wxString wxRichTextCtrl::GetRange(long from, long to) const
1647 {
1648     return GetBuffer().GetTextForRange(wxRichTextRange(from, to));
1649 }
1650
1651 void wxRichTextCtrl::SetValue(const wxString& value)
1652 {
1653     Clear();
1654
1655     // if the text is long enough, it's faster to just set it instead of first
1656     // comparing it with the old one (chances are that it will be different
1657     // anyhow, this comparison is there to avoid flicker for small single-line
1658     // edit controls mostly)
1659     if ( (value.length() > 0x400) || (value != GetValue()) )
1660     {
1661         DoWriteText(value, false /* not selection only */);
1662
1663         // for compatibility, don't move the cursor when doing SetValue()
1664         SetInsertionPoint(0);
1665     }
1666     else // same text
1667     {
1668         // still send an event for consistency
1669         SendUpdateEvent();
1670     }
1671
1672     // we should reset the modified flag even if the value didn't really change
1673
1674     // mark the control as being not dirty - we changed its text, not the
1675     // user
1676     DiscardEdits();
1677 }
1678
1679 void wxRichTextCtrl::WriteText(const wxString& value)
1680 {
1681     DoWriteText(value);
1682 }
1683
1684 void wxRichTextCtrl::DoWriteText(const wxString& value, bool WXUNUSED(selectionOnly))
1685 {
1686     GetBuffer().InsertTextWithUndo(m_caretPosition+1, value, this);
1687 }
1688
1689 void wxRichTextCtrl::AppendText(const wxString& text)
1690 {
1691     SetInsertionPointEnd();
1692
1693     WriteText(text);
1694 }
1695
1696 /// Write an image at the current insertion point
1697 bool wxRichTextCtrl::WriteImage(const wxImage& image, int bitmapType)
1698 {
1699     wxRichTextImageBlock imageBlock;
1700
1701     wxImage image2 = image;
1702     if (imageBlock.MakeImageBlock(image2, bitmapType))
1703         return WriteImage(imageBlock);
1704
1705     return false;
1706 }
1707
1708 bool wxRichTextCtrl::WriteImage(const wxString& filename, int bitmapType)
1709 {
1710     wxRichTextImageBlock imageBlock;
1711
1712     wxImage image;
1713     if (imageBlock.MakeImageBlock(filename, bitmapType, image, false))
1714         return WriteImage(imageBlock);
1715
1716     return false;
1717 }
1718
1719 bool wxRichTextCtrl::WriteImage(const wxRichTextImageBlock& imageBlock)
1720 {
1721     return GetBuffer().InsertImageWithUndo(m_caretPosition+1, imageBlock, this);
1722 }
1723
1724 bool wxRichTextCtrl::WriteImage(const wxBitmap& bitmap, int bitmapType)
1725 {
1726     if (bitmap.Ok())
1727     {
1728         wxRichTextImageBlock imageBlock;
1729
1730         wxImage image = bitmap.ConvertToImage();
1731         if (image.Ok() && imageBlock.MakeImageBlock(image, bitmapType))
1732             return WriteImage(imageBlock);
1733     }
1734
1735     return false;
1736 }
1737
1738 /// Insert a newline (actually paragraph) at the current insertion point.
1739 bool wxRichTextCtrl::Newline()
1740 {
1741     return GetBuffer().InsertNewlineWithUndo(m_caretPosition+1, this);
1742 }
1743
1744
1745 // ----------------------------------------------------------------------------
1746 // Clipboard operations
1747 // ----------------------------------------------------------------------------
1748
1749 void wxRichTextCtrl::Copy()
1750 {
1751     if (CanCopy())
1752     {
1753         wxRichTextRange range = GetSelectionRange();
1754         GetBuffer().CopyToClipboard(range);
1755     }
1756 }
1757
1758 void wxRichTextCtrl::Cut()
1759 {
1760     if (CanCut())
1761     {
1762         wxRichTextRange range = GetSelectionRange();
1763         GetBuffer().CopyToClipboard(range);
1764
1765         DeleteSelectedContent();
1766         LayoutContent();
1767         Refresh(false);
1768     }
1769 }
1770
1771 void wxRichTextCtrl::Paste()
1772 {
1773     if (CanPaste())
1774     {
1775         BeginBatchUndo(_("Paste"));
1776
1777         long newPos = m_caretPosition;
1778         DeleteSelectedContent(& newPos);
1779
1780         GetBuffer().PasteFromClipboard(newPos);
1781
1782         EndBatchUndo();
1783     }
1784 }
1785
1786 void wxRichTextCtrl::DeleteSelection()
1787 {
1788     if (CanDeleteSelection())
1789     {
1790         DeleteSelectedContent();
1791     }
1792 }
1793
1794 bool wxRichTextCtrl::HasSelection() const
1795 {
1796     return m_selectionRange.GetStart() != -2 && m_selectionRange.GetEnd() != -2;
1797 }
1798
1799 bool wxRichTextCtrl::CanCopy() const
1800 {
1801     // Can copy if there's a selection
1802     return HasSelection();
1803 }
1804
1805 bool wxRichTextCtrl::CanCut() const
1806 {
1807     return HasSelection() && IsEditable();
1808 }
1809
1810 bool wxRichTextCtrl::CanPaste() const
1811 {
1812     if ( !IsEditable() )
1813         return false;
1814
1815     return GetBuffer().CanPasteFromClipboard();
1816 }
1817
1818 bool wxRichTextCtrl::CanDeleteSelection() const
1819 {
1820     return HasSelection() && IsEditable();
1821 }
1822
1823
1824 // ----------------------------------------------------------------------------
1825 // Accessors
1826 // ----------------------------------------------------------------------------
1827
1828 void wxRichTextCtrl::SetEditable(bool editable)
1829 {
1830     m_editable = editable;
1831 }
1832
1833 void wxRichTextCtrl::SetInsertionPoint(long pos)
1834 {
1835     SelectNone();
1836
1837     m_caretPosition = pos - 1;
1838 }
1839
1840 void wxRichTextCtrl::SetInsertionPointEnd()
1841 {
1842     long pos = GetLastPosition();
1843     SetInsertionPoint(pos);
1844 }
1845
1846 long wxRichTextCtrl::GetInsertionPoint() const
1847 {
1848     return m_caretPosition+1;
1849 }
1850
1851 wxTextPos wxRichTextCtrl::GetLastPosition() const
1852 {
1853     return GetBuffer().GetRange().GetEnd();
1854 }
1855
1856 // If the return values from and to are the same, there is no
1857 // selection.
1858 void wxRichTextCtrl::GetSelection(long* from, long* to) const
1859 {
1860     *from = m_selectionRange.GetStart();
1861     *to = m_selectionRange.GetEnd();
1862 }
1863
1864 bool wxRichTextCtrl::IsEditable() const
1865 {
1866     return m_editable;
1867 }
1868
1869 // ----------------------------------------------------------------------------
1870 // selection
1871 // ----------------------------------------------------------------------------
1872
1873 void wxRichTextCtrl::SetSelection(long from, long to)
1874 {
1875     // if from and to are both -1, it means (in wxWidgets) that all text should
1876     // be selected.
1877     if ( (from == -1) && (to == -1) )
1878     {
1879         from = 0;
1880         to = GetLastPosition();
1881     }
1882
1883     DoSetSelection(from, to);
1884 }
1885
1886 void wxRichTextCtrl::DoSetSelection(long from, long to, bool WXUNUSED(scrollCaret))
1887 {
1888     m_selectionAnchor = from;
1889     m_selectionRange.SetRange(from, to);
1890     Refresh(false);
1891     PositionCaret();
1892 }
1893
1894 // ----------------------------------------------------------------------------
1895 // Editing
1896 // ----------------------------------------------------------------------------
1897
1898 void wxRichTextCtrl::Replace(long WXUNUSED(from), long WXUNUSED(to), const wxString& value)
1899 {
1900     BeginBatchUndo(_("Replace"));
1901
1902     DeleteSelectedContent();
1903
1904     DoWriteText(value, true /* selection only */);
1905
1906     EndBatchUndo();
1907 }
1908
1909 void wxRichTextCtrl::Remove(long from, long to)
1910 {
1911     SelectNone();
1912
1913     GetBuffer().DeleteRangeWithUndo(wxRichTextRange(from, to),
1914         m_caretPosition,       // Current caret position
1915         from,                           // New caret position
1916         this);
1917
1918     LayoutContent();
1919     if (!IsFrozen())
1920         Refresh(false);
1921 }
1922
1923 bool wxRichTextCtrl::IsModified() const
1924 {
1925     return m_buffer.IsModified();
1926 }
1927
1928 void wxRichTextCtrl::MarkDirty()
1929 {
1930     m_buffer.Modify(true);
1931 }
1932
1933 void wxRichTextCtrl::DiscardEdits()
1934 {
1935     m_buffer.Modify(false);
1936     m_buffer.GetCommandProcessor()->ClearCommands();
1937 }
1938
1939 int wxRichTextCtrl::GetNumberOfLines() const
1940 {
1941     return GetBuffer().GetParagraphCount();
1942 }
1943
1944 // ----------------------------------------------------------------------------
1945 // Positions <-> coords
1946 // ----------------------------------------------------------------------------
1947
1948 long wxRichTextCtrl::XYToPosition(long x, long y) const
1949 {
1950     return GetBuffer().XYToPosition(x, y);
1951 }
1952
1953 bool wxRichTextCtrl::PositionToXY(long pos, long *x, long *y) const
1954 {
1955     return GetBuffer().PositionToXY(pos, x, y);
1956 }
1957
1958 // ----------------------------------------------------------------------------
1959 //
1960 // ----------------------------------------------------------------------------
1961
1962 void wxRichTextCtrl::ShowPosition(long pos)
1963 {
1964     if (!IsPositionVisible(pos))
1965         ScrollIntoView(pos-1, WXK_DOWN);
1966 }
1967
1968 int wxRichTextCtrl::GetLineLength(long lineNo) const
1969 {
1970     return GetBuffer().GetParagraphLength(lineNo);
1971 }
1972
1973 wxString wxRichTextCtrl::GetLineText(long lineNo) const
1974 {
1975     return GetBuffer().GetParagraphText(lineNo);
1976 }
1977
1978 // ----------------------------------------------------------------------------
1979 // Undo/redo
1980 // ----------------------------------------------------------------------------
1981
1982 void wxRichTextCtrl::Undo()
1983 {
1984     if (CanUndo())
1985     {
1986         GetCommandProcessor()->Undo();
1987     }
1988 }
1989
1990 void wxRichTextCtrl::Redo()
1991 {
1992     if (CanRedo())
1993     {
1994         GetCommandProcessor()->Redo();
1995     }
1996 }
1997
1998 bool wxRichTextCtrl::CanUndo() const
1999 {
2000     return GetCommandProcessor()->CanUndo();
2001 }
2002
2003 bool wxRichTextCtrl::CanRedo() const
2004 {
2005     return GetCommandProcessor()->CanRedo();
2006 }
2007
2008 // ----------------------------------------------------------------------------
2009 // implemenation details
2010 // ----------------------------------------------------------------------------
2011
2012 void wxRichTextCtrl::Command(wxCommandEvent & event)
2013 {
2014     SetValue(event.GetString());
2015     GetEventHandler()->ProcessEvent(event);
2016 }
2017
2018 void wxRichTextCtrl::OnDropFiles(wxDropFilesEvent& event)
2019 {
2020     // By default, load the first file into the text window.
2021     if (event.GetNumberOfFiles() > 0)
2022     {
2023         LoadFile(event.GetFiles()[0]);
2024     }
2025 }
2026
2027 // ----------------------------------------------------------------------------
2028 // text control event processing
2029 // ----------------------------------------------------------------------------
2030
2031 bool wxRichTextCtrl::SendUpdateEvent()
2032 {
2033     wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
2034     InitCommandEvent(event);
2035
2036     return GetEventHandler()->ProcessEvent(event);
2037 }
2038
2039 void wxRichTextCtrl::InitCommandEvent(wxCommandEvent& event) const
2040 {
2041     event.SetEventObject((wxControlBase *)this);    // const_cast
2042
2043     switch ( m_clientDataType )
2044     {
2045         case wxClientData_Void:
2046             event.SetClientData(GetClientData());
2047             break;
2048
2049         case wxClientData_Object:
2050             event.SetClientObject(GetClientObject());
2051             break;
2052
2053         case wxClientData_None:
2054             // nothing to do
2055             ;
2056     }
2057 }
2058
2059
2060 wxSize wxRichTextCtrl::DoGetBestSize() const
2061 {
2062     return wxSize(10, 10);
2063 }
2064
2065 // ----------------------------------------------------------------------------
2066 // standard handlers for standard edit menu events
2067 // ----------------------------------------------------------------------------
2068
2069 void wxRichTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2070 {
2071     Cut();
2072 }
2073
2074 void wxRichTextCtrl::OnClear(wxCommandEvent& WXUNUSED(event))
2075 {
2076     DeleteSelection();
2077 }
2078
2079 void wxRichTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2080 {
2081     Copy();
2082 }
2083
2084 void wxRichTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2085 {
2086     Paste();
2087 }
2088
2089 void wxRichTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2090 {
2091     Undo();
2092 }
2093
2094 void wxRichTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2095 {
2096     Redo();
2097 }
2098
2099 void wxRichTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2100 {
2101     event.Enable( CanCut() );
2102 }
2103
2104 void wxRichTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2105 {
2106     event.Enable( CanCopy() );
2107 }
2108
2109 void wxRichTextCtrl::OnUpdateClear(wxUpdateUIEvent& event)
2110 {
2111     event.Enable( CanDeleteSelection() );
2112 }
2113
2114 void wxRichTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2115 {
2116     event.Enable( CanPaste() );
2117 }
2118
2119 void wxRichTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2120 {
2121     event.Enable( CanUndo() );
2122     event.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
2123 }
2124
2125 void wxRichTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2126 {
2127     event.Enable( CanRedo() );
2128     event.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
2129 }
2130
2131 void wxRichTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
2132 {
2133     SelectAll();
2134 }
2135
2136 void wxRichTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
2137 {
2138     event.Enable(GetLastPosition() > 0);
2139 }
2140
2141 void wxRichTextCtrl::OnContextMenu(wxContextMenuEvent& WXUNUSED(event))
2142 {
2143     if (!m_contextMenu)
2144     {
2145         m_contextMenu = new wxMenu;
2146         m_contextMenu->Append(wxID_UNDO, _("&Undo"));
2147         m_contextMenu->Append(wxID_REDO, _("&Redo"));
2148         m_contextMenu->AppendSeparator();
2149         m_contextMenu->Append(wxID_CUT, _("Cu&t"));
2150         m_contextMenu->Append(wxID_COPY, _("&Copy"));
2151         m_contextMenu->Append(wxID_PASTE, _("&Paste"));
2152         m_contextMenu->Append(wxID_CLEAR, _("&Delete"));
2153         m_contextMenu->AppendSeparator();
2154         m_contextMenu->Append(wxID_SELECTALL, _("Select &All"));
2155     }
2156     PopupMenu(m_contextMenu);
2157     return;
2158 }
2159
2160 bool wxRichTextCtrl::SetStyle(long start, long end, const wxTextAttrEx& style)
2161 {
2162     return GetBuffer().SetStyle(wxRichTextRange(start, end), style);
2163 }
2164
2165 bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style)
2166 {
2167     return GetBuffer().SetStyle(range, style);
2168 }
2169
2170 bool wxRichTextCtrl::SetDefaultStyle(const wxTextAttrEx& style)
2171 {
2172     return GetBuffer().SetDefaultStyle(style);
2173 }
2174
2175 const wxTextAttrEx& wxRichTextCtrl::GetDefaultStyleEx() const
2176 {
2177     return GetBuffer().GetDefaultStyle();
2178 }
2179
2180 bool wxRichTextCtrl::GetStyle(long position, wxTextAttrEx& style) const
2181 {
2182     return GetBuffer().GetStyle(position, style);
2183 }
2184
2185 bool wxRichTextCtrl::GetStyle(long position, wxRichTextAttr& style) const
2186 {
2187     return GetBuffer().GetStyle(position, style);
2188 }
2189
2190 /// Set font, and also the buffer attributes
2191 bool wxRichTextCtrl::SetFont(const wxFont& font)
2192 {
2193 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
2194     wxControl::SetFont(font);
2195 #else
2196     wxScrolledWindow::SetFont(font);
2197 #endif
2198
2199     wxTextAttrEx attr = GetBuffer().GetAttributes();
2200     attr.SetFont(font);
2201     GetBuffer().SetBasicStyle(attr);
2202     GetBuffer().SetDefaultStyle(attr);
2203
2204     return true;
2205 }
2206
2207 /// Transform logical to physical
2208 wxPoint wxRichTextCtrl::GetPhysicalPoint(const wxPoint& ptLogical) const
2209 {
2210     wxPoint pt;
2211     CalcScrolledPosition(ptLogical.x, ptLogical.y, & pt.x, & pt.y);
2212
2213     return pt;
2214 }
2215
2216 /// Transform physical to logical
2217 wxPoint wxRichTextCtrl::GetLogicalPoint(const wxPoint& ptPhysical) const
2218 {
2219     wxPoint pt;
2220     CalcUnscrolledPosition(ptPhysical.x, ptPhysical.y, & pt.x, & pt.y);
2221
2222     return pt;
2223 }
2224
2225 /// Position the caret
2226 void wxRichTextCtrl::PositionCaret()
2227 {
2228     if (!GetCaret())
2229         return;
2230
2231     //wxLogDebug(wxT("PositionCaret"));
2232
2233     wxRect caretRect;
2234     if (GetCaretPositionForIndex(GetCaretPosition(), caretRect))
2235     {
2236         wxPoint originalPt = caretRect.GetPosition();
2237         wxPoint pt = GetPhysicalPoint(originalPt);
2238         if (GetCaret()->GetPosition() != pt)
2239         {
2240             GetCaret()->Move(pt);
2241             GetCaret()->SetSize(caretRect.GetSize());
2242         }
2243     }
2244 }
2245
2246 /// Get the caret height and position for the given character position
2247 bool wxRichTextCtrl::GetCaretPositionForIndex(long position, wxRect& rect)
2248 {
2249     wxClientDC dc(this);
2250     dc.SetFont(GetFont());
2251
2252     PrepareDC(dc);
2253
2254     wxPoint pt;
2255     int height = 0;
2256
2257     if (GetBuffer().FindPosition(dc, position, pt, & height, m_caretAtLineStart))
2258     {
2259         rect = wxRect(pt, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH, height));
2260         return true;
2261     }
2262
2263     return false;
2264 }
2265
2266 /// Gets the line for the visible caret position. If the caret is
2267 /// shown at the very end of the line, it means the next character is actually
2268 /// on the following line. So let's get the line we're expecting to find
2269 /// if this is the case.
2270 wxRichTextLine* wxRichTextCtrl::GetVisibleLineForCaretPosition(long caretPosition) const
2271 {
2272     wxRichTextLine* line = GetBuffer().GetLineAtPosition(caretPosition, true);
2273     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(caretPosition, true);
2274     if (line)
2275     {
2276         wxRichTextRange lineRange = line->GetAbsoluteRange();
2277         if (caretPosition == lineRange.GetStart()-1 &&
2278             (para->GetRange().GetStart() != lineRange.GetStart()))
2279         {
2280             if (!m_caretAtLineStart)
2281                 line = GetBuffer().GetLineAtPosition(caretPosition-1, true);
2282         }
2283     }
2284     return line;
2285 }
2286
2287
2288 /// Move the caret to the given character position
2289 bool wxRichTextCtrl::MoveCaret(long pos, bool showAtLineStart)
2290 {
2291     if (GetBuffer().GetDirty())
2292         LayoutContent();
2293
2294     if (pos <= GetBuffer().GetRange().GetEnd())
2295     {
2296         SetCaretPosition(pos, showAtLineStart);
2297
2298         PositionCaret();
2299
2300         return true;
2301     }
2302     else
2303         return false;
2304 }
2305
2306 /// Layout the buffer: which we must do before certain operations, such as
2307 /// setting the caret position.
2308 bool wxRichTextCtrl::LayoutContent(bool onlyVisibleRect)
2309 {
2310     if (GetBuffer().GetDirty() || onlyVisibleRect)
2311     {
2312         wxRect availableSpace(GetClientSize());
2313         if (availableSpace.width == 0)
2314             availableSpace.width = 10;
2315         if (availableSpace.height == 0)
2316             availableSpace.height = 10;
2317
2318         int flags = wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT;
2319         if (onlyVisibleRect)
2320         {
2321             flags |= wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
2322             availableSpace.SetPosition(GetLogicalPoint(wxPoint(0, 0)));
2323         }
2324
2325         wxClientDC dc(this);
2326         dc.SetFont(GetFont());
2327
2328         PrepareDC(dc);
2329
2330         GetBuffer().Defragment();
2331         GetBuffer().UpdateRanges();     // If items were deleted, ranges need recalculation
2332         GetBuffer().Layout(dc, availableSpace, flags);
2333         GetBuffer().SetDirty(false);
2334
2335         if (!IsFrozen())
2336             SetupScrollbars();
2337     }
2338
2339     return true;
2340 }
2341
2342 /// Is all of the selection bold?
2343 bool wxRichTextCtrl::IsSelectionBold() const
2344 {
2345     if (HasSelection())
2346     {
2347         wxRichTextAttr attr;
2348         wxRichTextRange range = GetSelectionRange();
2349         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2350         attr.SetFontWeight(wxBOLD);
2351
2352         return HasCharacterAttributes(range, attr);
2353     }
2354     else
2355     {
2356         // If no selection, then we need to combine current style with default style
2357         // to see what the effect would be if we started typing.
2358         wxRichTextAttr attr;
2359         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2360         if (GetStyle(GetCaretPosition()+1, attr))
2361         {
2362             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2363             return attr.GetFontWeight() == wxBOLD;
2364         }
2365     }
2366     return false;
2367 }
2368
2369 /// Is all of the selection italics?
2370 bool wxRichTextCtrl::IsSelectionItalics() const
2371 {
2372     if (HasSelection())
2373     {
2374         wxRichTextRange range = GetSelectionRange();
2375         wxRichTextAttr attr;
2376         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2377         attr.SetFontStyle(wxITALIC);
2378
2379         return HasCharacterAttributes(range, attr);
2380     }
2381     else
2382     {
2383         // If no selection, then we need to combine current style with default style
2384         // to see what the effect would be if we started typing.
2385         wxRichTextAttr attr;
2386         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2387         if (GetStyle(GetCaretPosition()+1, attr))
2388         {
2389             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2390             return attr.GetFontStyle() == wxITALIC;
2391         }
2392     }
2393     return false;
2394 }
2395
2396 /// Is all of the selection underlined?
2397 bool wxRichTextCtrl::IsSelectionUnderlined() const
2398 {
2399     if (HasSelection())
2400     {
2401         wxRichTextRange range = GetSelectionRange();
2402         wxRichTextAttr attr;
2403         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2404         attr.SetFontUnderlined(true);
2405
2406         return HasCharacterAttributes(range, attr);
2407     }
2408     else
2409     {
2410         // If no selection, then we need to combine current style with default style
2411         // to see what the effect would be if we started typing.
2412         wxRichTextAttr attr;
2413         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2414         if (GetStyle(GetCaretPosition()+1, attr))
2415         {
2416             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2417             return attr.GetFontUnderlined();
2418         }
2419     }
2420     return false;
2421 }
2422
2423 /// Apply bold to the selection
2424 bool wxRichTextCtrl::ApplyBoldToSelection()
2425 {
2426     wxRichTextAttr attr;
2427     attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2428     attr.SetFontWeight(IsSelectionBold() ? wxNORMAL : wxBOLD);
2429
2430     if (HasSelection())
2431         return SetStyle(GetSelectionRange(), attr);
2432     else
2433         SetDefaultStyle(attr);
2434     return true;
2435 }
2436
2437 /// Apply italic to the selection
2438 bool wxRichTextCtrl::ApplyItalicToSelection()
2439 {
2440     wxRichTextAttr attr;
2441     attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2442     attr.SetFontStyle(IsSelectionItalics() ? wxNORMAL : wxITALIC);
2443
2444     if (HasSelection())
2445         return SetStyle(GetSelectionRange(), attr);
2446     else
2447         SetDefaultStyle(attr);
2448     return true;
2449 }
2450
2451 /// Apply underline to the selection
2452 bool wxRichTextCtrl::ApplyUnderlineToSelection()
2453 {
2454     wxRichTextAttr attr;
2455     attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2456     attr.SetFontUnderlined(!IsSelectionUnderlined());
2457
2458     if (HasSelection())
2459         return SetStyle(GetSelectionRange(), attr);
2460     else
2461         SetDefaultStyle(attr);
2462     return true;
2463 }
2464
2465 /// Is all of the selection aligned according to the specified flag?
2466 bool wxRichTextCtrl::IsSelectionAligned(wxTextAttrAlignment alignment) const
2467 {
2468     if (HasSelection())
2469     {
2470         wxRichTextRange range = GetSelectionRange();
2471         wxRichTextAttr attr;
2472         attr.SetAlignment(alignment);
2473
2474         return HasParagraphAttributes(range, attr);
2475     }
2476     else
2477     {
2478         // If no selection, then we need to get information from the current paragraph.
2479         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2480         if (para)
2481             return para->GetAttributes().GetAlignment() == alignment;
2482     }
2483     return false;
2484 }
2485
2486 /// Apply alignment to the selection
2487 bool wxRichTextCtrl::ApplyAlignmentToSelection(wxTextAttrAlignment alignment)
2488 {
2489     wxRichTextAttr attr;
2490     attr.SetAlignment(alignment);
2491     if (HasSelection())
2492         return SetStyle(GetSelectionRange(), attr);
2493     else
2494     {
2495         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2496         if (para)
2497             return SetStyle(para->GetRange(), attr);
2498     }
2499     return true;
2500 }
2501
2502 /// Sets the default style to the style under the cursor
2503 bool wxRichTextCtrl::SetDefaultStyleToCursorStyle()
2504 {
2505     wxTextAttrEx attr;
2506     attr.SetFlags(wxTEXT_ATTR_CHARACTER);
2507
2508     if (GetStyle(GetCaretPosition(), attr))
2509     {
2510         SetDefaultStyle(attr);
2511         return true;
2512     }
2513
2514     return false;
2515 }
2516
2517 /// Returns the first visible position in the current view
2518 long wxRichTextCtrl::GetFirstVisiblePosition() const
2519 {
2520     wxRichTextLine* line = GetBuffer().GetLineAtYPosition(GetLogicalPoint(wxPoint(0, 0)).y);
2521     if (line)
2522         return line->GetAbsoluteRange().GetStart();
2523     else
2524         return 0;
2525 }
2526
2527 #endif
2528     // wxUSE_RICHTEXT
2529