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