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, GetBuffer().GetRange(), 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->GetRange().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->GetRange().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             // We're at the end of a line. See whether we need to
 796             // stay at the same actual caret position but change visual
 797             // position, or not.
 798             if (oldPosition == line->GetRange().GetEnd())
 799             {
 800                 if (m_caretAtLineStart)
 801                 {
 802                     // We're already at the start of the line, so actually move on now.
 803                     m_caretPosition = oldPosition + 1;
 804                     m_caretAtLineStart = false;
 805                 }
 806                 else
 807                 {
 808                     // We're showing at the end of the line, so keep to
 809                     // the same position but indicate that we're to show
 810                     // at the start of the next line.
 811                     m_caretPosition = oldPosition;
 812                     m_caretAtLineStart = true;
 813                 }
 814                 SetDefaultStyleToCursorStyle();
 815                 return;
 816             }
 817         }
 818     }
 819     m_caretPosition ++;
 820     SetDefaultStyleToCursorStyle();
 821 }
 822
 823 /// Move caret one visual step backward: this may mean setting a flag
 824 /// and keeping the same position if we're going from the end of one line
 825 /// to the start of the next, which may be the exact same caret position.
 826 void wxRichTextCtrl::MoveCaretBack(long oldPosition)
 827 {
 828     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(oldPosition);
 829
 830     // Only do the check if we're not at the start of the paragraph (where things work OK
 831     // anyway)
 832     if (para && (oldPosition != para->GetRange().GetStart()))
 833     {
 834         wxRichTextLine* line = GetBuffer().GetLineAtPosition(oldPosition);
 835
 836         if (line)
 837         {
 838             // We're at the start of a line. See whether we need to
 839             // stay at the same actual caret position but change visual
 840             // position, or not.
 841             if (oldPosition == line->GetRange().GetStart())
 842             {
 843                 m_caretPosition = oldPosition-1;
 844                 m_caretAtLineStart = true;
 845                 return;
 846             }
 847             else if (oldPosition == line->GetRange().GetEnd())
 848             {
 849                 if (m_caretAtLineStart)
 850                 {
 851                     // We're at the start of the line, so keep the same caret position
 852                     // but clear the start-of-line flag.
 853                     m_caretPosition = oldPosition;
 854                     m_caretAtLineStart = false;
 855                 }
 856                 else
 857                 {
 858                     // We're showing at the end of the line, so go back
 859                     // to the previous character position.
 860                     m_caretPosition = oldPosition - 1;
 861                 }
 862                 SetDefaultStyleToCursorStyle();
 863                 return;
 864             }
 865         }
 866     }
 867     m_caretPosition --;
 868     SetDefaultStyleToCursorStyle();
 869 }
 870
 871 /// Move right
 872 bool wxRichTextCtrl::MoveRight(int noPositions, int flags)
 873 {
 874     long endPos = GetBuffer().GetRange().GetEnd();
 875
 876     if (m_caretPosition + noPositions < endPos)
 877     {
 878         long oldPos = m_caretPosition;
 879         long newPos = m_caretPosition + noPositions;
 880
 881         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
 882         if (!extendSel)
 883             SelectNone();
 884
 885         // Determine by looking at oldPos and m_caretPosition whether
 886         // we moved from the end of a line to the start of the next line, in which case
 887         // we want to adjust the caret position such that it is positioned at the
 888         // start of the next line, rather than jumping past the first character of the
 889         // line.
 890         if (noPositions == 1 && !extendSel)
 891             MoveCaretForward(oldPos);
 892         else
 893             SetCaretPosition(newPos);
 894
 895         PositionCaret();
 896         SetDefaultStyleToCursorStyle();
 897
 898         if (!IsFrozen())
 899             Refresh(); // TODO: optimize so that if we didn't change the selection, we don't refresh
 900         return true;
 901     }
 902     else
 903         return false;
 904 }
 905
 906 /// Move left
 907 bool wxRichTextCtrl::MoveLeft(int noPositions, int flags)
 908 {
 909     long startPos = -1;
 910
 911     if (m_caretPosition > startPos - noPositions + 1)
 912     {
 913         long oldPos = m_caretPosition;
 914         long newPos = m_caretPosition - noPositions;
 915         bool extendSel = ExtendSelection(m_caretPosition, newPos, flags);
 916         if (!extendSel)
 917             SelectNone();
 918
 919         if (noPositions == 1 && !extendSel)
 920             MoveCaretBack(oldPos);
 921         else
 922             SetCaretPosition(newPos);
 923
 924         PositionCaret();
 925         SetDefaultStyleToCursorStyle();
 926
 927         if (!IsFrozen())
 928             Refresh();
 929         return true;
 930     }
 931     else
 932         return false;
 933 }
 934
 935 /// Move up
 936 bool wxRichTextCtrl::MoveUp(int noLines, int flags)
 937 {
 938     return MoveDown(- noLines, flags);
 939 }
 940
 941 /// Move up
 942 bool wxRichTextCtrl::MoveDown(int noLines, int flags)
 943 {
 944     long lineNumber = GetBuffer().GetVisibleLineNumber(m_caretPosition, true, m_caretAtLineStart);
 945     wxPoint pt = GetCaret()->GetPosition();
 946     long newLine = lineNumber + noLines;
 947
 948     if (lineNumber != -1)
 949     {
 950         if (noLines > 0)
 951         {
 952             long lastLine = GetBuffer().GetVisibleLineNumber(GetBuffer().GetRange().GetEnd());
 953
 954             if (newLine > lastLine)
 955                 return false;
 956         }
 957         else
 958         {
 959             if (newLine < 0)
 960                 return false;
 961         }
 962     }
 963
 964     wxRichTextLine* lineObj = GetBuffer().GetLineForVisibleLineNumber(newLine);
 965     if (lineObj)
 966     {
 967         pt.y = lineObj->GetAbsolutePosition().y + 2;
 968     }
 969     else
 970         return false;
 971
 972     long newPos = 0;
 973     wxClientDC dc(this);
 974     PrepareDC(dc);
 975     dc.SetFont(GetFont());
 976
 977     int hitTest = GetBuffer().HitTest(dc, pt, newPos);
 978
 979     if (hitTest != wxRICHTEXT_HITTEST_NONE)
 980     {
 981         // If end of previous line, and hitTest is wxRICHTEXT_HITTEST_BEFORE,
 982         // we want to be at the end of the last line but with m_caretAtLineStart set to true,
 983         // so we view the caret at the start of the line.
 984         bool caretLineStart = false;
 985         if (hitTest == wxRICHTEXT_HITTEST_BEFORE)
 986         {
 987             wxRichTextLine* thisLine = GetBuffer().GetLineAtPosition(newPos-1);
 988             if (thisLine && (newPos-1) == thisLine->GetRange().GetEnd())
 989             {
 990                 // if (para->GetRange().GetStart() != thisLine->GetRange().GetStart())
 991                 {
 992                     newPos --;
 993                     caretLineStart = true;
 994                 }
 995             }
 996             else
 997             {
 998                 wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(newPos);
 999                 if (para && para->GetRange().GetStart() == newPos)
1000                     newPos --;
1001             }
1002         }
1003
1004         long newSelEnd = newPos;
1005
1006         if (!ExtendSelection(m_caretPosition, newSelEnd, flags))
1007             SelectNone();
1008
1009         SetCaretPosition(newPos, caretLineStart);
1010         PositionCaret();
1011         SetDefaultStyleToCursorStyle();
1012
1013         if (!IsFrozen())
1014             Refresh();
1015         return true;
1016     }
1017     else
1018         return false;
1019 }
1020
1021 /// Move to the end of the paragraph
1022 bool wxRichTextCtrl::MoveToParagraphEnd(int flags)
1023 {
1024     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1025     if (para)
1026     {
1027         long newPos = para->GetRange().GetEnd() - 1;
1028         if (!ExtendSelection(m_caretPosition, newPos, flags))
1029             SelectNone();
1030
1031         SetCaretPosition(newPos);
1032         PositionCaret();
1033         SetDefaultStyleToCursorStyle();
1034
1035         if (!IsFrozen())
1036             Refresh();
1037         return true;
1038     }
1039
1040     return false;
1041 }
1042
1043 /// Move to the start of the paragraph
1044 bool wxRichTextCtrl::MoveToParagraphStart(int flags)
1045 {
1046     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(m_caretPosition, true);
1047     if (para)
1048     {
1049         long newPos = para->GetRange().GetStart() - 1;
1050         if (!ExtendSelection(m_caretPosition, newPos, flags))
1051             SelectNone();
1052
1053         SetCaretPosition(newPos);
1054         PositionCaret();
1055         SetDefaultStyleToCursorStyle();
1056
1057         if (!IsFrozen())
1058             Refresh();
1059         return true;
1060     }
1061
1062     return false;
1063 }
1064
1065 /// Move to the end of the line
1066 bool wxRichTextCtrl::MoveToLineEnd(int flags)
1067 {
1068     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1069
1070     if (line)
1071     {
1072         long newPos = line->GetRange().GetEnd();
1073         if (!ExtendSelection(m_caretPosition, newPos, flags))
1074             SelectNone();
1075
1076         SetCaretPosition(newPos);
1077         PositionCaret();
1078         SetDefaultStyleToCursorStyle();
1079
1080         if (!IsFrozen())
1081             Refresh();
1082         return true;
1083     }
1084
1085     return false;
1086 }
1087
1088 /// Move to the start of the line
1089 bool wxRichTextCtrl::MoveToLineStart(int flags)
1090 {
1091     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1092     if (line)
1093     {
1094         long newPos = line->GetRange().GetStart()-1;
1095
1096         if (!ExtendSelection(m_caretPosition, newPos, flags))
1097             SelectNone();
1098
1099         wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(line);
1100
1101         SetCaretPosition(newPos, para->GetRange().GetStart() != line->GetRange().GetStart());
1102         PositionCaret();
1103         SetDefaultStyleToCursorStyle();
1104
1105         if (!IsFrozen())
1106             Refresh();
1107         return true;
1108     }
1109
1110     return false;
1111 }
1112
1113 /// Move to the start of the buffer
1114 bool wxRichTextCtrl::MoveHome(int flags)
1115 {
1116     if (m_caretPosition != -1)
1117     {
1118         if (!ExtendSelection(m_caretPosition, -1, flags))
1119             SelectNone();
1120
1121         SetCaretPosition(-1);
1122         PositionCaret();
1123         SetDefaultStyleToCursorStyle();
1124
1125         if (!IsFrozen())
1126             Refresh();
1127         return true;
1128     }
1129     else
1130         return false;
1131 }
1132
1133 /// Move to the end of the buffer
1134 bool wxRichTextCtrl::MoveEnd(int flags)
1135 {
1136     long endPos = GetBuffer().GetRange().GetEnd()-1;
1137
1138     if (m_caretPosition != endPos)
1139     {
1140         if (!ExtendSelection(m_caretPosition, endPos, flags))
1141             SelectNone();
1142
1143         SetCaretPosition(endPos);
1144         PositionCaret();
1145         SetDefaultStyleToCursorStyle();
1146
1147         if (!IsFrozen())
1148             Refresh();
1149         return true;
1150     }
1151     else
1152         return false;
1153 }
1154
1155 /// Move noPages pages up
1156 bool wxRichTextCtrl::PageUp(int noPages, int flags)
1157 {
1158     return PageDown(- noPages, flags);
1159 }
1160
1161 /// Move noPages pages down
1162 bool wxRichTextCtrl::PageDown(int noPages, int flags)
1163 {
1164     // Calculate which line occurs noPages * screen height further down.
1165     wxRichTextLine* line = GetVisibleLineForCaretPosition(m_caretPosition);
1166     if (line)
1167     {
1168         wxSize clientSize = GetClientSize();
1169         int newY = line->GetAbsolutePosition().y + noPages*clientSize.y;
1170
1171         wxRichTextLine* newLine = GetBuffer().GetLineAtYPosition(newY);
1172         if (newLine)
1173         {
1174             long pos = newLine->GetRange().GetStart()-1;
1175             if (pos != m_caretPosition)
1176             {
1177                 wxRichTextParagraph* para = GetBuffer().GetParagraphForLine(newLine);
1178
1179                 if (!ExtendSelection(m_caretPosition, pos, flags))
1180                     SelectNone();
1181
1182                 SetCaretPosition(pos, para->GetRange().GetStart() != newLine->GetRange().GetStart());
1183                 PositionCaret();
1184                 SetDefaultStyleToCursorStyle();
1185
1186                 if (!IsFrozen())
1187                     Refresh();
1188                 return true;
1189             }
1190         }
1191     }
1192
1193     return false;
1194 }
1195
1196 // Finds the caret position for the next word
1197 long wxRichTextCtrl::FindNextWordPosition(int direction) const
1198 {
1199     long endPos = GetBuffer().GetRange().GetEnd();
1200
1201     if (direction > 0)
1202     {
1203         long i = m_caretPosition+1+direction; // +1 for conversion to character pos
1204
1205         // First skip current text to space
1206         while (i < endPos && i > -1)
1207         {
1208             // i is in character, not caret positions
1209             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1210             if (text != wxT(" ") && !text.empty())
1211                 i += direction;
1212             else
1213             {
1214                 break;
1215             }
1216         }
1217         while (i < endPos && i > -1)
1218         {
1219             // i is in character, not caret positions
1220             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1221             if (text.empty()) // End of paragraph, or maybe an image
1222                 return wxMax(-1, i - 1);
1223             else if (text == wxT(" ") || text.empty())
1224                 i += direction;
1225             else
1226             {
1227                 // Convert to caret position
1228                 return wxMax(-1, i - 1);
1229             }
1230         }
1231         if (i >= endPos)
1232             return endPos-1;
1233         return i-1;
1234     }
1235     else
1236     {
1237         long i = m_caretPosition;
1238
1239         // First skip white space
1240         while (i < endPos && i > -1)
1241         {
1242             // i is in character, not caret positions
1243             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1244             if (text.empty()) // End of paragraph, or maybe an image
1245                 break;
1246             else if (text == wxT(" ") || text.empty())
1247                 i += direction;
1248             else
1249                 break;
1250         }
1251         // Next skip current text to space
1252         while (i < endPos && i > -1)
1253         {
1254             // i is in character, not caret positions
1255             wxString text = GetBuffer().GetTextForRange(wxRichTextRange(i, i));
1256             if (text != wxT(" ") /* && !text.empty() */)
1257                 i += direction;
1258             else
1259             {
1260                 return i;
1261             }
1262         }
1263         if (i < -1)
1264             return -1;
1265         return i;
1266     }
1267 }
1268
1269 /// Move n words left
1270 bool wxRichTextCtrl::WordLeft(int WXUNUSED(n), int flags)
1271 {
1272     long pos = FindNextWordPosition(-1);
1273     if (pos != m_caretPosition)
1274     {
1275         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1276
1277         if (!ExtendSelection(m_caretPosition, pos, flags))
1278             SelectNone();
1279
1280         SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1281         PositionCaret();
1282         SetDefaultStyleToCursorStyle();
1283
1284         if (!IsFrozen())
1285             Refresh();
1286         return true;
1287     }
1288
1289     return false;
1290 }
1291
1292 /// Move n words right
1293 bool wxRichTextCtrl::WordRight(int WXUNUSED(n), int flags)
1294 {
1295     long pos = FindNextWordPosition(1);
1296     if (pos != m_caretPosition)
1297     {
1298         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(pos, true);
1299
1300         if (!ExtendSelection(m_caretPosition, pos, flags))
1301             SelectNone();
1302
1303         SetCaretPosition(pos, para->GetRange().GetStart() != pos);
1304         PositionCaret();
1305         SetDefaultStyleToCursorStyle();
1306
1307         if (!IsFrozen())
1308             Refresh();
1309         return true;
1310     }
1311
1312     return false;
1313 }
1314
1315 /// Sizing
1316 void wxRichTextCtrl::OnSize(wxSizeEvent& event)
1317 {
1318     GetBuffer().SetDirty(true);
1319
1320     RecreateBuffer();
1321
1322     event.Skip();
1323 }
1324
1325 /// Set up scrollbars, e.g. after a resize
1326 void wxRichTextCtrl::SetupScrollbars()
1327 {
1328     if (m_freezeCount)
1329         return;
1330
1331     if (GetBuffer().IsEmpty())
1332     {
1333         SetScrollbars(0, 0, 0, 0, 0, 0);
1334         return;
1335     }
1336
1337     // TODO: reimplement scrolling so we scroll by line, not by fixed number
1338     // of pixels. See e.g. wxVScrolledWindow for ideas.
1339     int pixelsPerUnit = 5; // 10;
1340     wxSize clientSize = GetClientSize();
1341
1342     int maxHeight = GetBuffer().GetCachedSize().y;
1343
1344     int unitsY = maxHeight/pixelsPerUnit;
1345
1346     int startX, startY;
1347     GetViewStart(& startX, & startY);
1348
1349     int maxPositionX = 0; // wxMax(sz.x - clientSize.x, 0);
1350     int maxPositionY = (wxMax(maxHeight - clientSize.y, 0))/pixelsPerUnit;
1351
1352     // Move to previous scroll position if
1353     // possible
1354     SetScrollbars(0, pixelsPerUnit,
1355         0, unitsY,
1356         wxMin(maxPositionX, startX), wxMin(maxPositionY, startY));
1357 }
1358
1359 /// Paint the background
1360 void wxRichTextCtrl::PaintBackground(wxDC& dc)
1361 {
1362     wxColour backgroundColour = GetBackgroundColour();
1363     if (!backgroundColour.Ok())
1364         backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1365
1366     // Clear the background
1367     dc.SetBrush(wxBrush(backgroundColour));
1368     dc.SetPen(*wxTRANSPARENT_PEN);
1369     wxRect windowRect(GetClientSize());
1370     windowRect.x -= 2; windowRect.y -= 2;
1371     windowRect.width += 4; windowRect.height += 4;
1372
1373     // We need to shift the rectangle to take into account
1374     // scrolling. Converting device to logical coordinates.
1375     CalcUnscrolledPosition(windowRect.x, windowRect.y, & windowRect.x, & windowRect.y);
1376     dc.DrawRectangle(windowRect);
1377 }
1378
1379 /// Recreate buffer bitmap if necessary
1380 bool wxRichTextCtrl::RecreateBuffer(const wxSize& size)
1381 {
1382     wxSize sz = size;
1383     if (sz == wxDefaultSize)
1384         sz = GetClientSize();
1385
1386     if (sz.x < 1 || sz.y < 1)
1387         return false;
1388
1389     if (!m_bufferBitmap.Ok() || m_bufferBitmap.GetWidth() < sz.x || m_bufferBitmap.GetHeight() < sz.y)
1390         m_bufferBitmap = wxBitmap(sz.x, sz.y);
1391     return m_bufferBitmap.Ok();
1392 }
1393
1394 // ----------------------------------------------------------------------------
1395 // file IO functions
1396 // ----------------------------------------------------------------------------
1397
1398 bool wxRichTextCtrl::LoadFile(const wxString& filename, int type)
1399 {
1400     bool success = GetBuffer().LoadFile(filename, type);
1401     if (success)
1402         m_filename = filename;
1403
1404     DiscardEdits();
1405     SetInsertionPoint(0);
1406     Layout();
1407     PositionCaret();
1408     Refresh();
1409     SendUpdateEvent();
1410
1411     if (success)
1412         return true;
1413     else
1414     {
1415         wxLogError(_("File couldn't be loaded."));
1416
1417         return false;
1418     }
1419 }
1420
1421 bool wxRichTextCtrl::SaveFile(const wxString& filename, int type)
1422 {
1423     wxString filenameToUse = filename.empty() ? m_filename : filename;
1424     if ( filenameToUse.empty() )
1425     {
1426         // what kind of message to give? is it an error or a program bug?
1427         wxLogDebug(wxT("Can't save textctrl to file without filename."));
1428
1429         return false;
1430     }
1431
1432     if (GetBuffer().SaveFile(filenameToUse, type))
1433     {
1434         m_filename = filenameToUse;
1435
1436         DiscardEdits();
1437
1438         return true;
1439
1440     }
1441
1442     wxLogError(_("The text couldn't be saved."));
1443
1444     return false;
1445 }
1446
1447 // ----------------------------------------------------------------------------
1448 // wxRichTextCtrl specific functionality
1449 // ----------------------------------------------------------------------------
1450
1451 /// Add a new paragraph of text to the end of the buffer
1452 wxRichTextRange wxRichTextCtrl::AddParagraph(const wxString& text)
1453 {
1454     return GetBuffer().AddParagraph(text);
1455 }
1456
1457 /// Add an image
1458 wxRichTextRange wxRichTextCtrl::AddImage(const wxImage& image)
1459 {
1460     return GetBuffer().AddImage(image);
1461 }
1462
1463 // ----------------------------------------------------------------------------
1464 // selection and ranges
1465 // ----------------------------------------------------------------------------
1466
1467 void wxRichTextCtrl::SelectAll()
1468 {
1469     SetSelection(0, GetLastPosition());
1470     m_selectionAnchor = -1;
1471 }
1472
1473 /// Select none
1474 void wxRichTextCtrl::SelectNone()
1475 {
1476     SetSelection(-2, -2);
1477     m_selectionAnchor = -2;
1478 }
1479
1480 wxString wxRichTextCtrl::GetStringSelection() const
1481 {
1482     long from, to;
1483     GetSelection(&from, &to);
1484
1485     return GetRange(from, to);
1486 }
1487
1488 // do the window-specific processing after processing the update event
1489 void wxRichTextCtrl::DoUpdateWindowUI(wxUpdateUIEvent& event)
1490 {
1491     if ( event.GetSetEnabled() )
1492         Enable(event.GetEnabled());
1493
1494     if ( event.GetSetText() )
1495     {
1496         if ( event.GetText() != GetValue() )
1497             SetValue(event.GetText());
1498     }
1499 }
1500
1501 // ----------------------------------------------------------------------------
1502 // hit testing
1503 // ----------------------------------------------------------------------------
1504
1505 wxTextCtrlHitTestResult
1506 wxRichTextCtrl::HitTest(const wxPoint& pt, wxTextCoord *x, wxTextCoord *y) const
1507 {
1508     // implement in terms of the other overload as the native ports typically
1509     // can get the position and not (x, y) pair directly (although wxUniv
1510     // directly gets x and y -- and so overrides this method as well)
1511     long pos;
1512     wxTextCtrlHitTestResult rc = HitTest(pt, &pos);
1513
1514     if ( rc != wxTE_HT_UNKNOWN )
1515     {
1516         PositionToXY(pos, x, y);
1517     }
1518
1519     return rc;
1520 }
1521
1522 wxTextCtrlHitTestResult
1523 wxRichTextCtrl::HitTest(const wxPoint& pt,
1524                         long * pos) const
1525 {
1526     wxClientDC dc((wxRichTextCtrl*) this);
1527     ((wxRichTextCtrl*)this)->PrepareDC(dc);
1528
1529     int hit = ((wxRichTextCtrl*)this)->GetBuffer().HitTest(dc, pt, *pos);
1530     if (hit == wxRICHTEXT_HITTEST_BEFORE)
1531         return wxTE_HT_BEFORE;
1532     else if (hit == wxRICHTEXT_HITTEST_AFTER)
1533         return wxTE_HT_BEYOND;
1534     else if (hit == wxRICHTEXT_HITTEST_ON)
1535         return wxTE_HT_ON_TEXT;
1536     else
1537         return wxTE_HT_UNKNOWN;
1538 }
1539
1540 // ----------------------------------------------------------------------------
1541 // set/get the controls text
1542 // ----------------------------------------------------------------------------
1543
1544 wxString wxRichTextCtrl::GetValue() const
1545 {
1546     return GetBuffer().GetText();
1547 }
1548
1549 wxString wxRichTextCtrl::GetRange(long from, long to) const
1550 {
1551     return GetBuffer().GetTextForRange(wxRichTextRange(from, to));
1552 }
1553
1554 void wxRichTextCtrl::SetValue(const wxString& value)
1555 {
1556     Clear();
1557
1558     // if the text is long enough, it's faster to just set it instead of first
1559     // comparing it with the old one (chances are that it will be different
1560     // anyhow, this comparison is there to avoid flicker for small single-line
1561     // edit controls mostly)
1562     if ( (value.length() > 0x400) || (value != GetValue()) )
1563     {
1564         DoWriteText(value, false /* not selection only */);
1565
1566         // for compatibility, don't move the cursor when doing SetValue()
1567         SetInsertionPoint(0);
1568     }
1569     else // same text
1570     {
1571         // still send an event for consistency
1572         SendUpdateEvent();
1573     }
1574
1575     // we should reset the modified flag even if the value didn't really change
1576
1577     // mark the control as being not dirty - we changed its text, not the
1578     // user
1579     DiscardEdits();
1580 }
1581
1582 void wxRichTextCtrl::WriteText(const wxString& value)
1583 {
1584     DoWriteText(value);
1585 }
1586
1587 void wxRichTextCtrl::DoWriteText(const wxString& value, bool WXUNUSED(selectionOnly))
1588 {
1589     GetBuffer().InsertTextWithUndo(m_caretPosition+1, value, this);
1590 }
1591
1592 void wxRichTextCtrl::AppendText(const wxString& text)
1593 {
1594     SetInsertionPointEnd();
1595
1596     WriteText(text);
1597 }
1598
1599 /// Write an image at the current insertion point
1600 bool wxRichTextCtrl::WriteImage(const wxImage& image, int bitmapType)
1601 {
1602     wxRichTextImageBlock imageBlock;
1603
1604     wxImage image2 = image;
1605     if (imageBlock.MakeImageBlock(image2, bitmapType))
1606         return WriteImage(imageBlock);
1607     else
1608         return false;
1609 }
1610
1611 bool wxRichTextCtrl::WriteImage(const wxString& filename, int bitmapType)
1612 {
1613     wxRichTextImageBlock imageBlock;
1614
1615     wxImage image;
1616     if (imageBlock.MakeImageBlock(filename, bitmapType, image, false))
1617         return WriteImage(imageBlock);
1618     else
1619         return false;
1620 }
1621
1622 bool wxRichTextCtrl::WriteImage(const wxRichTextImageBlock& imageBlock)
1623 {
1624     return GetBuffer().InsertImageWithUndo(m_caretPosition+1, imageBlock, this);
1625 }
1626
1627 bool wxRichTextCtrl::WriteImage(const wxBitmap& bitmap, int bitmapType)
1628 {
1629     if (bitmap.Ok())
1630     {
1631         wxRichTextImageBlock imageBlock;
1632
1633         wxImage image = bitmap.ConvertToImage();
1634         if (image.Ok() && imageBlock.MakeImageBlock(image, bitmapType))
1635             return WriteImage(imageBlock);
1636         else
1637             return false;
1638     }
1639     return false;
1640 }
1641
1642 /// Insert a newline (actually paragraph) at the current insertion point.
1643 bool wxRichTextCtrl::Newline()
1644 {
1645     return GetBuffer().InsertNewlineWithUndo(m_caretPosition+1, this);
1646 }
1647
1648
1649 // ----------------------------------------------------------------------------
1650 // Clipboard operations
1651 // ----------------------------------------------------------------------------
1652
1653 void wxRichTextCtrl::Copy()
1654 {
1655     if (CanCopy())
1656     {
1657         wxRichTextRange range = GetSelectionRange();
1658         GetBuffer().CopyToClipboard(range);
1659     }
1660 }
1661
1662 void wxRichTextCtrl::Cut()
1663 {
1664     if (CanCut())
1665     {
1666         wxRichTextRange range = GetSelectionRange();
1667         GetBuffer().CopyToClipboard(range);
1668
1669         DeleteSelectedContent();
1670         Layout();
1671         Refresh();
1672     }
1673 }
1674
1675 void wxRichTextCtrl::Paste()
1676 {
1677     if (CanPaste())
1678     {
1679         BeginBatchUndo(_("Paste"));
1680
1681         long newPos = m_caretPosition;
1682         DeleteSelectedContent(& newPos);
1683
1684         GetBuffer().PasteFromClipboard(newPos);
1685
1686         EndBatchUndo();
1687     }
1688 }
1689
1690 void wxRichTextCtrl::DeleteSelection()
1691 {
1692     if (CanDeleteSelection())
1693     {
1694         DeleteSelectedContent();
1695     }
1696 }
1697
1698 bool wxRichTextCtrl::HasSelection() const
1699 {
1700     return m_selectionRange.GetStart() != -2 && m_selectionRange.GetEnd() != -2;
1701 }
1702
1703 bool wxRichTextCtrl::CanCopy() const
1704 {
1705     // Can copy if there's a selection
1706     return HasSelection();
1707 }
1708
1709 bool wxRichTextCtrl::CanCut() const
1710 {
1711     return HasSelection() && IsEditable();
1712 }
1713
1714 bool wxRichTextCtrl::CanPaste() const
1715 {
1716     if ( !IsEditable() )
1717         return false;
1718
1719     return GetBuffer().CanPasteFromClipboard();
1720 }
1721
1722 bool wxRichTextCtrl::CanDeleteSelection() const
1723 {
1724     return HasSelection() && IsEditable();
1725 }
1726
1727
1728 // ----------------------------------------------------------------------------
1729 // Accessors
1730 // ----------------------------------------------------------------------------
1731
1732 void wxRichTextCtrl::SetEditable(bool editable)
1733 {
1734     m_editable = editable;
1735 }
1736
1737 void wxRichTextCtrl::SetInsertionPoint(long pos)
1738 {
1739     SelectNone();
1740
1741     m_caretPosition = pos - 1;
1742 }
1743
1744 void wxRichTextCtrl::SetInsertionPointEnd()
1745 {
1746     long pos = GetLastPosition();
1747     SetInsertionPoint(pos);
1748 }
1749
1750 long wxRichTextCtrl::GetInsertionPoint() const
1751 {
1752     return m_caretPosition+1;
1753 }
1754
1755 wxTextPos wxRichTextCtrl::GetLastPosition() const
1756 {
1757     return GetBuffer().GetRange().GetEnd();
1758 }
1759
1760 // If the return values from and to are the same, there is no
1761 // selection.
1762 void wxRichTextCtrl::GetSelection(long* from, long* to) const
1763 {
1764     *from = m_selectionRange.GetStart();
1765     *to = m_selectionRange.GetEnd();
1766 }
1767
1768 bool wxRichTextCtrl::IsEditable() const
1769 {
1770     return m_editable;
1771 }
1772
1773 // ----------------------------------------------------------------------------
1774 // selection
1775 // ----------------------------------------------------------------------------
1776
1777 void wxRichTextCtrl::SetSelection(long from, long to)
1778 {
1779     // if from and to are both -1, it means (in wxWidgets) that all text should
1780     // be selected.
1781     if ( (from == -1) && (to == -1) )
1782     {
1783         from = 0;
1784         to = GetLastPosition();
1785     }
1786
1787     DoSetSelection(from, to);
1788 }
1789
1790 void wxRichTextCtrl::DoSetSelection(long from, long to, bool WXUNUSED(scrollCaret))
1791 {
1792     m_selectionAnchor = from;
1793     m_selectionRange.SetRange(from, to);
1794     if (!IsFrozen())
1795         Refresh();
1796     PositionCaret();
1797 }
1798
1799 // ----------------------------------------------------------------------------
1800 // Editing
1801 // ----------------------------------------------------------------------------
1802
1803 void wxRichTextCtrl::Replace(long WXUNUSED(from), long WXUNUSED(to), const wxString& value)
1804 {
1805     BeginBatchUndo(_("Replace"));
1806
1807     DeleteSelectedContent();
1808
1809     DoWriteText(value, true /* selection only */);
1810
1811     EndBatchUndo();
1812 }
1813
1814 void wxRichTextCtrl::Remove(long from, long to)
1815 {
1816     SelectNone();
1817
1818     GetBuffer().DeleteRangeWithUndo(wxRichTextRange(from, to),
1819         m_caretPosition,       // Current caret position
1820         from,                           // New caret position
1821         this);
1822
1823     Layout();
1824     if (!IsFrozen())
1825         Refresh();
1826 }
1827
1828 bool wxRichTextCtrl::IsModified() const
1829 {
1830     return m_buffer.IsModified();
1831 }
1832
1833 void wxRichTextCtrl::MarkDirty()
1834 {
1835     m_buffer.Modify(true);
1836 }
1837
1838 void wxRichTextCtrl::DiscardEdits()
1839 {
1840     m_buffer.Modify(false);
1841     m_buffer.GetCommandProcessor()->ClearCommands();
1842 }
1843
1844 int wxRichTextCtrl::GetNumberOfLines() const
1845 {
1846     return GetBuffer().GetParagraphCount();
1847 }
1848
1849 // ----------------------------------------------------------------------------
1850 // Positions <-> coords
1851 // ----------------------------------------------------------------------------
1852
1853 long wxRichTextCtrl::XYToPosition(long x, long y) const
1854 {
1855     return GetBuffer().XYToPosition(x, y);
1856 }
1857
1858 bool wxRichTextCtrl::PositionToXY(long pos, long *x, long *y) const
1859 {
1860     return GetBuffer().PositionToXY(pos, x, y);
1861 }
1862
1863 // ----------------------------------------------------------------------------
1864 //
1865 // ----------------------------------------------------------------------------
1866
1867 void wxRichTextCtrl::ShowPosition(long pos)
1868 {
1869     if (!IsPositionVisible(pos))
1870         ScrollIntoView(pos-1, WXK_DOWN);
1871 }
1872
1873 int wxRichTextCtrl::GetLineLength(long lineNo) const
1874 {
1875     return GetBuffer().GetParagraphLength(lineNo);
1876 }
1877
1878 wxString wxRichTextCtrl::GetLineText(long lineNo) const
1879 {
1880     return GetBuffer().GetParagraphText(lineNo);
1881 }
1882
1883 // ----------------------------------------------------------------------------
1884 // Undo/redo
1885 // ----------------------------------------------------------------------------
1886
1887 void wxRichTextCtrl::Undo()
1888 {
1889     if (CanUndo())
1890     {
1891         GetCommandProcessor()->Undo();
1892     }
1893 }
1894
1895 void wxRichTextCtrl::Redo()
1896 {
1897     if (CanRedo())
1898     {
1899         GetCommandProcessor()->Redo();
1900     }
1901 }
1902
1903 bool wxRichTextCtrl::CanUndo() const
1904 {
1905     return GetCommandProcessor()->CanUndo();
1906 }
1907
1908 bool wxRichTextCtrl::CanRedo() const
1909 {
1910     return GetCommandProcessor()->CanRedo();
1911 }
1912
1913 // ----------------------------------------------------------------------------
1914 // implemenation details
1915 // ----------------------------------------------------------------------------
1916
1917 void wxRichTextCtrl::Command(wxCommandEvent & event)
1918 {
1919     SetValue(event.GetString());
1920     GetEventHandler()->ProcessEvent(event);
1921 }
1922
1923 void wxRichTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1924 {
1925     // By default, load the first file into the text window.
1926     if (event.GetNumberOfFiles() > 0)
1927     {
1928         LoadFile(event.GetFiles()[0]);
1929     }
1930 }
1931
1932 // ----------------------------------------------------------------------------
1933 // text control event processing
1934 // ----------------------------------------------------------------------------
1935
1936 bool wxRichTextCtrl::SendUpdateEvent()
1937 {
1938     wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
1939     InitCommandEvent(event);
1940
1941     return GetEventHandler()->ProcessEvent(event);
1942 }
1943
1944 void wxRichTextCtrl::InitCommandEvent(wxCommandEvent& event) const
1945 {
1946     event.SetEventObject((wxControlBase *)this);    // const_cast
1947
1948     switch ( m_clientDataType )
1949     {
1950         case wxClientData_Void:
1951             event.SetClientData(GetClientData());
1952             break;
1953
1954         case wxClientData_Object:
1955             event.SetClientObject(GetClientObject());
1956             break;
1957
1958         case wxClientData_None:
1959             // nothing to do
1960             ;
1961     }
1962 }
1963
1964
1965 wxSize wxRichTextCtrl::DoGetBestSize() const
1966 {
1967     return wxSize(10, 10);
1968 }
1969
1970 // ----------------------------------------------------------------------------
1971 // standard handlers for standard edit menu events
1972 // ----------------------------------------------------------------------------
1973
1974 void wxRichTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1975 {
1976     Cut();
1977 }
1978
1979 void wxRichTextCtrl::OnClear(wxCommandEvent& WXUNUSED(event))
1980 {
1981     DeleteSelection();
1982 }
1983
1984 void wxRichTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1985 {
1986     Copy();
1987 }
1988
1989 void wxRichTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1990 {
1991     Paste();
1992 }
1993
1994 void wxRichTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1995 {
1996     Undo();
1997 }
1998
1999 void wxRichTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2000 {
2001     Redo();
2002 }
2003
2004 void wxRichTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2005 {
2006     event.Enable( CanCut() );
2007 }
2008
2009 void wxRichTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2010 {
2011     event.Enable( CanCopy() );
2012 }
2013
2014 void wxRichTextCtrl::OnUpdateClear(wxUpdateUIEvent& event)
2015 {
2016     event.Enable( CanDeleteSelection() );
2017 }
2018
2019 void wxRichTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2020 {
2021     event.Enable( CanPaste() );
2022 }
2023
2024 void wxRichTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2025 {
2026     event.Enable( CanUndo() );
2027     event.SetText( GetCommandProcessor()->GetUndoMenuLabel() );
2028 }
2029
2030 void wxRichTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2031 {
2032     event.Enable( CanRedo() );
2033     event.SetText( GetCommandProcessor()->GetRedoMenuLabel() );
2034 }
2035
2036 void wxRichTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
2037 {
2038     SelectAll();
2039 }
2040
2041 void wxRichTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
2042 {
2043     event.Enable(GetLastPosition() > 0);
2044 }
2045
2046 void wxRichTextCtrl::OnContextMenu(wxContextMenuEvent& WXUNUSED(event))
2047 {
2048     if (!m_contextMenu)
2049     {
2050         m_contextMenu = new wxMenu;
2051         m_contextMenu->Append(wxID_UNDO, _("&Undo"));
2052         m_contextMenu->Append(wxID_REDO, _("&Redo"));
2053         m_contextMenu->AppendSeparator();
2054         m_contextMenu->Append(wxID_CUT, _("Cu&t"));
2055         m_contextMenu->Append(wxID_COPY, _("&Copy"));
2056         m_contextMenu->Append(wxID_PASTE, _("&Paste"));
2057         m_contextMenu->Append(wxID_CLEAR, _("&Delete"));
2058         m_contextMenu->AppendSeparator();
2059         m_contextMenu->Append(wxID_SELECTALL, _("Select &All"));
2060     }
2061     PopupMenu(m_contextMenu);
2062     return;
2063 }
2064
2065 bool wxRichTextCtrl::SetStyle(long start, long end, const wxTextAttrEx& style)
2066 {
2067     return GetBuffer().SetStyle(wxRichTextRange(start, end), style);
2068 }
2069
2070 bool wxRichTextCtrl::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style)
2071 {
2072     return GetBuffer().SetStyle(range, style);
2073 }
2074
2075 bool wxRichTextCtrl::SetDefaultStyle(const wxTextAttrEx& style)
2076 {
2077     return GetBuffer().SetDefaultStyle(style);
2078 }
2079
2080 const wxTextAttrEx& wxRichTextCtrl::GetDefaultStyleEx() const
2081 {
2082     return GetBuffer().GetDefaultStyle();
2083 }
2084
2085 bool wxRichTextCtrl::GetStyle(long position, wxTextAttrEx& style) const
2086 {
2087     return GetBuffer().GetStyle(position, style);
2088 }
2089
2090 bool wxRichTextCtrl::GetStyle(long position, wxRichTextAttr& style) const
2091 {
2092     return GetBuffer().GetStyle(position, style);
2093 }
2094
2095 /// Set font, and also the buffer attributes
2096 bool wxRichTextCtrl::SetFont(const wxFont& font)
2097 {
2098 #if wxRICHTEXT_DERIVES_FROM_TEXTCTRLBASE
2099     wxControl::SetFont(font);
2100 #else
2101     wxScrolledWindow::SetFont(font);
2102 #endif
2103
2104     wxTextAttrEx attr = GetBuffer().GetAttributes();
2105     attr.SetFont(font);
2106     GetBuffer().SetBasicStyle(attr);
2107     GetBuffer().SetDefaultStyle(attr);
2108
2109     return true;
2110 }
2111
2112 /// Transform logical to physical (unscrolling)
2113 wxPoint wxRichTextCtrl::GetPhysicalPoint(const wxPoint& ptLogical)
2114 {
2115     wxPoint pt;
2116     CalcScrolledPosition(ptLogical.x, ptLogical.y, & pt.x, & pt.y);
2117
2118     return pt;
2119 }
2120
2121 /// Transform physical to logical
2122 wxPoint wxRichTextCtrl::GetLogicalPoint(const wxPoint& ptPhysical)
2123 {
2124     wxPoint pt;
2125     CalcUnscrolledPosition(ptPhysical.x, ptPhysical.y, & pt.x, & pt.y);
2126
2127     return pt;
2128 }
2129
2130 /// Position the caret
2131 void wxRichTextCtrl::PositionCaret()
2132 {
2133     wxRect caretRect;
2134     if (GetCaretPositionForIndex(GetCaretPosition(), caretRect))
2135     {
2136         wxPoint originalPt = caretRect.GetPosition();
2137         wxPoint pt = GetPhysicalPoint(originalPt);
2138
2139         GetCaret()->Move(pt);
2140         GetCaret()->SetSize(caretRect.GetSize());
2141     }
2142 }
2143
2144 /// Get the caret height and position for the given character position
2145 bool wxRichTextCtrl::GetCaretPositionForIndex(long position, wxRect& rect)
2146 {
2147     wxClientDC dc(this);
2148     dc.SetFont(GetFont());
2149
2150     PrepareDC(dc);
2151
2152     wxPoint pt;
2153     int height = 0;
2154
2155     if (GetBuffer().FindPosition(dc, position, pt, & height, m_caretAtLineStart))
2156     {
2157         rect = wxRect(pt, wxSize(wxRICHTEXT_DEFAULT_CARET_WIDTH, height));
2158         return true;
2159     }
2160     else
2161         return false;
2162 }
2163
2164 /// Gets the line for the visible caret position. If the caret is
2165 /// shown at the very end of the line, it means the next character is actually
2166 /// on the following line. So let's get the line we're expecting to find
2167 /// if this is the case.
2168 wxRichTextLine* wxRichTextCtrl::GetVisibleLineForCaretPosition(long caretPosition) const
2169 {
2170     wxRichTextLine* line = GetBuffer().GetLineAtPosition(caretPosition, true);
2171     wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(caretPosition, true);
2172     if (line)
2173     {
2174         if (caretPosition == line->GetRange().GetStart()-1 &&
2175             (para->GetRange().GetStart() != line->GetRange().GetStart()))
2176         {
2177             if (!m_caretAtLineStart)
2178                 line = GetBuffer().GetLineAtPosition(caretPosition-1, true);
2179         }
2180     }
2181     return line;
2182 }
2183
2184
2185 /// Move the caret to the given character position
2186 bool wxRichTextCtrl::MoveCaret(long pos, bool showAtLineStart)
2187 {
2188     if (GetBuffer().GetDirty())
2189         Layout();
2190
2191     if (pos <= GetBuffer().GetRange().GetEnd())
2192     {
2193         SetCaretPosition(pos, showAtLineStart);
2194
2195         PositionCaret();
2196
2197         return true;
2198     }
2199     else
2200         return false;
2201 }
2202
2203 /// Layout the buffer: which we must do before certain operations, such as
2204 /// setting the caret position.
2205 bool wxRichTextCtrl::Layout()
2206 {
2207     wxRect availableSpace(GetClientSize());
2208     if (availableSpace.width == 0)
2209         availableSpace.width = 10;
2210     if (availableSpace.height == 0)
2211         availableSpace.height = 10;
2212
2213     wxClientDC dc(this);
2214     dc.SetFont(GetFont());
2215
2216     PrepareDC(dc);
2217
2218     GetBuffer().Defragment();
2219     GetBuffer().UpdateRanges();     // If items were deleted, ranges need recalculation
2220     GetBuffer().Layout(dc, availableSpace, GetBuffer().GetRange(), wxRICHTEXT_FIXED_WIDTH|wxRICHTEXT_VARIABLE_HEIGHT);
2221     GetBuffer().SetDirty(false);
2222
2223     if (!IsFrozen())
2224         SetupScrollbars();
2225
2226     return true;
2227 }
2228
2229 /// Is all of the selection bold?
2230 bool wxRichTextCtrl::IsSelectionBold() const
2231 {
2232     if (HasSelection())
2233     {
2234         wxRichTextAttr attr;
2235         wxRichTextRange range = GetSelectionRange();
2236         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2237         attr.SetFontWeight(wxBOLD);
2238
2239         return HasCharacterAttributes(range, attr);
2240     }
2241     else
2242     {
2243         // If no selection, then we need to combine current style with default style
2244         // to see what the effect would be if we started typing.
2245         wxRichTextAttr attr;
2246         attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2247         if (GetStyle(GetCaretPosition()+1, attr))
2248         {
2249             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2250             return attr.GetFontWeight() == wxBOLD;
2251         }
2252     }
2253     return false;
2254 }
2255
2256 /// Is all of the selection italics?
2257 bool wxRichTextCtrl::IsSelectionItalics() const
2258 {
2259     if (HasSelection())
2260     {
2261         wxRichTextRange range = GetSelectionRange();
2262         wxRichTextAttr attr;
2263         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2264         attr.SetFontStyle(wxITALIC);
2265
2266         return HasCharacterAttributes(range, attr);
2267     }
2268     else
2269     {
2270         // If no selection, then we need to combine current style with default style
2271         // to see what the effect would be if we started typing.
2272         wxRichTextAttr attr;
2273         attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2274         if (GetStyle(GetCaretPosition()+1, attr))
2275         {
2276             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2277             return attr.GetFontStyle() == wxITALIC;
2278         }
2279     }
2280     return false;
2281 }
2282
2283 /// Is all of the selection underlined?
2284 bool wxRichTextCtrl::IsSelectionUnderlined() const
2285 {
2286     if (HasSelection())
2287     {
2288         wxRichTextRange range = GetSelectionRange();
2289         wxRichTextAttr attr;
2290         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2291         attr.SetFontUnderlined(true);
2292
2293         return HasCharacterAttributes(range, attr);
2294     }
2295     else
2296     {
2297         // If no selection, then we need to combine current style with default style
2298         // to see what the effect would be if we started typing.
2299         wxRichTextAttr attr;
2300         attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2301         if (GetStyle(GetCaretPosition()+1, attr))
2302         {
2303             wxRichTextApplyStyle(attr, GetDefaultStyleEx());
2304             return attr.GetFontUnderlined();
2305         }
2306     }
2307     return false;
2308 }
2309
2310 /// Apply bold to the selection
2311 bool wxRichTextCtrl::ApplyBoldToSelection()
2312 {
2313     wxRichTextAttr attr;
2314     attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
2315     attr.SetFontWeight(IsSelectionBold() ? wxNORMAL : wxBOLD);
2316
2317     if (HasSelection())
2318         return SetStyle(GetSelectionRange(), attr);
2319     else
2320         SetDefaultStyle(attr);
2321     return true;
2322 }
2323
2324 /// Apply italic to the selection
2325 bool wxRichTextCtrl::ApplyItalicToSelection()
2326 {
2327     wxRichTextAttr attr;
2328     attr.SetFlags(wxTEXT_ATTR_FONT_ITALIC);
2329     attr.SetFontStyle(IsSelectionItalics() ? wxNORMAL : wxITALIC);
2330
2331     if (HasSelection())
2332         return SetStyle(GetSelectionRange(), attr);
2333     else
2334         SetDefaultStyle(attr);
2335     return true;
2336 }
2337
2338 /// Apply underline to the selection
2339 bool wxRichTextCtrl::ApplyUnderlineToSelection()
2340 {
2341     wxRichTextAttr attr;
2342     attr.SetFlags(wxTEXT_ATTR_FONT_UNDERLINE);
2343     attr.SetFontWeight(!IsSelectionUnderlined());
2344
2345     if (HasSelection())
2346         return SetStyle(GetSelectionRange(), attr);
2347     else
2348         SetDefaultStyle(attr);
2349     return true;
2350 }
2351
2352 /// Is all of the selection aligned according to the specified flag?
2353 bool wxRichTextCtrl::IsSelectionAligned(wxTextAttrAlignment alignment) const
2354 {
2355     if (HasSelection())
2356     {
2357         wxRichTextRange range = GetSelectionRange();
2358         wxRichTextAttr attr;
2359         attr.SetAlignment(alignment);
2360
2361         return HasParagraphAttributes(range, attr);
2362     }
2363     else
2364     {
2365         // If no selection, then we need to get information from the current paragraph.
2366         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2367         if (para)
2368             return para->GetAttributes().GetAlignment() == alignment;
2369     }
2370     return false;
2371 }
2372
2373 /// Apply alignment to the selection
2374 bool wxRichTextCtrl::ApplyAlignmentToSelection(wxTextAttrAlignment alignment)
2375 {
2376     wxRichTextAttr attr;
2377     attr.SetAlignment(alignment);
2378     if (HasSelection())
2379         return SetStyle(GetSelectionRange(), attr);
2380     else
2381     {
2382         wxRichTextParagraph* para = GetBuffer().GetParagraphAtPosition(GetCaretPosition()+1);
2383         if (para)
2384             return SetStyle(para->GetRange(), attr);
2385     }
2386     return true;
2387 }
2388
2389 /// Sets the default style to the style under the cursor
2390 bool wxRichTextCtrl::SetDefaultStyleToCursorStyle()
2391 {
2392     wxTextAttrEx attr;
2393     attr.SetFlags(wxTEXT_ATTR_CHARACTER);
2394
2395     if (GetStyle(GetCaretPosition(), attr))
2396     {
2397         SetDefaultStyle(attr);
2398         return true;
2399     }
2400     else
2401         return false;
2402 }
2403
2404 #endif
2405     // wxUSE_RICHTEXT
2406