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