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