]> git.saurik.com Git - wxWidgets.git/blob - src/univ/textctrl.cpp
make it possible to change the text of the item being edited from OnBeginLabelEdit()
[wxWidgets.git] / src / univ / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: univ/textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 15.09.00
7 // RCS-ID: $Id$
8 // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 /*
13 TODO
14
15 + 1. update vert scrollbar when any line length changes for WrapLines()
16 + 2. cursor movement ("Hello,^" -> "^verse!" on Arrow Down)?
17 -> maybe save the x position and use it instead of current in handling
18 DOWN/UP actions (this would make up/down always return the cursor to
19 the same location)?
20 3. split file into chunks
21 +? 4. rewrite Replace() refresh logic to deal with wrapping lines
22 +? 5. cache info found by GetPartOfWrappedLine() - performance must be horrible
23 with lots of text
24
25 6. backspace refreshes too much (until end of line)
26 */
27
28 /*
29 Optimisation hints from PureQuantify:
30
31 +1. wxStringTokenize is the slowest part of Replace
32 2. GetDC/ReleaseDC are very slow, avoid calling them several times
33 +3. GetCharHeight() should be cached too
34 4. wxClientDC construction/destruction in HitTestLine is horribly expensive
35
36 For line wrapping controls HitTest2 takes 50% of program time. The results
37 of GetRowsPerLine and GetPartOfWrappedLine *MUST* be cached.
38
39 Search for "OPT!" for things which must be optimized.
40 */
41
42 /*
43 Some terminology:
44
45 Everywhere in this file LINE refers to a logical line of text, and ROW to a
46 physical line of text on the display. They are the same unless WrapLines()
47 is true in which case a single LINE may correspond to multiple ROWs.
48
49 A text position is an unsigned int (which for reasons of compatibility is
50 still a long as wxTextPos) from 0 to GetLastPosition() inclusive. The positions
51 correspond to the gaps between the letters so the position 0 is just
52 before the first character and the last position is the one beyond the last
53 character. For an empty text control GetLastPosition() returns 0.
54
55 Lines and columns returned/accepted by XYToPosition() and PositionToXY()
56 start from 0. The y coordinate is a LINE, not a ROW. Columns correspond to
57 the characters, the first column of a line is the first character in it,
58 the last one is length(line text). For compatibility, again, lines and
59 columns are also longs.
60
61 When translating lines/column coordinates to/from positions, the line and
62 column give the character after the given position. Thus, GetLastPosition()
63 doesn't have any corresponding column.
64
65 An example of positions and lines/columns for a control without wrapping
66 containing the text "Hello, Universe!\nGoodbye"
67
68 1 1 1 1 1 1 1
69 pos: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
70 H e l l o , U n i v e r s e ! line 0
71 col: 0 1 2 3 4 5 6 7 8 9 1 1 1 1 1 1
72 0 1 2 3 4 5
73
74 pos: 1 1 1 2 2 2 2 2
75 7 8 9 0 1 2 3 4
76 G o o d b y e line 1
77 col: 0 1 2 3 4 5 6
78
79
80 The same example for a control with line wrap assuming "Universe" is too
81 long to fit on the same line with "Hello,":
82
83 pos: 0 1 2 3 4 5
84 H e l l o , line 0 (row 0)
85 col: 0 1 2 3 4 5
86
87 1 1 1 1 1 1 1
88 pos: 6 7 8 9 0 1 2 3 4 5 6
89 U n i v e r s e ! line 0 (row 1)
90 col: 6 7 8 9 1 1 1 1 1 1
91 0 1 2 3 4 5
92
93 (line 1 == row 2 same as above)
94
95 Note that there is still the same number of columns and positions and that
96 there is no (logical) position at the end of the first ROW. This position
97 is identified with the preceding one (which is not how Windows does it: it
98 identifies it with the next one, i.e. the first position of the next line,
99 but much more logical IMHO).
100 */
101
102 /*
103 Search for "OPT" for possible optimizations
104
105 A possible global optimization would be to always store the coords in the
106 text in triplets (pos, col, line) and update them simultaneously instead of
107 recalculating col and line from pos each time it is needed. Currently we
108 only do it for the current position but we might also do it for the
109 selection start and end.
110 */
111
112 // ============================================================================
113 // declarations
114 // ============================================================================
115
116 // ----------------------------------------------------------------------------
117 // headers
118 // ----------------------------------------------------------------------------
119
120 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
121 #pragma implementation "univtextctrl.h"
122 #endif
123
124 #include "wx/wxprec.h"
125
126 #ifdef __BORLANDC__
127 #pragma hdrstop
128 #endif
129
130 #if wxUSE_TEXTCTRL
131
132 #include <ctype.h>
133
134 #ifndef WX_PRECOMP
135 #include "wx/log.h"
136
137 #include "wx/dcclient.h"
138 #include "wx/validate.h"
139 #include "wx/textctrl.h"
140 #endif
141
142 #include "wx/clipbrd.h"
143
144 #include "wx/textfile.h"
145
146 #include "wx/caret.h"
147
148 #include "wx/univ/inphand.h"
149 #include "wx/univ/renderer.h"
150 #include "wx/univ/colschem.h"
151 #include "wx/univ/theme.h"
152
153 #include "wx/cmdproc.h"
154
155 #if wxUSE_CLIPBOARD
156 #include "wx/dataobj.h"
157 #endif
158
159 // turn extra wxTextCtrl-specific debugging on/off
160 #define WXDEBUG_TEXT
161
162 // turn wxTextCtrl::Replace() debugging on (slows down code a *lot*!)
163 #define WXDEBUG_TEXT_REPLACE
164
165 #ifndef __WXDEBUG__
166 #undef WXDEBUG_TEXT
167 #undef WXDEBUG_TEXT_REPLACE
168 #endif
169
170 // wxStringTokenize only needed for debug checks
171 #ifdef WXDEBUG_TEXT_REPLACE
172 #include "wx/tokenzr.h"
173 #endif // WXDEBUG_TEXT_REPLACE
174
175 // ----------------------------------------------------------------------------
176 // private functions
177 // ----------------------------------------------------------------------------
178
179 // exchange two positions so that from is always less than or equal to to
180 static inline void OrderPositions(wxTextPos& from, wxTextPos& to)
181 {
182 if ( from > to )
183 {
184 wxTextPos tmp = from;
185 from = to;
186 to = tmp;
187 }
188 }
189
190 // ----------------------------------------------------------------------------
191 // constants
192 // ----------------------------------------------------------------------------
193
194 // names of text ctrl commands
195 #define wxTEXT_COMMAND_INSERT _T("insert")
196 #define wxTEXT_COMMAND_REMOVE _T("remove")
197
198 // the value which is never used for text position, even not -1 which is
199 // sometimes used for some special meaning
200 static const wxTextPos INVALID_POS_VALUE = wxInvalidTextCoord;
201
202 // overlap between pages (when using PageUp/Dn) in lines
203 static const size_t PAGE_OVERLAP_IN_LINES = 1;
204
205 // ----------------------------------------------------------------------------
206 // private data of wxTextCtrl
207 // ----------------------------------------------------------------------------
208
209 // the data only used by single line text controls
210 struct WXDLLEXPORT wxTextSingleLineData
211 {
212 // the position of the first visible pixel and the first visible column
213 wxCoord m_ofsHorz;
214 wxTextCoord m_colStart;
215
216 // and the last ones (m_posLastVisible is the width but m_colLastVisible
217 // is an absolute value)
218 wxCoord m_posLastVisible;
219 wxTextCoord m_colLastVisible;
220
221 // def ctor
222 wxTextSingleLineData()
223 {
224 m_colStart = 0;
225 m_ofsHorz = 0;
226
227 m_colLastVisible = -1;
228 m_posLastVisible = -1;
229 }
230
231 };
232
233 // the data only used by multi line text controls
234 struct WXDLLEXPORT wxTextMultiLineData
235 {
236 // the lines of text
237 wxArrayString m_lines;
238
239 // the current ranges of the scrollbars
240 int m_scrollRangeX,
241 m_scrollRangeY;
242
243 // should we adjust the horz/vert scrollbar?
244 bool m_updateScrollbarX,
245 m_updateScrollbarY;
246
247 // the max line length in pixels
248 wxCoord m_widthMax;
249
250 // the index of the line which has the length of m_widthMax
251 wxTextCoord m_lineLongest;
252
253 // the rect in which text appears: it is even less than m_rectText because
254 // only the last _complete_ line is shown, hence there is an unoccupied
255 // horizontal band at the bottom of it
256 wxRect m_rectTextReal;
257
258 // the x-coordinate of the caret before we started moving it vertically:
259 // this is used to ensure that moving the caret up and then down will
260 // return it to the same position as if we always round it in one direction
261 // we would shift it in that direction
262 //
263 // when m_xCaret == -1, we don't have any remembered position
264 wxCoord m_xCaret;
265
266 // the def ctor
267 wxTextMultiLineData()
268 {
269 m_scrollRangeX =
270 m_scrollRangeY = 0;
271
272 m_updateScrollbarX =
273 m_updateScrollbarY = false;
274
275 m_widthMax = -1;
276 m_lineLongest = 0;
277
278 m_xCaret = -1;
279 }
280 };
281
282 // the data only used by multi line text controls in line wrap mode
283 class WXDLLEXPORT wxWrappedLineData
284 {
285 // these functions set all our values, so give them access to them
286 friend void wxTextCtrl::LayoutLine(wxTextCoord line,
287 wxWrappedLineData& lineData) const;
288 friend void wxTextCtrl::LayoutLines(wxTextCoord) const;
289
290 public:
291 // def ctor
292 wxWrappedLineData()
293 {
294 m_rowFirst = -1;
295 }
296
297 // get the start of any row (remember that accessing m_rowsStart doesn't work
298 // for the first one)
299 wxTextCoord GetRowStart(wxTextCoord row) const
300 {
301 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
302
303 return row ? m_rowsStart[row - 1] : 0;
304 }
305
306 // get the length of the row (using the total line length which we don't
307 // have here but need to calculate the length of the last row, so it must
308 // be given to us)
309 wxTextCoord GetRowLength(wxTextCoord row, wxTextCoord lenLine) const
310 {
311 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
312
313 // note that m_rowsStart[row] is the same as GetRowStart(row + 1) (but
314 // slightly more efficient) and lenLine is the same as the start of the
315 // first row of the next line
316 return ((size_t)row == m_rowsStart.GetCount() ? lenLine : m_rowsStart[row])
317 - GetRowStart(row);
318 }
319
320 // return the width of the row in pixels
321 wxCoord GetRowWidth(wxTextCoord row) const
322 {
323 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
324
325 return m_rowsWidth[row];
326 }
327
328 // return the number of rows
329 size_t GetRowCount() const
330 {
331 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
332
333 return m_rowsStart.GetCount() + 1;
334 }
335
336 // return the number of additional (i.e. after the first one) rows
337 size_t GetExtraRowCount() const
338 {
339 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
340
341 return m_rowsStart.GetCount();
342 }
343
344 // return the first row of this line
345 wxTextCoord GetFirstRow() const
346 {
347 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
348
349 return m_rowFirst;
350 }
351
352 // return the first row of the next line
353 wxTextCoord GetNextRow() const
354 {
355 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
356
357 return m_rowFirst + m_rowsStart.GetCount() + 1;
358 }
359
360 // this just provides direct access to m_rowsStart aerray for efficiency
361 wxTextCoord GetExtraRowStart(wxTextCoord row) const
362 {
363 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
364
365 return m_rowsStart[row];
366 }
367
368 // this code is unused any longer
369 #if 0
370 // return true if the column is in the start of the last row (hence the row
371 // it is in is not wrapped)
372 bool IsLastRow(wxTextCoord colRowStart) const
373 {
374 return colRowStart == GetRowStart(m_rowsStart.GetCount());
375 }
376
377 // return true if the column is the last column of the row starting in
378 // colRowStart
379 bool IsLastColInRow(wxTextCoord colRowStart,
380 wxTextCoord colRowEnd,
381 wxTextCoord lenLine) const
382 {
383 // find the row which starts with colRowStart
384 size_t nRows = GetRowCount();
385 for ( size_t n = 0; n < nRows; n++ )
386 {
387 if ( GetRowStart(n) == colRowStart )
388 {
389 wxTextCoord colNextRowStart = n == nRows - 1
390 ? lenLine
391 : GetRowStart(n + 1);
392
393 wxASSERT_MSG( colRowEnd < colNextRowStart,
394 _T("this column is not in this row at all!") );
395
396 return colRowEnd == colNextRowStart - 1;
397 }
398 }
399
400 // caller got it wrong
401 wxFAIL_MSG( _T("this column is not in the start of the row!") );
402
403 return false;
404 }
405 #endif // 0
406
407 // is this row the last one in its line?
408 bool IsLastRow(wxTextCoord row) const
409 {
410 return (size_t)row == GetExtraRowCount();
411 }
412
413 // the line is valid if it had been laid out correctly: note that just
414 // shiwting the line (because one of previous lines changed) doesn't make
415 // it invalid
416 bool IsValid() const { return !m_rowsWidth.IsEmpty(); }
417
418 // invalidating line will relayout it
419 void Invalidate() { m_rowsWidth.Empty(); }
420
421 private:
422 // for each line we remember the starting columns of all its rows after the
423 // first one (which always starts at 0), i.e. if a line is wrapped twice
424 // (== takes 3 rows) its m_rowsStart[0] may be 10 and m_rowsStart[1] == 15
425 wxArrayLong m_rowsStart;
426
427 // and the width of each row in pixels (this array starts from 0, as usual)
428 wxArrayInt m_rowsWidth;
429
430 // and also its starting row (0 for the first line, first lines'
431 // m_rowsStart.GetCount() + 1 for the second &c): it is set to -1 initially
432 // and this means that the struct hadn't yet been initialized
433 wxTextCoord m_rowFirst;
434
435 // the last modification "time"-stamp used by LayoutLines()
436 size_t m_timestamp;
437 };
438
439 WX_DECLARE_OBJARRAY(wxWrappedLineData, wxArrayWrappedLinesData);
440 #include "wx/arrimpl.cpp"
441 WX_DEFINE_OBJARRAY(wxArrayWrappedLinesData);
442
443 struct WXDLLEXPORT wxTextWrappedData : public wxTextMultiLineData
444 {
445 // the width of the column to the right of the text rect used for the
446 // indicator mark display for the wrapped lines
447 wxCoord m_widthMark;
448
449 // the data for each line
450 wxArrayWrappedLinesData m_linesData;
451
452 // flag telling us to recalculate all starting rows starting from this line
453 // (if it is -1, we don't have to recalculate anything) - it is set when
454 // the number of the rows in the middle of the control changes
455 wxTextCoord m_rowFirstInvalid;
456
457 // the current timestamp used by LayoutLines()
458 size_t m_timestamp;
459
460 // invalidate starting rows of all lines (NOT rows!) after this one
461 void InvalidateLinesBelow(wxTextCoord line)
462 {
463 if ( m_rowFirstInvalid == -1 || m_rowFirstInvalid > line )
464 {
465 m_rowFirstInvalid = line;
466 }
467 }
468
469 // check if this line is valid: i.e. before the first invalid one
470 bool IsValidLine(wxTextCoord line) const
471 {
472 return ((m_rowFirstInvalid == -1) || (line < m_rowFirstInvalid)) &&
473 m_linesData[line].IsValid();
474 }
475
476 // def ctor
477 wxTextWrappedData()
478 {
479 m_widthMark = 0;
480 m_rowFirstInvalid = -1;
481 m_timestamp = 0;
482 }
483 };
484
485 // ----------------------------------------------------------------------------
486 // private classes for undo/redo management
487 // ----------------------------------------------------------------------------
488
489 /*
490 We use custom versions of wxWidgets command processor to implement undo/redo
491 as we want to avoid storing the backpointer to wxTextCtrl in wxCommand
492 itself: this is a waste of memory as all commands in the given command
493 processor always have the same associated wxTextCtrl and so it makes sense
494 to store the backpointer there.
495
496 As for the rest of the implementation, it's fairly standard: we have 2
497 command classes corresponding to adding and removing text.
498 */
499
500 // a command corresponding to a wxTextCtrl action
501 class wxTextCtrlCommand : public wxCommand
502 {
503 public:
504 wxTextCtrlCommand(const wxString& name) : wxCommand(true, name) { }
505
506 // we don't use these methods as they don't make sense for us as we need a
507 // wxTextCtrl to be applied
508 virtual bool Do() { wxFAIL_MSG(_T("shouldn't be called")); return false; }
509 virtual bool Undo() { wxFAIL_MSG(_T("shouldn't be called")); return false; }
510
511 // instead, our command processor uses these methods
512 virtual bool Do(wxTextCtrl *text) = 0;
513 virtual bool Undo(wxTextCtrl *text) = 0;
514 };
515
516 // insert text command
517 class wxTextCtrlInsertCommand : public wxTextCtrlCommand
518 {
519 public:
520 wxTextCtrlInsertCommand(const wxString& textToInsert)
521 : wxTextCtrlCommand(wxTEXT_COMMAND_INSERT), m_text(textToInsert)
522 {
523 m_from = -1;
524 }
525
526 // combine the 2 commands together
527 void Append(wxTextCtrlInsertCommand *other);
528
529 virtual bool CanUndo() const;
530 virtual bool Do(wxTextCtrl *text);
531 virtual bool Do() { return wxTextCtrlCommand::Do(); }
532 virtual bool Undo() { return wxTextCtrlCommand::Undo(); }
533 virtual bool Undo(wxTextCtrl *text);
534
535 private:
536 // the text we insert
537 wxString m_text;
538
539 // the position where we inserted the text
540 wxTextPos m_from;
541 };
542
543 // remove text command
544 class wxTextCtrlRemoveCommand : public wxTextCtrlCommand
545 {
546 public:
547 wxTextCtrlRemoveCommand(wxTextPos from, wxTextPos to)
548 : wxTextCtrlCommand(wxTEXT_COMMAND_REMOVE)
549 {
550 m_from = from;
551 m_to = to;
552 }
553
554 virtual bool CanUndo() const;
555 virtual bool Do(wxTextCtrl *text);
556 virtual bool Do() { return wxTextCtrlCommand::Do(); }
557 virtual bool Undo() { return wxTextCtrlCommand::Undo(); }
558 virtual bool Undo(wxTextCtrl *text);
559
560 private:
561 // the range of text to delete
562 wxTextPos m_from,
563 m_to;
564
565 // the text which was deleted when this command was Do()ne
566 wxString m_textDeleted;
567 };
568
569 // a command processor for a wxTextCtrl
570 class wxTextCtrlCommandProcessor : public wxCommandProcessor
571 {
572 public:
573 wxTextCtrlCommandProcessor(wxTextCtrl *text)
574 {
575 m_compressInserts = false;
576
577 m_text = text;
578 }
579
580 // override Store() to compress multiple wxTextCtrlInsertCommand into one
581 virtual void Store(wxCommand *command);
582
583 // stop compressing insert commands when this is called
584 void StopCompressing() { m_compressInserts = false; }
585
586 // accessors
587 wxTextCtrl *GetTextCtrl() const { return m_text; }
588 bool IsCompressing() const { return m_compressInserts; }
589
590 protected:
591 virtual bool DoCommand(wxCommand& cmd)
592 { return ((wxTextCtrlCommand &)cmd).Do(m_text); }
593 virtual bool UndoCommand(wxCommand& cmd)
594 { return ((wxTextCtrlCommand &)cmd).Undo(m_text); }
595
596 // check if this command is a wxTextCtrlInsertCommand and return it casted
597 // to the right type if it is or NULL otherwise
598 wxTextCtrlInsertCommand *IsInsertCommand(wxCommand *cmd);
599
600 private:
601 // the control we're associated with
602 wxTextCtrl *m_text;
603
604 // if the flag is true we're compressing subsequent insert commands into
605 // one so that the entire typing could be undone in one call to Undo()
606 bool m_compressInserts;
607 };
608
609 // ============================================================================
610 // implementation
611 // ============================================================================
612
613 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
614 EVT_CHAR(wxTextCtrl::OnChar)
615
616 EVT_SIZE(wxTextCtrl::OnSize)
617 END_EVENT_TABLE()
618
619 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
620
621 // ----------------------------------------------------------------------------
622 // creation
623 // ----------------------------------------------------------------------------
624
625 void wxTextCtrl::Init()
626 {
627 m_selAnchor =
628 m_selStart =
629 m_selEnd = -1;
630
631 m_isModified = false;
632 m_isEditable = true;
633
634 m_posLast =
635 m_curPos =
636 m_curCol =
637 m_curRow = 0;
638
639 m_heightLine =
640 m_widthAvg = -1;
641
642 // init wxScrollHelper
643 SetWindow(this);
644
645 // init the undo manager
646 m_cmdProcessor = new wxTextCtrlCommandProcessor(this);
647
648 // no data yet
649 m_data.data = NULL;
650 }
651
652 bool wxTextCtrl::Create(wxWindow *parent,
653 wxWindowID id,
654 const wxString& value,
655 const wxPoint& pos,
656 const wxSize& size,
657 long style,
658 const wxValidator& validator,
659 const wxString &name)
660 {
661 if ( style & wxTE_MULTILINE )
662 {
663 // for compatibility with wxMSW we create the controls with vertical
664 // scrollbar always shown unless they have wxTE_RICH style (because
665 // Windows text controls always has vert scrollbar but richedit one
666 // doesn't)
667 if ( !(style & wxTE_RICH) )
668 {
669 style |= wxALWAYS_SHOW_SB;
670 }
671
672 // wrapping style: wxTE_DONTWRAP == wxHSCROLL so if it's _not_ given,
673 // we won't have horizontal scrollbar automatically, no need to do
674 // anything
675
676 // TODO: support wxTE_NO_VSCROLL (?)
677
678 // create data object for normal multiline or for controls with line
679 // wrap as needed
680 if ( style & wxHSCROLL )
681 m_data.mdata = new wxTextMultiLineData;
682 else
683 m_data.wdata = new wxTextWrappedData;
684 }
685 else
686 {
687 // this doesn't make sense for single line controls
688 style &= ~wxHSCROLL;
689
690 // create data object for single line controls
691 m_data.sdata = new wxTextSingleLineData;
692 }
693
694 #if wxUSE_TWO_WINDOWS
695 if ((style & wxBORDER_MASK) == 0)
696 style |= wxBORDER_SUNKEN;
697 #endif
698
699 if ( !wxControl::Create(parent, id, pos, size, style,
700 validator, name) )
701 {
702 return false;
703 }
704
705 SetCursor(wxCURSOR_IBEAM);
706
707 if ( style & wxTE_MULTILINE )
708 {
709 // we should always have at least one line in a multiline control
710 MData().m_lines.Add(wxEmptyString);
711
712 if ( !(style & wxHSCROLL) )
713 {
714 WData().m_linesData.Add(new wxWrappedLineData);
715 WData().InvalidateLinesBelow(0);
716 }
717
718 // we might support it but it's quite useless and other ports don't
719 // support it anyhow
720 wxASSERT_MSG( !(style & wxTE_PASSWORD),
721 _T("wxTE_PASSWORD can't be used with multiline ctrls") );
722 }
723
724 RecalcFontMetrics();
725 SetValue(value);
726 SetBestSize(size);
727
728 m_isEditable = !(style & wxTE_READONLY);
729
730 CreateCaret();
731 InitInsertionPoint();
732
733 // we can't show caret right now as we're not shown yet and so it would
734 // result in garbage on the screen - we'll do it after first OnPaint()
735 m_hasCaret = false;
736
737 CreateInputHandler(wxINP_HANDLER_TEXTCTRL);
738
739 wxSizeEvent sizeEvent(GetSize(), GetId());
740 GetEventHandler()->ProcessEvent(sizeEvent);
741
742 return true;
743 }
744
745 wxTextCtrl::~wxTextCtrl()
746 {
747 delete m_cmdProcessor;
748
749 if ( m_data.data )
750 {
751 if ( IsSingleLine() )
752 delete m_data.sdata;
753 else if ( WrapLines() )
754 delete m_data.wdata;
755 else
756 delete m_data.mdata;
757 }
758 }
759
760 // ----------------------------------------------------------------------------
761 // set/get the value
762 // ----------------------------------------------------------------------------
763
764 void wxTextCtrl::SetValue(const wxString& value)
765 {
766 if ( IsSingleLine() && (value == GetValue()) )
767 {
768 // nothing changed
769 return;
770 }
771
772 Replace(0, GetLastPosition(), value);
773
774 if ( IsSingleLine() )
775 {
776 SetInsertionPoint(0);
777 }
778
779 // TODO: should we generate the event or not, finally?
780 }
781
782 const wxArrayString& wxTextCtrl::GetLines() const
783 {
784 return MData().m_lines;
785 }
786
787 size_t wxTextCtrl::GetLineCount() const
788 {
789 return MData().m_lines.GetCount();
790 }
791
792 wxString wxTextCtrl::GetValue() const
793 {
794 // for multiline controls we don't always store the total value but only
795 // recompute it when asked - and to invalidate it we just empty it in
796 // Replace()
797 if ( !IsSingleLine() && m_value.empty() )
798 {
799 // recalculate: note that we always do it for empty multilien control,
800 // but then it's so quick that it's not important
801
802 // the first line is special as there is no \n before it, so it's
803 // outside the loop
804 const wxArrayString& lines = GetLines();
805 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
806 self->m_value << lines[0u];
807 size_t count = lines.GetCount();
808 for ( size_t n = 1; n < count; n++ )
809 {
810 self->m_value << _T('\n') << lines[n];
811 }
812 }
813
814 return m_value;
815 }
816
817 void wxTextCtrl::Clear()
818 {
819 SetValue(wxEmptyString);
820 }
821
822 bool wxTextCtrl::ReplaceLine(wxTextCoord line,
823 const wxString& text)
824 {
825 if ( WrapLines() )
826 {
827 // first, we have to relayout the line entirely
828 //
829 // OPT: we might try not to recalc the unchanged part of line
830
831 wxWrappedLineData& lineData = WData().m_linesData[line];
832
833 // if we had some number of rows before, use this number, otherwise
834 // just make sure that the test below (rowsNew != rowsOld) will be true
835 int rowsOld;
836 if ( lineData.IsValid() )
837 {
838 rowsOld = lineData.GetExtraRowCount();
839 }
840 else // line wasn't laid out yet
841 {
842 // assume it changed entirely as we can't do anything better
843 rowsOld = -1;
844 }
845
846 // now change the line
847 MData().m_lines[line] = text;
848
849 // OPT: we choose to lay it our immediately instead of delaying it
850 // until it is needed because it allows us to avoid invalidating
851 // lines further down if the number of rows didn't chnage, but
852 // maybe we can imporve this even further?
853 LayoutLine(line, lineData);
854
855 int rowsNew = lineData.GetExtraRowCount();
856
857 if ( rowsNew != rowsOld )
858 {
859 // we have to update the line wrap marks as this is normally done
860 // by LayoutLines() which we bypassed by calling LayoutLine()
861 // directly
862 wxTextCoord rowFirst = lineData.GetFirstRow(),
863 rowCount = wxMax(rowsOld, rowsNew);
864 RefreshLineWrapMarks(rowFirst, rowFirst + rowCount);
865
866 // next, if this is not the last line, as the number of rows in it
867 // changed, we need to shift all the lines below it
868 if ( (size_t)line < WData().m_linesData.GetCount() )
869 {
870 // number of rows changed shifting all lines below
871 WData().InvalidateLinesBelow(line + 1);
872 }
873
874 // the number of rows changed
875 return true;
876 }
877 }
878 else // no line wrap
879 {
880 MData().m_lines[line] = text;
881 }
882
883 // the number of rows didn't change
884 return false;
885 }
886
887 void wxTextCtrl::RemoveLine(wxTextCoord line)
888 {
889 MData().m_lines.RemoveAt(line);
890 if ( WrapLines() )
891 {
892 // we need to recalculate all the starting rows from this line, but we
893 // can avoid doing it if this line was never calculated: this means
894 // that we will recalculate all lines below it anyhow later if needed
895 if ( WData().IsValidLine(line) )
896 {
897 WData().InvalidateLinesBelow(line);
898 }
899
900 WData().m_linesData.RemoveAt(line);
901 }
902 }
903
904 void wxTextCtrl::InsertLine(wxTextCoord line, const wxString& text)
905 {
906 MData().m_lines.Insert(text, line);
907 if ( WrapLines() )
908 {
909 WData().m_linesData.Insert(new wxWrappedLineData, line);
910
911 // invalidate everything below it
912 WData().InvalidateLinesBelow(line);
913 }
914 }
915
916 void wxTextCtrl::Replace(wxTextPos from, wxTextPos to, const wxString& text)
917 {
918 wxTextCoord colStart, colEnd,
919 lineStart, lineEnd;
920
921 if ( (from > to) ||
922 !PositionToXY(from, &colStart, &lineStart) ||
923 !PositionToXY(to, &colEnd, &lineEnd) )
924 {
925 wxFAIL_MSG(_T("invalid range in wxTextCtrl::Replace"));
926
927 return;
928 }
929
930 #ifdef WXDEBUG_TEXT_REPLACE
931 // a straighforward (but very inefficient) way of calculating what the new
932 // value should be
933 wxString textTotal = GetValue();
934 wxString textTotalNew(textTotal, (size_t)from);
935 textTotalNew += text;
936 if ( (size_t)to < textTotal.length() )
937 textTotalNew += textTotal.c_str() + (size_t)to;
938 #endif // WXDEBUG_TEXT_REPLACE
939
940 // remember the old selection and reset it immediately: we must do it
941 // before calling Refresh(anything) as, at least under GTK, this leads to
942 // an _immediate_ repaint (under MSW it is delayed) and hence parts of
943 // text would be redrawn as selected if we didn't reset the selection
944 int selStartOld = m_selStart,
945 selEndOld = m_selEnd;
946
947 m_selStart =
948 m_selEnd = -1;
949
950 if ( IsSingleLine() )
951 {
952 // replace the part of the text with the new value
953 wxString valueNew(m_value, (size_t)from);
954
955 // remember it for later use
956 wxCoord startNewText = GetTextWidth(valueNew);
957
958 valueNew += text;
959 if ( (size_t)to < m_value.length() )
960 {
961 valueNew += m_value.c_str() + (size_t)to;
962 }
963
964 // we usually refresh till the end of line except of the most common case
965 // when some text is appended to the end of the string in which case we
966 // refresh just it
967 wxCoord widthNewText;
968
969 if ( (size_t)from < m_value.length() )
970 {
971 // refresh till the end of line
972 widthNewText = 0;
973 }
974 else // text appended, not replaced
975 {
976 // refresh only the new text
977 widthNewText = GetTextWidth(text);
978 }
979
980 m_value = valueNew;
981
982 // force SData().m_colLastVisible update
983 SData().m_colLastVisible = -1;
984
985 // repaint
986 RefreshPixelRange(0, startNewText, widthNewText);
987 }
988 else // multiline
989 {
990 //OPT: special case for replacements inside single line?
991
992 /*
993 Join all the lines in the replacement range into one string, then
994 replace a part of it with the new text and break it into lines again.
995 */
996
997 // (0) we want to know if this replacement changes the number of rows
998 // as if it does we need to refresh everything below the changed
999 // text (it will be shifted...) and we can avoid it if there is no
1000 // row relayout
1001 bool rowsNumberChanged = false;
1002
1003 // (1) join lines
1004 const wxArrayString& linesOld = GetLines();
1005 wxString textOrig;
1006 wxTextCoord line;
1007 for ( line = lineStart; line <= lineEnd; line++ )
1008 {
1009 if ( line > lineStart )
1010 {
1011 // from the previous line
1012 textOrig += _T('\n');
1013 }
1014
1015 textOrig += linesOld[line];
1016 }
1017
1018 // we need to append the '\n' for the last line unless there is no
1019 // following line
1020 size_t countOld = linesOld.GetCount();
1021
1022 // (2) replace text in the combined string
1023
1024 // (2a) leave the part before replaced area unchanged
1025 wxString textNew(textOrig, colStart);
1026
1027 // these values will be used to refresh the changed area below
1028 wxCoord widthNewText,
1029 startNewText = GetTextWidth(textNew);
1030 if ( (size_t)colStart == linesOld[lineStart].length() )
1031 {
1032 // text appended, refresh just enough to show the new text
1033 widthNewText = GetTextWidth(text.BeforeFirst(_T('\n')));
1034 }
1035 else // text inserted, refresh till the end of line
1036 {
1037 widthNewText = 0;
1038 }
1039
1040 // (2b) insert new text
1041 textNew += text;
1042
1043 // (2c) and append the end of the old text
1044
1045 // adjust for index shift: to is relative to colStart, not 0
1046 size_t toRel = (size_t)((to - from) + colStart);
1047 if ( toRel < textOrig.length() )
1048 {
1049 textNew += textOrig.c_str() + toRel;
1050 }
1051
1052 // (3) break it into lines
1053
1054 wxArrayString lines;
1055 const wxChar *curLineStart = textNew.c_str();
1056 for ( const wxChar *p = textNew.c_str(); ; p++ )
1057 {
1058 // end of line/text?
1059 if ( !*p || *p == _T('\n') )
1060 {
1061 lines.Add(wxString(curLineStart, p));
1062 if ( !*p )
1063 break;
1064
1065 curLineStart = p + 1;
1066 }
1067 }
1068
1069 #ifdef WXDEBUG_TEXT_REPLACE
1070 // (3a) all empty tokens should be counted as replacing with "foo" and
1071 // with "foo\n" should have different effects
1072 wxArrayString lines2 = wxStringTokenize(textNew, _T("\n"),
1073 wxTOKEN_RET_EMPTY_ALL);
1074
1075 if ( lines2.IsEmpty() )
1076 {
1077 lines2.Add(wxEmptyString);
1078 }
1079
1080 wxASSERT_MSG( lines.GetCount() == lines2.GetCount(),
1081 _T("Replace() broken") );
1082 for ( size_t n = 0; n < lines.GetCount(); n++ )
1083 {
1084 wxASSERT_MSG( lines[n] == lines2[n], _T("Replace() broken") );
1085 }
1086 #endif // WXDEBUG_TEXT_REPLACE
1087
1088 // (3b) special case: if we replace everything till the end we need to
1089 // keep an empty line or the lines would disappear completely
1090 // (this also takes care of never leaving m_lines empty)
1091 if ( ((size_t)lineEnd == countOld - 1) && lines.IsEmpty() )
1092 {
1093 lines.Add(wxEmptyString);
1094 }
1095
1096 size_t nReplaceCount = lines.GetCount(),
1097 nReplaceLine = 0;
1098
1099 // (4) merge into the array
1100
1101 // (4a) replace
1102 for ( line = lineStart; line <= lineEnd; line++, nReplaceLine++ )
1103 {
1104 if ( nReplaceLine < nReplaceCount )
1105 {
1106 // we have the replacement line for this one
1107 if ( ReplaceLine(line, lines[nReplaceLine]) )
1108 {
1109 rowsNumberChanged = true;
1110 }
1111
1112 UpdateMaxWidth(line);
1113 }
1114 else // no more replacement lines
1115 {
1116 // (4b) delete all extra lines (note that we need to delete
1117 // them backwards because indices shift while we do it)
1118 bool deletedLongestLine = false;
1119 for ( wxTextCoord lineDel = lineEnd; lineDel >= line; lineDel-- )
1120 {
1121 if ( lineDel == MData().m_lineLongest )
1122 {
1123 // we will need to recalc the max line width
1124 deletedLongestLine = true;
1125 }
1126
1127 RemoveLine(lineDel);
1128 }
1129
1130 if ( deletedLongestLine )
1131 {
1132 RecalcMaxWidth();
1133 }
1134
1135 // even the line number changed
1136 rowsNumberChanged = true;
1137
1138 // update line to exit the loop
1139 line = lineEnd + 1;
1140 }
1141 }
1142
1143 // (4c) insert the new lines
1144 if ( nReplaceLine < nReplaceCount )
1145 {
1146 // even the line number changed
1147 rowsNumberChanged = true;
1148
1149 do
1150 {
1151 InsertLine(++lineEnd, lines[nReplaceLine++]);
1152
1153 UpdateMaxWidth(lineEnd);
1154 }
1155 while ( nReplaceLine < nReplaceCount );
1156 }
1157
1158 // (5) now refresh the changed area
1159
1160 // update the (cached) last position first as refresh functions use it
1161 m_posLast += text.length() - to + from;
1162
1163 // we may optimize refresh if the number of rows didn't change - but if
1164 // it did we have to refresh everything below the part we chanegd as
1165 // well as it might have moved
1166 if ( !rowsNumberChanged )
1167 {
1168 // refresh the line we changed
1169 if ( !WrapLines() )
1170 {
1171 RefreshPixelRange(lineStart++, startNewText, widthNewText);
1172 }
1173 else
1174 {
1175 //OPT: we shouldn't refresh the unchanged part of the line in
1176 // this case, but instead just refresh the tail of it - the
1177 // trouble is that we don't know here where does this tail
1178 // start
1179 }
1180
1181 // number of rows didn't change, refresh the updated rows and the
1182 // last one
1183 if ( lineStart <= lineEnd )
1184 RefreshLineRange(lineStart, lineEnd);
1185 }
1186 else // rows number did change
1187 {
1188 if ( !WrapLines() )
1189 {
1190 // refresh only part of the first line
1191 RefreshPixelRange(lineStart++, startNewText, widthNewText);
1192 }
1193 //else: we have to refresh everything as some part of the text
1194 // could be in the previous row before but moved to the next
1195 // one now (due to word wrap)
1196
1197 wxTextCoord lineEnd = GetLines().GetCount() - 1;
1198 if ( lineStart <= lineEnd )
1199 RefreshLineRange(lineStart, lineEnd);
1200
1201 // refresh text rect left below
1202 RefreshLineRange(lineEnd + 1, 0);
1203
1204 // the vert scrollbar might [dis]appear
1205 MData().m_updateScrollbarY = true;
1206 }
1207
1208 // must recalculate it - will do later
1209 m_value.clear();
1210 }
1211
1212 #ifdef WXDEBUG_TEXT_REPLACE
1213 // optimized code above should give the same result as straightforward
1214 // computation in the beginning
1215 wxASSERT_MSG( GetValue() == textTotalNew, _T("error in Replace()") );
1216 #endif // WXDEBUG_TEXT_REPLACE
1217
1218 // update the current position: note that we always put the cursor at the
1219 // end of the replacement text
1220 DoSetInsertionPoint(from + text.length());
1221
1222 // and the selection: this is complicated by the fact that selection coords
1223 // must be first updated to reflect change in text coords, i.e. if we had
1224 // selection from 17 to 19 and we just removed this range, we don't have to
1225 // refresh anything, so we can't just use ClearSelection() here
1226 if ( selStartOld != -1 )
1227 {
1228 // refresh the parst of the selection outside the changed text (which
1229 // we already refreshed)
1230 if ( selStartOld < from )
1231 RefreshTextRange(selStartOld, from);
1232 if ( to < selEndOld )
1233 RefreshTextRange(to, selEndOld);
1234
1235 }
1236
1237 // now call it to do the rest (not related to refreshing)
1238 ClearSelection();
1239 }
1240
1241 void wxTextCtrl::Remove(wxTextPos from, wxTextPos to)
1242 {
1243 // Replace() only works with correctly ordered arguments, so exchange them
1244 // if necessary
1245 OrderPositions(from, to);
1246
1247 Replace(from, to, wxEmptyString);
1248 }
1249
1250 void wxTextCtrl::WriteText(const wxString& text)
1251 {
1252 // replace the selection with the new text
1253 RemoveSelection();
1254
1255 Replace(m_curPos, m_curPos, text);
1256 }
1257
1258 void wxTextCtrl::AppendText(const wxString& text)
1259 {
1260 SetInsertionPointEnd();
1261 WriteText(text);
1262 }
1263
1264 // ----------------------------------------------------------------------------
1265 // current position
1266 // ----------------------------------------------------------------------------
1267
1268 void wxTextCtrl::SetInsertionPoint(wxTextPos pos)
1269 {
1270 wxCHECK_RET( pos >= 0 && pos <= GetLastPosition(),
1271 _T("insertion point position out of range") );
1272
1273 // don't do anything if it didn't change
1274 if ( pos != m_curPos )
1275 {
1276 DoSetInsertionPoint(pos);
1277 }
1278
1279 if ( !IsSingleLine() )
1280 {
1281 // moving cursor should reset the stored abscissa (even if the cursor
1282 // position didn't actually change!)
1283 MData().m_xCaret = -1;
1284 }
1285
1286 ClearSelection();
1287 }
1288
1289 void wxTextCtrl::InitInsertionPoint()
1290 {
1291 // so far always put it in the beginning
1292 DoSetInsertionPoint(0);
1293
1294 // this will also set the selection anchor correctly
1295 ClearSelection();
1296 }
1297
1298 void wxTextCtrl::MoveInsertionPoint(wxTextPos pos)
1299 {
1300 wxASSERT_MSG( pos >= 0 && pos <= GetLastPosition(),
1301 _T("DoSetInsertionPoint() can only be called with valid pos") );
1302
1303 m_curPos = pos;
1304 PositionToXY(m_curPos, &m_curCol, &m_curRow);
1305 }
1306
1307 void wxTextCtrl::DoSetInsertionPoint(wxTextPos pos)
1308 {
1309 MoveInsertionPoint(pos);
1310
1311 ShowPosition(pos);
1312 }
1313
1314 void wxTextCtrl::SetInsertionPointEnd()
1315 {
1316 SetInsertionPoint(GetLastPosition());
1317 }
1318
1319 wxTextPos wxTextCtrl::GetInsertionPoint() const
1320 {
1321 return m_curPos;
1322 }
1323
1324 wxTextPos wxTextCtrl::GetLastPosition() const
1325 {
1326 wxTextPos pos;
1327 if ( IsSingleLine() )
1328 {
1329 pos = m_value.length();
1330 }
1331 else // multiline
1332 {
1333 #ifdef WXDEBUG_TEXT
1334 pos = 0;
1335 size_t nLineCount = GetLineCount();
1336 for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
1337 {
1338 // +1 is because the positions at the end of this line and of the
1339 // start of the next one are different
1340 pos += GetLines()[nLine].length() + 1;
1341 }
1342
1343 if ( pos > 0 )
1344 {
1345 // the last position is at the end of the last line, not in the
1346 // beginning of the next line after it
1347 pos--;
1348 }
1349
1350 // more probable reason of this would be to forget to update m_posLast
1351 wxASSERT_MSG( pos == m_posLast, _T("bug in GetLastPosition()") );
1352 #endif // WXDEBUG_TEXT
1353
1354 pos = m_posLast;
1355 }
1356
1357 return pos;
1358 }
1359
1360 // ----------------------------------------------------------------------------
1361 // selection
1362 // ----------------------------------------------------------------------------
1363
1364 void wxTextCtrl::GetSelection(wxTextPos* from, wxTextPos* to) const
1365 {
1366 if ( from )
1367 *from = m_selStart;
1368 if ( to )
1369 *to = m_selEnd;
1370 }
1371
1372 wxString wxTextCtrl::GetSelectionText() const
1373 {
1374 wxString sel;
1375
1376 if ( HasSelection() )
1377 {
1378 if ( IsSingleLine() )
1379 {
1380 sel = m_value.Mid(m_selStart, m_selEnd - m_selStart);
1381 }
1382 else // multiline
1383 {
1384 wxTextCoord colStart, lineStart,
1385 colEnd, lineEnd;
1386 PositionToXY(m_selStart, &colStart, &lineStart);
1387 PositionToXY(m_selEnd, &colEnd, &lineEnd);
1388
1389 // as always, we need to check for the special case when the start
1390 // and end line are the same
1391 if ( lineEnd == lineStart )
1392 {
1393 sel = GetLines()[lineStart].Mid(colStart, colEnd - colStart);
1394 }
1395 else // sel on multiple lines
1396 {
1397 // take the end of the first line
1398 sel = GetLines()[lineStart].c_str() + colStart;
1399 sel += _T('\n');
1400
1401 // all intermediate ones
1402 for ( wxTextCoord line = lineStart + 1; line < lineEnd; line++ )
1403 {
1404 sel << GetLines()[line] << _T('\n');
1405 }
1406
1407 // and the start of the last one
1408 sel += GetLines()[lineEnd].Left(colEnd);
1409 }
1410 }
1411 }
1412
1413 return sel;
1414 }
1415
1416 void wxTextCtrl::SetSelection(wxTextPos from, wxTextPos to)
1417 {
1418 // selecting till -1 is the same as selecting to the end
1419 if ( to == -1 && from != -1 )
1420 {
1421 to = GetLastPosition();
1422 }
1423
1424 if ( from == -1 || to == from )
1425 {
1426 ClearSelection();
1427 }
1428 else // valid sel range
1429 {
1430 // remember the 'to' position as the current position, used to move the
1431 // caret there later
1432 wxTextPos toOrig = to;
1433
1434 OrderPositions(from, to);
1435
1436 wxCHECK_RET( to <= GetLastPosition(),
1437 _T("invalid range in wxTextCtrl::SetSelection") );
1438
1439 if ( from != m_selStart || to != m_selEnd )
1440 {
1441 // we need to use temp vars as RefreshTextRange() may call DoDraw()
1442 // directly and so m_selStart/End must be reset by then
1443 wxTextPos selStartOld = m_selStart,
1444 selEndOld = m_selEnd;
1445
1446 m_selStart = from;
1447 m_selEnd = to;
1448
1449 wxLogTrace(_T("text"), _T("Selection range is %ld-%ld"),
1450 m_selStart, m_selEnd);
1451
1452 // refresh only the part of text which became (un)selected if
1453 // possible
1454 if ( selStartOld == m_selStart )
1455 {
1456 RefreshTextRange(selEndOld, m_selEnd);
1457 }
1458 else if ( selEndOld == m_selEnd )
1459 {
1460 RefreshTextRange(m_selStart, selStartOld);
1461 }
1462 else
1463 {
1464 // OPT: could check for other cases too but it is probably not
1465 // worth it as the two above are the most common ones
1466 if ( selStartOld != -1 )
1467 RefreshTextRange(selStartOld, selEndOld);
1468 if ( m_selStart != -1 )
1469 RefreshTextRange(m_selStart, m_selEnd);
1470 }
1471
1472 // we need to fully repaint the invalidated areas of the window
1473 // before scrolling it (from DoSetInsertionPoint which is typically
1474 // called after SetSelection()), otherwise they may stay unpainted
1475 m_targetWindow->Update();
1476 }
1477 //else: nothing to do
1478
1479 // the insertion point is put at the location where the caret was moved
1480 DoSetInsertionPoint(toOrig);
1481 }
1482 }
1483
1484 void wxTextCtrl::ClearSelection()
1485 {
1486 if ( HasSelection() )
1487 {
1488 // we need to use temp vars as RefreshTextRange() may call DoDraw()
1489 // directly (see above as well)
1490 wxTextPos selStart = m_selStart,
1491 selEnd = m_selEnd;
1492
1493 // no selection any more
1494 m_selStart =
1495 m_selEnd = -1;
1496
1497 // refresh the old selection
1498 RefreshTextRange(selStart, selEnd);
1499 }
1500
1501 // the anchor should be moved even if there was no selection previously
1502 m_selAnchor = m_curPos;
1503 }
1504
1505 void wxTextCtrl::RemoveSelection()
1506 {
1507 if ( !HasSelection() )
1508 return;
1509
1510 Remove(m_selStart, m_selEnd);
1511 }
1512
1513 bool wxTextCtrl::GetSelectedPartOfLine(wxTextCoord line,
1514 wxTextPos *start, wxTextPos *end) const
1515 {
1516 if ( start )
1517 *start = -1;
1518 if ( end )
1519 *end = -1;
1520
1521 if ( !HasSelection() )
1522 {
1523 // no selection at all, hence no selection in this line
1524 return false;
1525 }
1526
1527 wxTextCoord lineStart, colStart;
1528 PositionToXY(m_selStart, &colStart, &lineStart);
1529 if ( lineStart > line )
1530 {
1531 // this line is entirely above the selection
1532 return false;
1533 }
1534
1535 wxTextCoord lineEnd, colEnd;
1536 PositionToXY(m_selEnd, &colEnd, &lineEnd);
1537 if ( lineEnd < line )
1538 {
1539 // this line is entirely below the selection
1540 return false;
1541 }
1542
1543 if ( line == lineStart )
1544 {
1545 if ( start )
1546 *start = colStart;
1547 if ( end )
1548 *end = lineEnd == lineStart ? colEnd : GetLineLength(line);
1549 }
1550 else if ( line == lineEnd )
1551 {
1552 if ( start )
1553 *start = lineEnd == lineStart ? colStart : 0;
1554 if ( end )
1555 *end = colEnd;
1556 }
1557 else // the line is entirely inside the selection
1558 {
1559 if ( start )
1560 *start = 0;
1561 if ( end )
1562 *end = GetLineLength(line);
1563 }
1564
1565 return true;
1566 }
1567
1568 // ----------------------------------------------------------------------------
1569 // flags
1570 // ----------------------------------------------------------------------------
1571
1572 bool wxTextCtrl::IsModified() const
1573 {
1574 return m_isModified;
1575 }
1576
1577 bool wxTextCtrl::IsEditable() const
1578 {
1579 // disabled control can never be edited
1580 return m_isEditable && IsEnabled();
1581 }
1582
1583 void wxTextCtrl::MarkDirty()
1584 {
1585 m_isModified = true;
1586 }
1587
1588 void wxTextCtrl::DiscardEdits()
1589 {
1590 m_isModified = false;
1591 }
1592
1593 void wxTextCtrl::SetEditable(bool editable)
1594 {
1595 if ( editable != m_isEditable )
1596 {
1597 m_isEditable = editable;
1598
1599 // the caret (dis)appears
1600 CreateCaret();
1601
1602 // the appearance of the control might have changed
1603 Refresh();
1604 }
1605 }
1606
1607 // ----------------------------------------------------------------------------
1608 // col/lines <-> position correspondence
1609 // ----------------------------------------------------------------------------
1610
1611 /*
1612 A few remarks about this stuff:
1613
1614 o The numbering of the text control columns/rows starts from 0.
1615 o Start of first line is position 0, its last position is line.length()
1616 o Start of the next line is the last position of the previous line + 1
1617 */
1618
1619 int wxTextCtrl::GetLineLength(wxTextCoord line) const
1620 {
1621 if ( IsSingleLine() )
1622 {
1623 wxASSERT_MSG( line == 0, _T("invalid GetLineLength() parameter") );
1624
1625 return m_value.length();
1626 }
1627 else // multiline
1628 {
1629 wxCHECK_MSG( (size_t)line < GetLineCount(), -1,
1630 _T("line index out of range") );
1631
1632 return GetLines()[line].length();
1633 }
1634 }
1635
1636 wxString wxTextCtrl::GetLineText(wxTextCoord line) const
1637 {
1638 if ( IsSingleLine() )
1639 {
1640 wxASSERT_MSG( line == 0, _T("invalid GetLineLength() parameter") );
1641
1642 return m_value;
1643 }
1644 else // multiline
1645 {
1646 //this is called during DoGetBestSize
1647 if (line == 0 && GetLineCount() == 0) return wxEmptyString ;
1648
1649 wxCHECK_MSG( (size_t)line < GetLineCount(), wxEmptyString,
1650 _T("line index out of range") );
1651
1652 return GetLines()[line];
1653 }
1654 }
1655
1656 int wxTextCtrl::GetNumberOfLines() const
1657 {
1658 // there is always 1 line, even if the text is empty
1659 return IsSingleLine() ? 1 : GetLineCount();
1660 }
1661
1662 wxTextPos wxTextCtrl::XYToPosition(wxTextCoord x, wxTextCoord y) const
1663 {
1664 // note that this method should accept any values of x and y and return -1
1665 // if they are out of range
1666 if ( IsSingleLine() )
1667 {
1668 return ( x > GetLastPosition() || y > 0 ) ? wxOutOfRangeTextCoord : x;
1669 }
1670 else // multiline
1671 {
1672 if ( (size_t)y >= GetLineCount() )
1673 {
1674 // this position is below the text
1675 return GetLastPosition();
1676 }
1677
1678 wxTextPos pos = 0;
1679 for ( size_t nLine = 0; nLine < (size_t)y; nLine++ )
1680 {
1681 // +1 is because the positions at the end of this line and of the
1682 // start of the next one are different
1683 pos += GetLines()[nLine].length() + 1;
1684 }
1685
1686 // take into account also the position in line
1687 if ( (size_t)x > GetLines()[y].length() )
1688 {
1689 // don't return position in the next line
1690 x = GetLines()[y].length();
1691 }
1692
1693 return pos + x;
1694 }
1695 }
1696
1697 bool wxTextCtrl::PositionToXY(wxTextPos pos,
1698 wxTextCoord *x, wxTextCoord *y) const
1699 {
1700 if ( IsSingleLine() )
1701 {
1702 if ( (size_t)pos > m_value.length() )
1703 return false;
1704
1705 if ( x )
1706 *x = pos;
1707 if ( y )
1708 *y = 0;
1709
1710 return true;
1711 }
1712 else // multiline
1713 {
1714 wxTextPos posCur = 0;
1715 size_t nLineCount = GetLineCount();
1716 for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
1717 {
1718 // +1 is because the start the start of the next line is one
1719 // position after the end of this one
1720 wxTextPos posNew = posCur + GetLines()[nLine].length() + 1;
1721 if ( posNew > pos )
1722 {
1723 // we've found the line, now just calc the column
1724 if ( x )
1725 *x = pos - posCur;
1726
1727 if ( y )
1728 *y = nLine;
1729
1730 #ifdef WXDEBUG_TEXT
1731 wxASSERT_MSG( XYToPosition(pos - posCur, nLine) == pos,
1732 _T("XYToPosition() or PositionToXY() broken") );
1733 #endif // WXDEBUG_TEXT
1734
1735 return true;
1736 }
1737 else // go further down
1738 {
1739 posCur = posNew;
1740 }
1741 }
1742
1743 // beyond the last line
1744 return false;
1745 }
1746 }
1747
1748 wxTextCoord wxTextCtrl::GetRowsPerLine(wxTextCoord line) const
1749 {
1750 // a normal line has one row
1751 wxTextCoord numRows = 1;
1752
1753 if ( WrapLines() )
1754 {
1755 // add the number of additional rows
1756 numRows += WData().m_linesData[line].GetExtraRowCount();
1757 }
1758
1759 return numRows;
1760 }
1761
1762 wxTextCoord wxTextCtrl::GetRowCount() const
1763 {
1764 wxTextCoord count = GetLineCount();
1765 if (count == 0)
1766 return 0;
1767 if ( WrapLines() )
1768 {
1769 count = GetFirstRowOfLine(count - 1) +
1770 WData().m_linesData[count - 1].GetRowCount();
1771 }
1772
1773 return count;
1774 }
1775
1776 wxTextCoord wxTextCtrl::GetRowAfterLine(wxTextCoord line) const
1777 {
1778 if ( !WrapLines() )
1779 return line + 1;
1780
1781 if ( !WData().IsValidLine(line) )
1782 {
1783 LayoutLines(line);
1784 }
1785
1786 return WData().m_linesData[line].GetNextRow();
1787 }
1788
1789 wxTextCoord wxTextCtrl::GetFirstRowOfLine(wxTextCoord line) const
1790 {
1791 if ( !WrapLines() )
1792 return line;
1793
1794 if ( !WData().IsValidLine(line) )
1795 {
1796 LayoutLines(line);
1797 }
1798
1799 return WData().m_linesData[line].GetFirstRow();
1800 }
1801
1802 bool wxTextCtrl::PositionToLogicalXY(wxTextPos pos,
1803 wxCoord *xOut,
1804 wxCoord *yOut) const
1805 {
1806 wxTextCoord col, line;
1807
1808 // optimization for special (but common) case when we already have the col
1809 // and line
1810 if ( pos == m_curPos )
1811 {
1812 col = m_curCol;
1813 line = m_curRow;
1814 }
1815 else // must really calculate col/line from pos
1816 {
1817 if ( !PositionToXY(pos, &col, &line) )
1818 return false;
1819 }
1820
1821 int hLine = GetLineHeight();
1822 wxCoord x, y;
1823 wxString textLine = GetLineText(line);
1824 if ( IsSingleLine() || !WrapLines() )
1825 {
1826 x = GetTextWidth(textLine.Left(col));
1827 y = line*hLine;
1828 }
1829 else // difficult case: multline control with line wrap
1830 {
1831 y = GetFirstRowOfLine(line);
1832
1833 wxTextCoord colRowStart;
1834 y += GetRowInLine(line, col, &colRowStart);
1835
1836 y *= hLine;
1837
1838 // x is the width of the text before this position in this row
1839 x = GetTextWidth(textLine.Mid(colRowStart, col - colRowStart));
1840 }
1841
1842 if ( xOut )
1843 *xOut = x;
1844 if ( yOut )
1845 *yOut = y;
1846
1847 return true;
1848 }
1849
1850 bool wxTextCtrl::PositionToDeviceXY(wxTextPos pos,
1851 wxCoord *xOut,
1852 wxCoord *yOut) const
1853 {
1854 wxCoord x, y;
1855 if ( !PositionToLogicalXY(pos, &x, &y) )
1856 return false;
1857
1858 // finally translate the logical text rect coords into physical client
1859 // coords
1860 CalcScrolledPosition(m_rectText.x + x, m_rectText.y + y, xOut, yOut);
1861
1862 return true;
1863 }
1864
1865 wxPoint wxTextCtrl::GetCaretPosition() const
1866 {
1867 wxCoord xCaret, yCaret;
1868 if ( !PositionToDeviceXY(m_curPos, &xCaret, &yCaret) )
1869 {
1870 wxFAIL_MSG( _T("Caret can't be beyond the text!") );
1871 }
1872
1873 return wxPoint(xCaret, yCaret);
1874 }
1875
1876 // pos may be -1 to show the current position
1877 void wxTextCtrl::ShowPosition(wxTextPos pos)
1878 {
1879 bool showCaret = GetCaret() && GetCaret()->IsVisible();
1880 if (showCaret)
1881 HideCaret();
1882
1883 if ( IsSingleLine() )
1884 {
1885 ShowHorzPosition(GetTextWidth(m_value.Left(pos)));
1886 }
1887 else if ( MData().m_scrollRangeX || MData().m_scrollRangeY ) // multiline with scrollbars
1888 {
1889 int xStart, yStart;
1890 GetViewStart(&xStart, &yStart);
1891
1892 if ( pos == -1 )
1893 pos = m_curPos;
1894
1895 wxCoord x, y;
1896 PositionToLogicalXY(pos, &x, &y);
1897
1898 wxRect rectText = GetRealTextArea();
1899
1900 // scroll the position vertically into view: if it is currently above
1901 // it, make it the first one, otherwise the last one
1902 if ( MData().m_scrollRangeY )
1903 {
1904 y /= GetLineHeight();
1905
1906 if ( y < yStart )
1907 {
1908 Scroll(0, y);
1909 }
1910 else // we are currently in or below the view area
1911 {
1912 // find the last row currently shown
1913 wxTextCoord yEnd;
1914
1915 if ( WrapLines() )
1916 {
1917 // to find the last row we need to use the generic HitTest
1918 wxTextCoord col;
1919
1920 // OPT this is a bit silly: we undo this in HitTest(), so
1921 // it would be better to factor out the common
1922 // functionality into a separate function (OTOH it
1923 // won't probably save us that much)
1924 wxPoint pt(0, rectText.height - 1);
1925 pt += GetClientAreaOrigin();
1926 pt += m_rectText.GetPosition();
1927 HitTest(pt, &col, &yEnd);
1928
1929 // find the row inside the line
1930 yEnd = GetFirstRowOfLine(yEnd) + GetRowInLine(yEnd, col);
1931 }
1932 else
1933 {
1934 // finding the last line is easy if each line has exactly
1935 // one row
1936 yEnd = yStart + rectText.height / GetLineHeight() - 1;
1937 }
1938
1939 if ( yEnd < y )
1940 {
1941 // scroll down: the current item should appear at the
1942 // bottom of the view
1943 Scroll(0, y - (yEnd - yStart));
1944 }
1945 }
1946 }
1947
1948 // scroll the position horizontally into view
1949 //
1950 // we follow what I believe to be Windows behaviour here, that is if
1951 // the position is already entirely in the view we do nothing, but if
1952 // we do have to scroll the window to bring it into view, we scroll it
1953 // not just enough to show the position but slightly more so that this
1954 // position is at 1/3 of the window width from the closest border to it
1955 // (I'm not sure that Windows does exactly this but it looks like this)
1956 if ( MData().m_scrollRangeX )
1957 {
1958 // unlike for the rows, xStart doesn't correspond to the starting
1959 // column as they all have different widths, so we need to
1960 // translate everything to pixels
1961
1962 // we want the text between x and x2 be entirely inside the view
1963 // (i.e. the current character)
1964
1965 // make xStart the first visible pixel (and not position)
1966 int wChar = GetAverageWidth();
1967 xStart *= wChar;
1968
1969 if ( x < xStart )
1970 {
1971 // we want the position of this column be 1/3 to the right of
1972 // the left edge
1973 x -= rectText.width / 3;
1974 if ( x < 0 )
1975 x = 0;
1976 Scroll(x / wChar, y);
1977 }
1978 else // maybe we're beyond the right border of the view?
1979 {
1980 wxTextCoord col, row;
1981 if ( PositionToXY(pos, &col, &row) )
1982 {
1983 wxString lineText = GetLineText(row);
1984 wxCoord x2 = x + GetTextWidth(lineText[(size_t)col]);
1985 if ( x2 > xStart + rectText.width )
1986 {
1987 // we want the position of this column be 1/3 to the
1988 // left of the right edge, i.e. 2/3 right of the left
1989 // one
1990 x2 -= (2*rectText.width)/3;
1991 if ( x2 < 0 )
1992 x2 = 0;
1993 Scroll(x2 / wChar, row);
1994 }
1995 }
1996 }
1997 }
1998 }
1999 //else: multiline but no scrollbars, hence nothing to do
2000
2001 if (showCaret)
2002 ShowCaret();
2003 }
2004
2005 // ----------------------------------------------------------------------------
2006 // word stuff
2007 // ----------------------------------------------------------------------------
2008
2009 /*
2010 TODO: we could have (easy to do) vi-like options for word movement, i.e.
2011 distinguish between inlusive/exclusive words and between words and
2012 WORDS (in vim sense) and also, finally, make the set of characters
2013 which make up a word configurable - currently we use the exclusive
2014 WORDS only (coincidentally, this is what Windows edit control does)
2015
2016 For future references, here is what vim help says:
2017
2018 A word consists of a sequence of letters, digits and underscores, or
2019 a sequence of other non-blank characters, separated with white space
2020 (spaces, tabs, <EOL>). This can be changed with the 'iskeyword'
2021 option.
2022
2023 A WORD consists of a sequence of non-blank characters, separated with
2024 white space. An empty line is also considered to be a word and a
2025 WORD.
2026 */
2027
2028 static inline bool IsWordChar(wxChar ch)
2029 {
2030 return !wxIsspace(ch);
2031 }
2032
2033 wxTextPos wxTextCtrl::GetWordStart() const
2034 {
2035 if ( m_curPos == -1 || m_curPos == 0 )
2036 return 0;
2037
2038 if ( m_curCol == 0 )
2039 {
2040 // go to the end of the previous line
2041 return m_curPos - 1;
2042 }
2043
2044 // it shouldn't be possible to learn where the word starts in the password
2045 // text entry zone
2046 if ( IsPassword() )
2047 return 0;
2048
2049 // start at the previous position
2050 const wxChar *p0 = GetLineText(m_curRow).c_str();
2051 const wxChar *p = p0 + m_curCol - 1;
2052
2053 // find the end of the previous word
2054 while ( (p > p0) && !IsWordChar(*p) )
2055 p--;
2056
2057 // now find the beginning of this word
2058 while ( (p > p0) && IsWordChar(*p) )
2059 p--;
2060
2061 // we might have gone too far
2062 if ( !IsWordChar(*p) )
2063 p++;
2064
2065 return (m_curPos - m_curCol) + p - p0;
2066 }
2067
2068 wxTextPos wxTextCtrl::GetWordEnd() const
2069 {
2070 if ( m_curPos == -1 )
2071 return 0;
2072
2073 wxString line = GetLineText(m_curRow);
2074 if ( (size_t)m_curCol == line.length() )
2075 {
2076 // if we're on the last position in the line, go to the next one - if
2077 // it exists
2078 wxTextPos pos = m_curPos;
2079 if ( pos < GetLastPosition() )
2080 pos++;
2081
2082 return pos;
2083 }
2084
2085 // it shouldn't be possible to learn where the word ends in the password
2086 // text entry zone
2087 if ( IsPassword() )
2088 return GetLastPosition();
2089
2090 // start at the current position
2091 const wxChar *p0 = line.c_str();
2092 const wxChar *p = p0 + m_curCol;
2093
2094 // find the start of the next word
2095 while ( *p && !IsWordChar(*p) )
2096 p++;
2097
2098 // now find the end of it
2099 while ( *p && IsWordChar(*p) )
2100 p++;
2101
2102 // and find the start of the next word
2103 while ( *p && !IsWordChar(*p) )
2104 p++;
2105
2106 return (m_curPos - m_curCol) + p - p0;
2107 }
2108
2109 // ----------------------------------------------------------------------------
2110 // clipboard stuff
2111 // ----------------------------------------------------------------------------
2112
2113 void wxTextCtrl::Copy()
2114 {
2115 #if wxUSE_CLIPBOARD
2116 if ( HasSelection() )
2117 {
2118 wxClipboardLocker clipLock;
2119
2120 // wxTextFile::Translate() is needed to transform all '\n' into "\r\n"
2121 wxString text = wxTextFile::Translate(GetTextToShow(GetSelectionText()));
2122 wxTextDataObject *data = new wxTextDataObject(text);
2123 wxTheClipboard->SetData(data);
2124 }
2125 #endif // wxUSE_CLIPBOARD
2126 }
2127
2128 void wxTextCtrl::Cut()
2129 {
2130 (void)DoCut();
2131 }
2132
2133 bool wxTextCtrl::DoCut()
2134 {
2135 if ( !HasSelection() )
2136 return false;
2137
2138 Copy();
2139
2140 RemoveSelection();
2141
2142 return true;
2143 }
2144
2145 void wxTextCtrl::Paste()
2146 {
2147 (void)DoPaste();
2148 }
2149
2150 bool wxTextCtrl::DoPaste()
2151 {
2152 #if wxUSE_CLIPBOARD
2153 wxClipboardLocker clipLock;
2154
2155 wxTextDataObject data;
2156 if ( wxTheClipboard->IsSupported(data.GetFormat())
2157 && wxTheClipboard->GetData(data) )
2158 {
2159 // reverse transformation: '\r\n\" -> '\n'
2160 wxString text = wxTextFile::Translate(data.GetText(),
2161 wxTextFileType_Unix);
2162 if ( !text.empty() )
2163 {
2164 WriteText(text);
2165
2166 return true;
2167 }
2168 }
2169 #endif // wxUSE_CLIPBOARD
2170
2171 return false;
2172 }
2173
2174 // ----------------------------------------------------------------------------
2175 // Undo and redo
2176 // ----------------------------------------------------------------------------
2177
2178 wxTextCtrlInsertCommand *
2179 wxTextCtrlCommandProcessor::IsInsertCommand(wxCommand *command)
2180 {
2181 return (wxTextCtrlInsertCommand *)
2182 (command && (command->GetName() == wxTEXT_COMMAND_INSERT)
2183 ? command : NULL);
2184 }
2185
2186 void wxTextCtrlCommandProcessor::Store(wxCommand *command)
2187 {
2188 wxTextCtrlInsertCommand *cmdIns = IsInsertCommand(command);
2189 if ( cmdIns )
2190 {
2191 if ( IsCompressing() )
2192 {
2193 wxTextCtrlInsertCommand *
2194 cmdInsLast = IsInsertCommand(GetCurrentCommand());
2195
2196 // it is possible that we don't have any last command at all if,
2197 // for example, it was undone since the last Store(), so deal with
2198 // this case too
2199 if ( cmdInsLast )
2200 {
2201 cmdInsLast->Append(cmdIns);
2202
2203 delete cmdIns;
2204
2205 // don't need to call the base class version
2206 return;
2207 }
2208 }
2209
2210 // append the following insert commands to this one
2211 m_compressInserts = true;
2212
2213 // let the base class version will do the job normally
2214 }
2215 else // not an insert command
2216 {
2217 // stop compressing insert commands - this won't work with the last
2218 // command not being an insert one anyhow
2219 StopCompressing();
2220
2221 // let the base class version will do the job normally
2222 }
2223
2224 wxCommandProcessor::Store(command);
2225 }
2226
2227 void wxTextCtrlInsertCommand::Append(wxTextCtrlInsertCommand *other)
2228 {
2229 m_text += other->m_text;
2230 }
2231
2232 bool wxTextCtrlInsertCommand::CanUndo() const
2233 {
2234 return m_from != -1;
2235 }
2236
2237 bool wxTextCtrlInsertCommand::Do(wxTextCtrl *text)
2238 {
2239 // the text is going to be inserted at the current position, remember where
2240 // exactly it is
2241 m_from = text->GetInsertionPoint();
2242
2243 // and now do insert it
2244 text->WriteText(m_text);
2245
2246 return true;
2247 }
2248
2249 bool wxTextCtrlInsertCommand::Undo(wxTextCtrl *text)
2250 {
2251 wxCHECK_MSG( CanUndo(), false, _T("impossible to undo insert cmd") );
2252
2253 // remove the text from where we inserted it
2254 text->Remove(m_from, m_from + m_text.length());
2255
2256 return true;
2257 }
2258
2259 bool wxTextCtrlRemoveCommand::CanUndo() const
2260 {
2261 // if we were executed, we should have the text we removed
2262 return !m_textDeleted.empty();
2263 }
2264
2265 bool wxTextCtrlRemoveCommand::Do(wxTextCtrl *text)
2266 {
2267 text->SetSelection(m_from, m_to);
2268 m_textDeleted = text->GetSelectionText();
2269 text->RemoveSelection();
2270
2271 return true;
2272 }
2273
2274 bool wxTextCtrlRemoveCommand::Undo(wxTextCtrl *text)
2275 {
2276 // it is possible that the text was deleted and that we can't restore text
2277 // at the same position we removed it any more
2278 wxTextPos posLast = text->GetLastPosition();
2279 text->SetInsertionPoint(m_from > posLast ? posLast : m_from);
2280 text->WriteText(m_textDeleted);
2281
2282 return true;
2283 }
2284
2285 void wxTextCtrl::Undo()
2286 {
2287 // the caller must check it
2288 wxASSERT_MSG( CanUndo(), _T("can't call Undo() if !CanUndo()") );
2289
2290 m_cmdProcessor->Undo();
2291 }
2292
2293 void wxTextCtrl::Redo()
2294 {
2295 // the caller must check it
2296 wxASSERT_MSG( CanRedo(), _T("can't call Undo() if !CanUndo()") );
2297
2298 m_cmdProcessor->Redo();
2299 }
2300
2301 bool wxTextCtrl::CanUndo() const
2302 {
2303 return IsEditable() && m_cmdProcessor->CanUndo();
2304 }
2305
2306 bool wxTextCtrl::CanRedo() const
2307 {
2308 return IsEditable() && m_cmdProcessor->CanRedo();
2309 }
2310
2311 // ----------------------------------------------------------------------------
2312 // geometry
2313 // ----------------------------------------------------------------------------
2314
2315 wxSize wxTextCtrl::DoGetBestClientSize() const
2316 {
2317 // when we're called for the very first time from Create() we must
2318 // calculate the font metrics here because we can't do it before calling
2319 // Create() (there is no window yet and wxGTK crashes) but we need them
2320 // here
2321 if ( m_heightLine == -1 )
2322 {
2323 wxConstCast(this, wxTextCtrl)->RecalcFontMetrics();
2324 }
2325
2326 wxCoord w, h;
2327 GetTextExtent(GetTextToShow(GetLineText(0)), &w, &h);
2328
2329 int wChar = GetAverageWidth(),
2330 hChar = GetLineHeight();
2331
2332 int widthMin = wxMax(10*wChar, 100);
2333 if ( w < widthMin )
2334 w = widthMin;
2335 if ( h < hChar )
2336 h = hChar;
2337
2338 if ( !IsSingleLine() )
2339 {
2340 // let the control have a reasonable number of lines
2341 int lines = GetNumberOfLines();
2342 if ( lines < 5 )
2343 lines = 5;
2344 else if ( lines > 10 )
2345 lines = 10;
2346 h *= lines;
2347 }
2348
2349 wxRect rectText;
2350 rectText.width = w;
2351 rectText.height = h;
2352 wxRect rectTotal = GetRenderer()->GetTextTotalArea(this, rectText);
2353 return wxSize(rectTotal.width, rectTotal.height);
2354 }
2355
2356 void wxTextCtrl::UpdateTextRect()
2357 {
2358 wxRect rectTotal(GetClientSize());
2359 wxCoord *extraSpace = WrapLines() ? &WData().m_widthMark : NULL;
2360 m_rectText = GetRenderer()->GetTextClientArea(this, rectTotal, extraSpace);
2361
2362 // code elsewhere is confused by negative rect size
2363 if ( m_rectText.width <= 0 )
2364 m_rectText.width = 1;
2365 if ( m_rectText.height <= 0 )
2366 m_rectText.height = 1;
2367
2368 if ( !IsSingleLine() )
2369 {
2370 // invalidate it so that GetRealTextArea() will recalc it
2371 MData().m_rectTextReal.width = 0;
2372
2373 // only scroll this rect when the window is scrolled: note that we have
2374 // to scroll not only the text but the line wrap marks too if we show
2375 // them
2376 wxRect rectText = GetRealTextArea();
2377 if ( extraSpace && *extraSpace )
2378 {
2379 rectText.width += *extraSpace;
2380 }
2381 SetTargetRect(rectText);
2382
2383 // relayout all lines
2384 if ( WrapLines() )
2385 {
2386 WData().m_rowFirstInvalid = 0;
2387
2388 // increase timestamp: this means that the lines which had been
2389 // laid out before will be relayd out the next time LayoutLines()
2390 // is called because their timestamp will be smaller than the
2391 // current one
2392 WData().m_timestamp++;
2393 }
2394 }
2395
2396 UpdateLastVisible();
2397 }
2398
2399 void wxTextCtrl::UpdateLastVisible()
2400 {
2401 // this method is only used for horizontal "scrollbarless" scrolling which
2402 // is used only with single line controls
2403 if ( !IsSingleLine() )
2404 return;
2405
2406 // use (efficient) HitTestLine to find the last visible character
2407 wxString text = m_value.Mid((size_t)SData().m_colStart /* to the end */);
2408 wxTextCoord col;
2409 switch ( HitTestLine(text, m_rectText.width, &col) )
2410 {
2411 case wxTE_HT_BEYOND:
2412 // everything is visible
2413 SData().m_colLastVisible = text.length();
2414
2415 // calc it below
2416 SData().m_posLastVisible = -1;
2417 break;
2418
2419 /*
2420 case wxTE_HT_BEFORE:
2421 case wxTE_HT_BELOW:
2422 */
2423 default:
2424 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2425 // fall through
2426
2427 case wxTE_HT_ON_TEXT:
2428 if ( col > 0 )
2429 {
2430 // the last entirely seen character is the previous one because
2431 // this one is only partly visible - unless the width of the
2432 // string is exactly the max width
2433 SData().m_posLastVisible = GetTextWidth(text.Truncate(col + 1));
2434 if ( SData().m_posLastVisible > m_rectText.width )
2435 {
2436 // this character is not entirely visible, take the
2437 // previous one
2438 col--;
2439
2440 // recalc it
2441 SData().m_posLastVisible = -1;
2442 }
2443 //else: we can just see it
2444
2445 SData().m_colLastVisible = col;
2446 }
2447 break;
2448 }
2449
2450 // calculate the width of the text really shown
2451 if ( SData().m_posLastVisible == -1 )
2452 {
2453 SData().m_posLastVisible = GetTextWidth(text.Truncate(SData().m_colLastVisible + 1));
2454 }
2455
2456 // current value is relative the start of the string text which starts at
2457 // SData().m_colStart, we need an absolute offset into string
2458 SData().m_colLastVisible += SData().m_colStart;
2459
2460 wxLogTrace(_T("text"), _T("Last visible column/position is %d/%ld"),
2461 (int) SData().m_colLastVisible, (long) SData().m_posLastVisible);
2462 }
2463
2464 void wxTextCtrl::OnSize(wxSizeEvent& event)
2465 {
2466 UpdateTextRect();
2467
2468 if ( !IsSingleLine() )
2469 {
2470 #if 0
2471 // update them immediately because if we are called for the first time,
2472 // we need to create them in order for the base class version to
2473 // position the scrollbars correctly - if we don't do it now, it won't
2474 // happen at all if we don't get more size events
2475 UpdateScrollbars();
2476 #endif // 0
2477
2478 MData().m_updateScrollbarX =
2479 MData().m_updateScrollbarY = true;
2480 }
2481
2482 event.Skip();
2483 }
2484
2485 wxCoord wxTextCtrl::GetTotalWidth() const
2486 {
2487 wxCoord w;
2488 CalcUnscrolledPosition(m_rectText.width, 0, &w, NULL);
2489 return w;
2490 }
2491
2492 wxCoord wxTextCtrl::GetTextWidth(const wxString& text) const
2493 {
2494 wxCoord w;
2495 GetTextExtent(GetTextToShow(text), &w, NULL);
2496 return w;
2497 }
2498
2499 wxRect wxTextCtrl::GetRealTextArea() const
2500 {
2501 // for single line text control it's just the same as text rect
2502 if ( IsSingleLine() )
2503 return m_rectText;
2504
2505 // the real text area always holds an entire number of lines, so the only
2506 // difference with the text area is a narrow strip along the bottom border
2507 wxRect rectText = MData().m_rectTextReal;
2508 if ( !rectText.width )
2509 {
2510 // recalculate it
2511 rectText = m_rectText;
2512
2513 // when we're called for the very first time, the line height might not
2514 // had been calculated yet, so do get it now
2515 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
2516 self->RecalcFontMetrics();
2517
2518 int hLine = GetLineHeight();
2519 rectText.height = (m_rectText.height / hLine) * hLine;
2520
2521 // cache the result
2522 self->MData().m_rectTextReal = rectText;
2523 }
2524
2525 return rectText;
2526 }
2527
2528 wxTextCoord wxTextCtrl::GetRowInLine(wxTextCoord line,
2529 wxTextCoord col,
2530 wxTextCoord *colRowStart) const
2531 {
2532 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2533
2534 const wxWrappedLineData& lineData = WData().m_linesData[line];
2535
2536 if ( !WData().IsValidLine(line) )
2537 LayoutLines(line);
2538
2539 // row is here counted a bit specially: 0 is the 2nd row of the line (1st
2540 // extra row)
2541 size_t row = 0,
2542 rowMax = lineData.GetExtraRowCount();
2543 if ( rowMax )
2544 {
2545 row = 0;
2546 while ( (row < rowMax) && (col >= lineData.GetExtraRowStart(row)) )
2547 row++;
2548
2549 // it's ok here that row is 1 greater than needed: like this, it is
2550 // counted as a normal (and not extra) row
2551 }
2552 //else: only one row anyhow
2553
2554 if ( colRowStart )
2555 {
2556 // +1 because we need a real row number, not the extra row one
2557 *colRowStart = lineData.GetRowStart(row);
2558
2559 // this can't happen, of course
2560 wxASSERT_MSG( *colRowStart <= col, _T("GetRowInLine() is broken") );
2561 }
2562
2563 return row;
2564 }
2565
2566 void wxTextCtrl::LayoutLine(wxTextCoord line, wxWrappedLineData& lineData) const
2567 {
2568 // FIXME: this uses old GetPartOfWrappedLine() which is not used anywhere
2569 // else now and has rather awkward interface for our needs here
2570
2571 lineData.m_rowsStart.Empty();
2572 lineData.m_rowsWidth.Empty();
2573
2574 const wxString& text = GetLineText(line);
2575 wxCoord widthRow;
2576 size_t colRowStart = 0;
2577 do
2578 {
2579 size_t lenRow = GetPartOfWrappedLine
2580 (
2581 text.c_str() + colRowStart,
2582 &widthRow
2583 );
2584
2585 // remember the start of this row (not for the first one as
2586 // it's always 0) and its width
2587 if ( colRowStart )
2588 lineData.m_rowsStart.Add(colRowStart);
2589 lineData.m_rowsWidth.Add(widthRow);
2590
2591 colRowStart += lenRow;
2592 }
2593 while ( colRowStart < text.length() );
2594
2595 // put the current timestamp on it
2596 lineData.m_timestamp = WData().m_timestamp;
2597 }
2598
2599 void wxTextCtrl::LayoutLines(wxTextCoord lineLast) const
2600 {
2601 wxASSERT_MSG( WrapLines(), _T("should only be used for line wrapping") );
2602
2603 // if we were called, some line was dirty and if it was dirty we must have
2604 // had m_rowFirstInvalid set to something too
2605 wxTextCoord lineFirst = WData().m_rowFirstInvalid;
2606 wxASSERT_MSG( lineFirst != -1, _T("nothing to layout?") );
2607
2608 wxTextCoord rowFirst, rowCur;
2609 if ( lineFirst )
2610 {
2611 // start after the last known valid line
2612 const wxWrappedLineData& lineData = WData().m_linesData[lineFirst - 1];
2613 rowFirst = lineData.GetFirstRow() + lineData.GetRowCount();
2614 }
2615 else // no valid lines, start at row 0
2616 {
2617 rowFirst = 0;
2618 }
2619
2620 rowCur = rowFirst;
2621 for ( wxTextCoord line = lineFirst; line <= lineLast; line++ )
2622 {
2623 // set the starting row for this line
2624 wxWrappedLineData& lineData = WData().m_linesData[line];
2625 lineData.m_rowFirst = rowCur;
2626
2627 // had the line been already broken into rows?
2628 //
2629 // if so, compare its timestamp with the current one: if nothing has
2630 // been changed, don't relayout it
2631 if ( !lineData.IsValid() ||
2632 (lineData.m_timestamp < WData().m_timestamp) )
2633 {
2634 // now do break it in rows
2635 LayoutLine(line, lineData);
2636 }
2637
2638 rowCur += lineData.GetRowCount();
2639 }
2640
2641 // we are now valid at least up to this line, but if it is the last one we
2642 // just don't have any more invalid rows at all
2643 if ( (size_t)lineLast == WData().m_linesData.GetCount() -1 )
2644 {
2645 lineLast = -1;
2646 }
2647
2648 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
2649 self->WData().m_rowFirstInvalid = lineLast;
2650
2651 // also refresh the line end indicators (FIXME shouldn't do it always!)
2652 self->RefreshLineWrapMarks(rowFirst, rowCur);
2653 }
2654
2655 size_t wxTextCtrl::GetPartOfWrappedLine(const wxChar* text,
2656 wxCoord *widthReal) const
2657 {
2658 // this function is slow, it shouldn't be called unless really needed
2659 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2660
2661 wxString s(text);
2662 wxTextCoord col;
2663 wxCoord wReal = wxDefaultCoord;
2664 switch ( HitTestLine(s, m_rectText.width, &col) )
2665 {
2666 /*
2667 case wxTE_HT_BEFORE:
2668 case wxTE_HT_BELOW:
2669 */
2670 default:
2671 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2672 // fall through
2673
2674 case wxTE_HT_ON_TEXT:
2675 if ( col > 0 )
2676 {
2677 // the last entirely seen character is the previous one because
2678 // this one is only partly visible - unless the width of the
2679 // string is exactly the max width
2680 wReal = GetTextWidth(s.Truncate(col + 1));
2681 if ( wReal > m_rectText.width )
2682 {
2683 // this character is not entirely visible, take the
2684 // previous one
2685 col--;
2686
2687 // recalc the width
2688 wReal = wxDefaultCoord;
2689 }
2690 //else: we can just see it
2691
2692 // wrap at any character or only at words boundaries?
2693 if ( !(GetWindowStyle() & wxTE_LINEWRAP) )
2694 {
2695 // find the (last) not word char before this word
2696 wxTextCoord colWordStart;
2697 for ( colWordStart = col;
2698 colWordStart && IsWordChar(s[(size_t)colWordStart]);
2699 colWordStart-- )
2700 ;
2701
2702 if ( colWordStart > 0 )
2703 {
2704 if ( colWordStart != col )
2705 {
2706 // will have to recalc the real width
2707 wReal = wxDefaultCoord;
2708
2709 col = colWordStart;
2710 }
2711 }
2712 //else: only a single word, have to wrap it here
2713 }
2714 }
2715 break;
2716
2717 case wxTE_HT_BEYOND:
2718 break;
2719 }
2720
2721 // we return the number of characters, not the index of the last one
2722 if ( (size_t)col < s.length() )
2723 {
2724 // but don't return more than this (empty) string has
2725 col++;
2726 }
2727
2728 if ( widthReal )
2729 {
2730 if ( wReal == wxDefaultCoord )
2731 {
2732 // calc it if not done yet
2733 wReal = GetTextWidth(s.Truncate(col));
2734 }
2735
2736 *widthReal = wReal;
2737 }
2738
2739 // VZ: old, horribly inefficient code which can still be used for checking
2740 // the result (in line, not word, wrap mode only) - to be removed later
2741 #if 0
2742 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
2743 wxClientDC dc(self);
2744 dc.SetFont(GetFont());
2745 self->DoPrepareDC(dc);
2746
2747 wxCoord widthMax = m_rectText.width;
2748
2749 // the text which we can keep in this ROW
2750 wxString str;
2751 wxCoord w, wOld;
2752 for ( wOld = w = 0; *text && (w <= widthMax); )
2753 {
2754 wOld = w;
2755 str += *text++;
2756 dc.GetTextExtent(str, &w, NULL);
2757 }
2758
2759 if ( w > widthMax )
2760 {
2761 // if we wrapped, the last letter was one too much
2762 if ( str.length() > 1 )
2763 {
2764 // remove it
2765 str.erase(str.length() - 1, 1);
2766 }
2767 else // but always keep at least one letter in each row
2768 {
2769 // the real width then is the last value of w and not teh one
2770 // before last
2771 wOld = w;
2772 }
2773 }
2774 else // we didn't wrap
2775 {
2776 wOld = w;
2777 }
2778
2779 wxASSERT( col == str.length() );
2780
2781 if ( widthReal )
2782 {
2783 wxASSERT( *widthReal == wOld );
2784
2785 *widthReal = wOld;
2786 }
2787
2788 //return str.length();
2789 #endif
2790
2791 return col;
2792 }
2793
2794 // OPT: this function is called a lot - would be nice to optimize it but I
2795 // don't really know how yet
2796 wxTextCtrlHitTestResult wxTextCtrl::HitTestLine(const wxString& line,
2797 wxCoord x,
2798 wxTextCoord *colOut) const
2799 {
2800 wxTextCtrlHitTestResult res = wxTE_HT_ON_TEXT;
2801
2802 int col;
2803 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
2804 wxClientDC dc(self);
2805 dc.SetFont(GetFont());
2806 self->DoPrepareDC(dc);
2807
2808 wxCoord width;
2809 dc.GetTextExtent(line, &width, NULL);
2810 if ( x >= width )
2811 {
2812 // clicking beyond the end of line is equivalent to clicking at
2813 // the end of it, so return the last line column
2814 col = line.length();
2815 if ( col )
2816 {
2817 // unless the line is empty and so doesn't have any column at all -
2818 // in this case return 0, what else can we do?
2819 col--;
2820 }
2821
2822 res = wxTE_HT_BEYOND;
2823 }
2824 else if ( x < 0 )
2825 {
2826 col = 0;
2827
2828 res = wxTE_HT_BEFORE;
2829 }
2830 else // we're inside the line
2831 {
2832 // now calculate the column: first, approximate it with fixed-width
2833 // value and then calculate the correct value iteratively: note that
2834 // we use the first character of the line instead of (average)
2835 // GetCharWidth(): it is common to have lines of dashes, for example,
2836 // and this should give us much better approximation in such case
2837 //
2838 // OPT: maybe using (cache) m_widthAvg would be still faster? profile!
2839 dc.GetTextExtent(line[0], &width, NULL);
2840
2841 col = x / width;
2842 if ( col < 0 )
2843 {
2844 col = 0;
2845 }
2846 else if ( (size_t)col > line.length() )
2847 {
2848 col = line.length();
2849 }
2850
2851 // matchDir is the direction in which we should move to reach the
2852 // character containing the given position
2853 enum
2854 {
2855 Match_Left = -1,
2856 Match_None = 0,
2857 Match_Right = 1
2858 } matchDir = Match_None;
2859 for ( ;; )
2860 {
2861 // check that we didn't go beyond the line boundary
2862 if ( col < 0 )
2863 {
2864 col = 0;
2865 break;
2866 }
2867 if ( (size_t)col > line.length() )
2868 {
2869 col = line.length();
2870 break;
2871 }
2872
2873 wxString strBefore(line, (size_t)col);
2874 dc.GetTextExtent(strBefore, &width, NULL);
2875 if ( width > x )
2876 {
2877 if ( matchDir == Match_Right )
2878 {
2879 // we were going to the right and, finally, moved beyond
2880 // the original position - stop on the previous one
2881 col--;
2882
2883 break;
2884 }
2885
2886 if ( matchDir == Match_None )
2887 {
2888 // we just started iterating, now we know that we should
2889 // move to the left
2890 matchDir = Match_Left;
2891 }
2892 //else: we are still to the right of the target, continue
2893 }
2894 else // width < x
2895 {
2896 // invert the logic above
2897 if ( matchDir == Match_Left )
2898 {
2899 // with the exception that we don't need to backtrack here
2900 break;
2901 }
2902
2903 if ( matchDir == Match_None )
2904 {
2905 // go to the right
2906 matchDir = Match_Right;
2907 }
2908 }
2909
2910 // this is not supposed to happen
2911 wxASSERT_MSG( matchDir, _T("logic error in wxTextCtrl::HitTest") );
2912
2913 if ( matchDir == Match_Right )
2914 col++;
2915 else
2916 col--;
2917 }
2918 }
2919
2920 // check that we calculated it correctly
2921 #ifdef WXDEBUG_TEXT
2922 if ( res == wxTE_HT_ON_TEXT )
2923 {
2924 wxCoord width1;
2925 wxString text = line.Left(col);
2926 dc.GetTextExtent(text, &width1, NULL);
2927 if ( (size_t)col < line.length() )
2928 {
2929 wxCoord width2;
2930
2931 text += line[col];
2932 dc.GetTextExtent(text, &width2, NULL);
2933
2934 wxASSERT_MSG( (width1 <= x) && (x < width2),
2935 _T("incorrect HitTestLine() result") );
2936 }
2937 else // we return last char
2938 {
2939 wxASSERT_MSG( x >= width1, _T("incorrect HitTestLine() result") );
2940 }
2941 }
2942 #endif // WXDEBUG_TEXT
2943
2944 if ( colOut )
2945 *colOut = col;
2946
2947 return res;
2948 }
2949
2950 wxTextCtrlHitTestResult wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const
2951 {
2952 wxTextCoord x, y;
2953 wxTextCtrlHitTestResult rc = HitTest(pt, &x, &y);
2954 if ( rc != wxTE_HT_UNKNOWN && pos )
2955 {
2956 *pos = XYToPosition(x, y);
2957 }
2958
2959 return rc;
2960 }
2961
2962 wxTextCtrlHitTestResult wxTextCtrl::HitTest(const wxPoint& pos,
2963 wxTextCoord *colOut,
2964 wxTextCoord *rowOut) const
2965 {
2966 return HitTest2(pos.y, pos.x, 0, rowOut, colOut, NULL, NULL);
2967 }
2968
2969 wxTextCtrlHitTestResult wxTextCtrl::HitTestLogical(const wxPoint& pos,
2970 wxTextCoord *colOut,
2971 wxTextCoord *rowOut) const
2972 {
2973 return HitTest2(pos.y, pos.x, 0, rowOut, colOut, NULL, NULL, false);
2974 }
2975
2976 wxTextCtrlHitTestResult wxTextCtrl::HitTest2(wxCoord y0,
2977 wxCoord x10,
2978 wxCoord x20,
2979 wxTextCoord *rowOut,
2980 wxTextCoord *colStart,
2981 wxTextCoord *colEnd,
2982 wxTextCoord *colRowStartOut,
2983 bool deviceCoords) const
2984 {
2985 // is the point in the text area or to the right or below it?
2986 wxTextCtrlHitTestResult res = wxTE_HT_ON_TEXT;
2987
2988 // translate the window coords x0 and y0 into the client coords in the text
2989 // area by adjusting for both the client and text area offsets (unless this
2990 // was already done)
2991 int x1, y;
2992 if ( deviceCoords )
2993 {
2994 wxPoint pt = GetClientAreaOrigin() + m_rectText.GetPosition();
2995 CalcUnscrolledPosition(x10 - pt.x, y0 - pt.y, &x1, &y);
2996 }
2997 else
2998 {
2999 y = y0;
3000 x1 = x10;
3001 }
3002
3003 // calculate the row (it is really a LINE, not a ROW)
3004 wxTextCoord row;
3005
3006 // these vars are used only for WrapLines() case
3007 wxTextCoord colRowStart = 0;
3008 size_t rowLen = 0;
3009
3010 if ( colRowStartOut )
3011 *colRowStartOut = 0;
3012
3013 int hLine = GetLineHeight();
3014 if ( y < 0 )
3015 {
3016 // and clicking before it is the same as clicking on the first one
3017 row = 0;
3018
3019 res = wxTE_HT_BEFORE;
3020 }
3021 else // y >= 0
3022 {
3023 wxTextCoord rowLast = GetNumberOfLines() - 1;
3024 row = y / hLine;
3025 if ( IsSingleLine() || !WrapLines() )
3026 {
3027 // in this case row calculation is simple as all lines have the
3028 // same height and so row is the same as line
3029 if ( row > rowLast )
3030 {
3031 // clicking below the text is the same as clicking on the last
3032 // line
3033 row = rowLast;
3034
3035 res = wxTE_HT_BELOW;
3036 }
3037 }
3038 else // multline control with line wrap
3039 {
3040 // use binary search to find the line containing this row
3041 const wxArrayWrappedLinesData& linesData = WData().m_linesData;
3042 size_t lo = 0,
3043 hi = linesData.GetCount(),
3044 cur;
3045 while ( lo < hi )
3046 {
3047 cur = (lo + hi)/2;
3048 const wxWrappedLineData& lineData = linesData[cur];
3049 if ( !WData().IsValidLine(cur) )
3050 LayoutLines(cur);
3051 wxTextCoord rowFirst = lineData.GetFirstRow();
3052
3053 if ( row < rowFirst )
3054 {
3055 hi = cur;
3056 }
3057 else
3058 {
3059 // our row is after the first row of the cur line:
3060 // obviously, if cur is the last line, it contains this
3061 // row, otherwise we have to test that it is before the
3062 // first row of the next line
3063 bool found = cur == linesData.GetCount() - 1;
3064 if ( found )
3065 {
3066 // if the row is beyond the end of text, adjust it to
3067 // be the last one and set res accordingly
3068 if ( (size_t)(row - rowFirst) >= lineData.GetRowCount() )
3069 {
3070 res = wxTE_HT_BELOW;
3071
3072 row = lineData.GetRowCount() + rowFirst - 1;
3073 }
3074 }
3075 else // not the last row
3076 {
3077 const wxWrappedLineData&
3078 lineNextData = linesData[cur + 1];
3079 if ( !WData().IsValidLine(cur + 1) )
3080 LayoutLines(cur + 1);
3081 found = row < lineNextData.GetFirstRow();
3082 }
3083
3084 if ( found )
3085 {
3086 colRowStart = lineData.GetRowStart(row - rowFirst);
3087 rowLen = lineData.GetRowLength(row - rowFirst,
3088 GetLines()[cur].length());
3089 row = cur;
3090
3091 break;
3092 }
3093 else
3094 {
3095 lo = cur;
3096 }
3097 }
3098 }
3099 }
3100 }
3101
3102 if ( res == wxTE_HT_ON_TEXT )
3103 {
3104 // now find the position in the line
3105 wxString lineText = GetLineText(row),
3106 rowText;
3107
3108 if ( colRowStart || rowLen )
3109 {
3110 // look in this row only, not in whole line
3111 rowText = lineText.Mid(colRowStart, rowLen);
3112 }
3113 else
3114 {
3115 // just take the whole string
3116 rowText = lineText;
3117 }
3118
3119 if ( colStart )
3120 {
3121 res = HitTestLine(GetTextToShow(rowText), x1, colStart);
3122
3123 if ( colRowStart )
3124 {
3125 if ( colRowStartOut )
3126 {
3127 // give them the column offset in this ROW in pixels
3128 *colRowStartOut = colRowStart;
3129 }
3130
3131 // take into account that the ROW doesn't start in the
3132 // beginning of the LINE
3133 *colStart += colRowStart;
3134 }
3135
3136 if ( colEnd )
3137 {
3138 // the hit test result we return is for x1, so throw out
3139 // the result for x2 here
3140 int x2 = x1 + x20 - x10;
3141 (void)HitTestLine(GetTextToShow(rowText), x2, colEnd);
3142
3143 *colEnd += colRowStart;
3144 }
3145 }
3146 }
3147 else // before/after vertical text span
3148 {
3149 if ( colStart )
3150 {
3151 // fill the column with the first/last position in the
3152 // corresponding line
3153 if ( res == wxTE_HT_BEFORE )
3154 *colStart = 0;
3155 else // res == wxTE_HT_BELOW
3156 *colStart = GetLineText(GetNumberOfLines() - 1).length();
3157 }
3158 }
3159
3160 if ( rowOut )
3161 {
3162 // give them the row in text coords (as is)
3163 *rowOut = row;
3164 }
3165
3166 return res;
3167 }
3168
3169 bool wxTextCtrl::GetLineAndRow(wxTextCoord row,
3170 wxTextCoord *lineOut,
3171 wxTextCoord *rowInLineOut) const
3172 {
3173 wxTextCoord line,
3174 rowInLine = 0;
3175
3176 if ( row < 0 )
3177 return false;
3178
3179 int nLines = GetNumberOfLines();
3180 if ( WrapLines() )
3181 {
3182 const wxArrayWrappedLinesData& linesData = WData().m_linesData;
3183 for ( line = 0; line < nLines; line++ )
3184 {
3185 if ( !WData().IsValidLine(line) )
3186 LayoutLines(line);
3187
3188 if ( row < linesData[line].GetNextRow() )
3189 {
3190 // we found the right line
3191 rowInLine = row - linesData[line].GetFirstRow();
3192
3193 break;
3194 }
3195 }
3196
3197 if ( line == nLines )
3198 {
3199 // the row is out of range
3200 return false;
3201 }
3202 }
3203 else // no line wrapping, everything is easy
3204 {
3205 if ( row >= nLines )
3206 return false;
3207
3208 line = row;
3209 }
3210
3211 if ( lineOut )
3212 *lineOut = line;
3213 if ( rowInLineOut )
3214 *rowInLineOut = rowInLine;
3215
3216 return true;
3217 }
3218
3219 // ----------------------------------------------------------------------------
3220 // scrolling
3221 // ----------------------------------------------------------------------------
3222
3223 /*
3224 wxTextCtrl has not one but two scrolling mechanisms: one is semi-automatic
3225 scrolling in both horizontal and vertical direction implemented using
3226 wxScrollHelper and the second one is manual scrolling implemented using
3227 SData().m_ofsHorz and used by the single line controls without scroll bar.
3228
3229 The first version (the standard one) always scrolls by fixed amount which is
3230 fine for vertical scrolling as all lines have the same height but is rather
3231 ugly for horizontal scrolling if proportional font is used. This is why we
3232 manually update and use SData().m_ofsHorz which contains the length of the string
3233 which is hidden beyond the left borde. An important property of text
3234 controls using this kind of scrolling is that an entire number of characters
3235 is always shown and that parts of characters never appear on display -
3236 neither in the leftmost nor rightmost positions.
3237
3238 Once again, for multi line controls SData().m_ofsHorz is always 0 and scrolling is
3239 done as usual for wxScrollWindow.
3240 */
3241
3242 void wxTextCtrl::ShowHorzPosition(wxCoord pos)
3243 {
3244 wxASSERT_MSG( IsSingleLine(), _T("doesn't work for multiline") );
3245
3246 // pos is the logical position to show
3247
3248 // SData().m_ofsHorz is the fisrt logical position shown
3249 if ( pos < SData().m_ofsHorz )
3250 {
3251 // scroll backwards
3252 wxTextCoord col;
3253 HitTestLine(m_value, pos, &col);
3254 ScrollText(col);
3255 }
3256 else
3257 {
3258 wxCoord width = m_rectText.width;
3259 if ( !width )
3260 {
3261 // if we are called from the ctor, m_rectText is not initialized
3262 // yet, so do it now
3263 UpdateTextRect();
3264 width = m_rectText.width;
3265 }
3266
3267 // SData().m_ofsHorz + width is the last logical position shown
3268 if ( pos > SData().m_ofsHorz + width)
3269 {
3270 // scroll forward
3271 wxTextCoord col;
3272 HitTestLine(m_value, pos - width, &col);
3273 ScrollText(col + 1);
3274 }
3275 }
3276 }
3277
3278 // scroll the window horizontally so that the first visible character becomes
3279 // the one at this position
3280 void wxTextCtrl::ScrollText(wxTextCoord col)
3281 {
3282 wxASSERT_MSG( IsSingleLine(),
3283 _T("ScrollText() is for single line controls only") );
3284
3285 // never scroll beyond the left border
3286 if ( col < 0 )
3287 col = 0;
3288
3289 // OPT: could only get the extent of the part of the string between col
3290 // and SData().m_colStart
3291 wxCoord ofsHorz = GetTextWidth(GetLineText(0).Left(col));
3292
3293 if ( ofsHorz != SData().m_ofsHorz )
3294 {
3295 // remember the last currently used pixel
3296 int posLastVisible = SData().m_posLastVisible;
3297 if ( posLastVisible == -1 )
3298 {
3299 // this may happen when we're called very early, during the
3300 // controls construction
3301 UpdateLastVisible();
3302
3303 posLastVisible = SData().m_posLastVisible;
3304 }
3305
3306 // NB1: to scroll to the right, offset must be negative, hence the
3307 // order of operands
3308 int dx = SData().m_ofsHorz - ofsHorz;
3309
3310 // NB2: we call Refresh() below which results in a call to
3311 // DoDraw(), so we must update SData().m_ofsHorz before calling it
3312 SData().m_ofsHorz = ofsHorz;
3313 SData().m_colStart = col;
3314
3315 // after changing m_colStart, recalc the last visible position: we need
3316 // to recalc the last visible position beore scrolling in order to make
3317 // it appear exactly at the right edge of the text area after scrolling
3318 UpdateLastVisible();
3319
3320 #if 0 // do we?
3321 if ( dx < 0 )
3322 {
3323 // we want to force the update of it after scrolling
3324 SData().m_colLastVisible = -1;
3325 }
3326 #endif
3327
3328 // scroll only the rectangle inside which there is the text
3329 wxRect rect = m_rectText;
3330 rect.width = posLastVisible;
3331
3332 rect = ScrollNoRefresh(dx, 0, &rect);
3333
3334 /*
3335 we need to manually refresh the part which ScrollWindow() doesn't
3336 refresh (with new API this means the part outside the rect returned
3337 by ScrollNoRefresh): indeed, if we had this:
3338
3339 ********o
3340
3341 where '*' is text and 'o' is blank area at the end (too small to
3342 hold the next char) then after scrolling by 2 positions to the left
3343 we're going to have
3344
3345 ******RRo
3346
3347 where 'R' is the area refreshed by ScrollWindow() - but we still
3348 need to refresh the 'o' at the end as it may be now big enough to
3349 hold the new character shifted into view.
3350
3351 when we are scrolling to the right, we need to update this rect as
3352 well because it might have contained something before but doesn't
3353 contain anything any more
3354 */
3355
3356 // we can combine both rectangles into one when scrolling to the left,
3357 // but we need two separate Refreshes() otherwise
3358 if ( dx > 0 )
3359 {
3360 // refresh the uncovered part on the left
3361 Refresh(true, &rect);
3362
3363 // and now the area on the right
3364 rect.x = m_rectText.x + posLastVisible;
3365 rect.width = m_rectText.width - posLastVisible;
3366 }
3367 else // scrolling to the left
3368 {
3369 // just extend the rect covering the uncovered area to the edge of
3370 // the text rect
3371 rect.width += m_rectText.width - posLastVisible;
3372 }
3373
3374 Refresh(true, &rect);
3375
3376 // I don't know exactly why is this needed here but without it we may
3377 // scroll the window again (from the same method) before the previously
3378 // invalidated area is repainted when typing *very* quickly - and this
3379 // may lead to the display corruption
3380 Update();
3381 }
3382 }
3383
3384 void wxTextCtrl::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
3385 {
3386 if ( IsSingleLine() )
3387 {
3388 // we don't use wxScrollHelper
3389 if ( xx )
3390 *xx = x + SData().m_ofsHorz;
3391 if ( yy )
3392 *yy = y;
3393 }
3394 else
3395 {
3396 // let the base class do it
3397 wxScrollHelper::CalcUnscrolledPosition(x, y, xx, yy);
3398 }
3399 }
3400
3401 void wxTextCtrl::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
3402 {
3403 if ( IsSingleLine() )
3404 {
3405 // we don't use wxScrollHelper
3406 if ( xx )
3407 *xx = x - SData().m_ofsHorz;
3408 if ( yy )
3409 *yy = y;
3410 }
3411 else
3412 {
3413 // let the base class do it
3414 wxScrollHelper::CalcScrolledPosition(x, y, xx, yy);
3415 }
3416 }
3417
3418 void wxTextCtrl::DoPrepareDC(wxDC& dc)
3419 {
3420 // for single line controls we only have to deal with SData().m_ofsHorz and it's
3421 // useless to call base class version as they don't use normal scrolling
3422 if ( IsSingleLine() && SData().m_ofsHorz )
3423 {
3424 // adjust the DC origin if the text is shifted
3425 wxPoint pt = dc.GetDeviceOrigin();
3426 dc.SetDeviceOrigin(pt.x - SData().m_ofsHorz, pt.y);
3427 }
3428 else
3429 {
3430 wxScrollHelper::DoPrepareDC(dc);
3431 }
3432 }
3433
3434 void wxTextCtrl::UpdateMaxWidth(wxTextCoord line)
3435 {
3436 // OPT!
3437
3438 // check if the max width changes after this line was modified
3439 wxCoord widthMaxOld = MData().m_widthMax,
3440 width;
3441 GetTextExtent(GetLineText(line), &width, NULL);
3442
3443 if ( line == MData().m_lineLongest )
3444 {
3445 // this line was the longest one, is it still?
3446 if ( width > MData().m_widthMax )
3447 {
3448 MData().m_widthMax = width;
3449 }
3450 else if ( width < MData().m_widthMax )
3451 {
3452 // we need to find the new longest line
3453 RecalcMaxWidth();
3454 }
3455 //else: its length didn't change, nothing to do
3456 }
3457 else // it wasn't the longest line, but maybe it became it?
3458 {
3459 // GetMaxWidth() and not MData().m_widthMax as it might be not calculated yet
3460 if ( width > GetMaxWidth() )
3461 {
3462 MData().m_widthMax = width;
3463 MData().m_lineLongest = line;
3464 }
3465 }
3466
3467 MData().m_updateScrollbarX = MData().m_widthMax != widthMaxOld;
3468 }
3469
3470 void wxTextCtrl::RecalcFontMetrics()
3471 {
3472 m_heightLine = GetCharHeight();
3473 m_widthAvg = GetCharWidth();
3474 }
3475
3476 void wxTextCtrl::RecalcMaxWidth()
3477 {
3478 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3479
3480 MData().m_widthMax = -1;
3481 (void)GetMaxWidth();
3482 }
3483
3484 wxCoord wxTextCtrl::GetMaxWidth() const
3485 {
3486 if ( MData().m_widthMax == -1 )
3487 {
3488 // recalculate it
3489
3490 // OPT: should we remember the widths of all the lines?
3491
3492 wxTextCtrl *self = wxConstCast(this, wxTextCtrl);
3493 wxClientDC dc(self);
3494 dc.SetFont(GetFont());
3495
3496 self->MData().m_widthMax = 0;
3497
3498 size_t count = GetLineCount();
3499 for ( size_t n = 0; n < count; n++ )
3500 {
3501 wxCoord width;
3502 dc.GetTextExtent(GetLines()[n], &width, NULL);
3503 if ( width > MData().m_widthMax )
3504 {
3505 // remember the width and the line which has it
3506 self->MData().m_widthMax = width;
3507 self->MData().m_lineLongest = n;
3508 }
3509 }
3510 }
3511
3512 wxASSERT_MSG( MData().m_widthMax != -1, _T("should have at least 1 line") );
3513
3514 return MData().m_widthMax;
3515 }
3516
3517 void wxTextCtrl::UpdateScrollbars()
3518 {
3519 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3520
3521 wxSize size = GetRealTextArea().GetSize();
3522
3523 // is our height enough to show all items?
3524 wxTextCoord nRows = GetRowCount();
3525 wxCoord lineHeight = GetLineHeight();
3526 bool showScrollbarY = nRows*lineHeight > size.y;
3527
3528 // is our width enough to show the longest line?
3529 wxCoord charWidth, maxWidth;
3530 bool showScrollbarX;
3531 if ( !WrapLines() )
3532 {
3533 charWidth = GetAverageWidth();
3534 maxWidth = GetMaxWidth();
3535 showScrollbarX = maxWidth > size.x;
3536 }
3537 else // never show the horz scrollbar
3538 {
3539 // just to suppress compiler warnings about using uninit vars below
3540 charWidth = maxWidth = 0;
3541
3542 showScrollbarX = false;
3543 }
3544
3545 // calc the scrollbars ranges
3546 int scrollRangeX = showScrollbarX
3547 ? (maxWidth + 2*charWidth - 1) / charWidth
3548 : 0;
3549 int scrollRangeY = showScrollbarY ? nRows : 0;
3550
3551 int scrollRangeXOld = MData().m_scrollRangeX,
3552 scrollRangeYOld = MData().m_scrollRangeY;
3553 if ( (scrollRangeY != scrollRangeYOld) || (scrollRangeX != scrollRangeXOld) )
3554 {
3555 int x, y;
3556 GetViewStart(&x, &y);
3557
3558 #if 0
3559 // we want to leave the scrollbars at the same position which means
3560 // that x and y have to be adjusted as the number of positions may have
3561 // changed
3562 //
3563 // the number of positions is calculated from knowing that last
3564 // position = range - thumbSize and thumbSize == pageSize which is
3565 // equal to the window width / pixelsPerLine
3566 if ( scrollRangeXOld )
3567 {
3568 x *= scrollRangeX - m_rectText.width / charWidth;
3569 x /= scrollRangeXOld - m_rectText.width / charWidth;
3570 }
3571
3572 if ( scrollRangeYOld )
3573 y *= scrollRangeY / scrollRangeYOld;
3574 #endif // 0
3575
3576 SetScrollbars(charWidth, lineHeight,
3577 scrollRangeX, scrollRangeY,
3578 x, y,
3579 true /* no refresh */);
3580
3581 if ( scrollRangeXOld )
3582 {
3583 x *= scrollRangeX - m_rectText.width / charWidth;
3584 x /= scrollRangeXOld - m_rectText.width / charWidth;
3585 Scroll(x, y);
3586 }
3587
3588 MData().m_scrollRangeX = scrollRangeX;
3589 MData().m_scrollRangeY = scrollRangeY;
3590
3591 // bring the current position in view
3592 ShowPosition(-1);
3593 }
3594
3595 MData().m_updateScrollbarX =
3596 MData().m_updateScrollbarY = false;
3597 }
3598
3599 void wxTextCtrl::OnInternalIdle()
3600 {
3601 // notice that single line text control never has scrollbars
3602 if ( !IsSingleLine() &&
3603 (MData().m_updateScrollbarX || MData().m_updateScrollbarY) )
3604 {
3605 UpdateScrollbars();
3606 }
3607 wxControl::OnInternalIdle();
3608 }
3609
3610 bool wxTextCtrl::SendAutoScrollEvents(wxScrollWinEvent& event) const
3611 {
3612 bool forward = event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN;
3613 if ( event.GetOrientation() == wxHORIZONTAL )
3614 {
3615 return forward ? m_curCol <= GetLineLength(m_curRow) : m_curCol > 0;
3616 }
3617 else // wxVERTICAL
3618 {
3619 return forward ? m_curRow < GetNumberOfLines() : m_curRow > 0;
3620 }
3621 }
3622
3623 // ----------------------------------------------------------------------------
3624 // refresh
3625 // ----------------------------------------------------------------------------
3626
3627 void wxTextCtrl::RefreshSelection()
3628 {
3629 if ( HasSelection() )
3630 {
3631 RefreshTextRange(m_selStart, m_selEnd);
3632 }
3633 }
3634
3635 void wxTextCtrl::RefreshLineRange(wxTextCoord lineFirst, wxTextCoord lineLast)
3636 {
3637 wxASSERT_MSG( lineFirst <= lineLast || !lineLast,
3638 _T("no lines to refresh") );
3639
3640 wxRect rect;
3641 // rect.x is already 0
3642 rect.width = m_rectText.width;
3643 wxCoord h = GetLineHeight();
3644
3645 wxTextCoord rowFirst;
3646 if ( lineFirst < GetNumberOfLines() )
3647 {
3648 rowFirst = GetFirstRowOfLine(lineFirst);
3649 }
3650 else // lineFirst == GetNumberOfLines()
3651 {
3652 // lineFirst may be beyond the last line only if we refresh till
3653 // the end, otherwise it's illegal
3654 wxASSERT_MSG( lineFirst == GetNumberOfLines() && !lineLast,
3655 _T("invalid line range") );
3656
3657 rowFirst = GetRowAfterLine(lineFirst - 1);
3658 }
3659
3660 rect.y = rowFirst*h;
3661
3662 if ( lineLast )
3663 {
3664 // refresh till this line (inclusive)
3665 wxTextCoord rowLast = GetRowAfterLine(lineLast);
3666
3667 rect.height = (rowLast - rowFirst + 1)*h;
3668 }
3669 else // lineLast == 0 means to refresh till the end
3670 {
3671 // FIXME: calc it exactly
3672 rect.height = 32000;
3673 }
3674
3675 RefreshTextRect(rect);
3676 }
3677
3678 void wxTextCtrl::RefreshTextRange(wxTextPos start, wxTextPos end)
3679 {
3680 wxCHECK_RET( start != -1 && end != -1,
3681 _T("invalid RefreshTextRange() arguments") );
3682
3683 // accept arguments in any order as it is more conenient for the caller
3684 OrderPositions(start, end);
3685
3686 // this is acceptable but we don't do anything in this case
3687 if ( start == end )
3688 return;
3689
3690 wxTextPos colStart, lineStart;
3691 if ( !PositionToXY(start, &colStart, &lineStart) )
3692 {
3693 // the range is entirely beyond the end of the text, nothing to do
3694 return;
3695 }
3696
3697 wxTextCoord colEnd, lineEnd;
3698 if ( !PositionToXY(end, &colEnd, &lineEnd) )
3699 {
3700 // the range spans beyond the end of text, refresh to the end
3701 colEnd = -1;
3702 lineEnd = GetNumberOfLines() - 1;
3703 }
3704
3705 // refresh all lines one by one
3706 for ( wxTextCoord line = lineStart; line <= lineEnd; line++ )
3707 {
3708 // refresh the first line from the start of the range to the end, the
3709 // intermediate ones entirely and the last one from the beginning to
3710 // the end of the range
3711 wxTextPos posStart = line == lineStart ? colStart : 0;
3712 size_t posCount;
3713 if ( (line != lineEnd) || (colEnd == -1) )
3714 {
3715 // intermediate line or the last one but we need to refresh it
3716 // until the end anyhow - do it
3717 posCount = wxSTRING_MAXLEN;
3718 }
3719 else // last line
3720 {
3721 // refresh just the positions in between the start and the end one
3722 posCount = colEnd - posStart;
3723 }
3724
3725 if ( posCount )
3726 RefreshColRange(line, posStart, posCount);
3727 }
3728 }
3729
3730 void wxTextCtrl::RefreshColRange(wxTextCoord line,
3731 wxTextPos start,
3732 size_t count)
3733 {
3734 wxString text = GetLineText(line);
3735
3736 wxASSERT_MSG( (size_t)start <= text.length() && count,
3737 _T("invalid RefreshColRange() parameter") );
3738
3739 RefreshPixelRange(line,
3740 GetTextWidth(text.Left((size_t)start)),
3741 GetTextWidth(text.Mid((size_t)start, (size_t)count)));
3742 }
3743
3744 // this method accepts "logical" coords in the sense that they are coordinates
3745 // in a logical line but it can span several rows if we wrap lines and
3746 // RefreshPixelRange() will then refresh several rows
3747 void wxTextCtrl::RefreshPixelRange(wxTextCoord line,
3748 wxCoord start,
3749 wxCoord width)
3750 {
3751 // we will use line text only in line wrap case
3752 wxString text;
3753 if ( WrapLines() )
3754 {
3755 text = GetLineText(line);
3756 }
3757
3758 // special case: width == 0 means to refresh till the end of line
3759 if ( width == 0 )
3760 {
3761 // refresh till the end of visible line
3762 width = GetTotalWidth();
3763
3764 if ( WrapLines() )
3765 {
3766 // refresh till the end of text
3767 wxCoord widthAll = GetTextWidth(text);
3768
3769 // extend width to the end of ROW
3770 width = widthAll - widthAll % width + width;
3771 }
3772
3773 // no need to refresh beyond the end of line
3774 width -= start;
3775 }
3776 //else: just refresh the specified part
3777
3778 wxCoord h = GetLineHeight();
3779 wxRect rect;
3780 rect.x = start;
3781 rect.y = GetFirstRowOfLine(line)*h;
3782 rect.height = h;
3783
3784 if ( WrapLines() )
3785 {
3786 // (1) skip all rows which we don't touch at all
3787 const wxWrappedLineData& lineData = WData().m_linesData[line];
3788 if ( !WData().IsValidLine(line) )
3789 LayoutLines(line);
3790
3791 wxCoord wLine = 0; // suppress compiler warning about uninit var
3792 size_t rowLast = lineData.GetRowCount(),
3793 row = 0;
3794 while ( (row < rowLast) &&
3795 (rect.x > (wLine = lineData.GetRowWidth(row++))) )
3796 {
3797 rect.x -= wLine;
3798 rect.y += h;
3799 }
3800
3801 // (2) now refresh all lines except the last one: note that the first
3802 // line is refreshed from the given start to the end, all the next
3803 // ones - entirely
3804 while ( (row < rowLast) && (width > wLine - rect.x) )
3805 {
3806 rect.width = GetTotalWidth() - rect.x;
3807 RefreshTextRect(rect);
3808
3809 width -= wLine - rect.x;
3810 rect.x = 0;
3811 rect.y += h;
3812
3813 wLine = lineData.GetRowWidth(row++);
3814 }
3815
3816 // (3) the code below will refresh the last line
3817 }
3818
3819 rect.width = width;
3820
3821 RefreshTextRect(rect);
3822 }
3823
3824 void wxTextCtrl::RefreshTextRect(const wxRect& rectClient, bool textOnly)
3825 {
3826 wxRect rect;
3827 CalcScrolledPosition(rectClient.x, rectClient.y, &rect.x, &rect.y);
3828 rect.width = rectClient.width;
3829 rect.height = rectClient.height;
3830
3831 // account for the text area offset
3832 rect.Offset(m_rectText.GetPosition());
3833
3834 // don't refresh beyond the text area unless we're refreshing the line wrap
3835 // marks in which case textOnly is false
3836 if ( textOnly )
3837 {
3838 if ( rect.GetRight() > m_rectText.GetRight() )
3839 {
3840 rect.SetRight(m_rectText.GetRight());
3841
3842 if ( rect.width <= 0 )
3843 {
3844 // nothing to refresh
3845 return;
3846 }
3847 }
3848 }
3849
3850 // check the bottom boundary always, even for the line wrap marks
3851 if ( rect.GetBottom() > m_rectText.GetBottom() )
3852 {
3853 rect.SetBottom(m_rectText.GetBottom());
3854
3855 if ( rect.height <= 0 )
3856 {
3857 // nothing to refresh
3858 return;
3859 }
3860 }
3861
3862 // never refresh before the visible rect
3863 if ( rect.x < m_rectText.x )
3864 rect.x = m_rectText.x;
3865
3866 if ( rect.y < m_rectText.y )
3867 rect.y = m_rectText.y;
3868
3869 wxLogTrace(_T("text"), _T("Refreshing (%d, %d)-(%d, %d)"),
3870 rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
3871
3872 Refresh(true, &rect);
3873 }
3874
3875 void wxTextCtrl::RefreshLineWrapMarks(wxTextCoord rowFirst,
3876 wxTextCoord rowLast)
3877 {
3878 if ( WData().m_widthMark )
3879 {
3880 wxRect rectMarks;
3881 rectMarks.x = m_rectText.width;
3882 rectMarks.width = WData().m_widthMark;
3883 rectMarks.y = rowFirst*GetLineHeight();
3884 rectMarks.height = (rowLast - rowFirst)*GetLineHeight();
3885
3886 RefreshTextRect(rectMarks, false /* don't limit to text area */);
3887 }
3888 }
3889
3890 // ----------------------------------------------------------------------------
3891 // border drawing
3892 // ----------------------------------------------------------------------------
3893
3894 void wxTextCtrl::DoDrawBorder(wxDC& dc, const wxRect& rect)
3895 {
3896 m_renderer->DrawTextBorder(dc, GetBorder(), rect, GetStateFlags());
3897 }
3898
3899 // ----------------------------------------------------------------------------
3900 // client area drawing
3901 // ----------------------------------------------------------------------------
3902
3903 /*
3904 Several remarks about wxTextCtrl redraw logic:
3905
3906 1. only the regions which must be updated are redrawn, this means that we
3907 never Refresh() the entire window but use RefreshPixelRange() and
3908 ScrollWindow() which only refresh small parts of it and iterate over the
3909 update region in our DoDraw()
3910
3911 2. the text displayed on the screen is obtained using GetTextToShow(): it
3912 should be used for all drawing/measuring
3913 */
3914
3915 wxString wxTextCtrl::GetTextToShow(const wxString& text) const
3916 {
3917 wxString textShown;
3918 if ( IsPassword() )
3919 textShown = wxString(_T('*'), text.length());
3920 else
3921 textShown = text;
3922
3923 return textShown;
3924 }
3925
3926 void wxTextCtrl::DoDrawTextInRect(wxDC& dc, const wxRect& rectUpdate)
3927 {
3928 // debugging trick to see the update rect visually
3929 #ifdef WXDEBUG_TEXT
3930 static int s_countUpdates = -1;
3931 if ( s_countUpdates != -1 )
3932 {
3933 wxWindowDC dc(this);
3934 dc.SetBrush(*(++s_countUpdates % 2 ? wxRED_BRUSH : wxGREEN_BRUSH));
3935 dc.SetPen(*wxTRANSPARENT_PEN);
3936 dc.DrawRectangle(rectUpdate);
3937 }
3938 #endif // WXDEBUG_TEXT
3939
3940 // calculate the range lineStart..lineEnd of lines to redraw
3941 wxTextCoord lineStart, lineEnd;
3942 if ( IsSingleLine() )
3943 {
3944 lineStart =
3945 lineEnd = 0;
3946 }
3947 else // multiline
3948 {
3949 wxPoint pt = rectUpdate.GetPosition();
3950 (void)HitTest(pt, NULL, &lineStart);
3951
3952 pt.y += rectUpdate.height;
3953 (void)HitTest(pt, NULL, &lineEnd);
3954 }
3955
3956 // prepare for drawing
3957 wxCoord hLine = GetLineHeight();
3958
3959 // these vars will be used for hit testing of the current row
3960 wxCoord y = rectUpdate.y;
3961 const wxCoord x1 = rectUpdate.x;
3962 const wxCoord x2 = rectUpdate.x + rectUpdate.width;
3963
3964 wxRect rectText;
3965 rectText.height = hLine;
3966 wxCoord yClient = y - GetClientAreaOrigin().y;
3967
3968 // we want to always start at the top of the line, otherwise if we redraw a
3969 // rect whose top is in the middle of a line, we'd draw this line shifted
3970 yClient -= (yClient - m_rectText.y) % hLine;
3971
3972 if ( IsSingleLine() )
3973 {
3974 rectText.y = yClient;
3975 }
3976 else // multiline, adjust for scrolling
3977 {
3978 CalcUnscrolledPosition(0, yClient, NULL, &rectText.y);
3979 }
3980
3981 wxRenderer *renderer = GetRenderer();
3982
3983 // do draw the invalidated parts of each line: note that we iterate here
3984 // over ROWs, not over LINEs
3985 for ( wxTextCoord line = lineStart;
3986 y < rectUpdate.y + rectUpdate.height;
3987 y += hLine,
3988 rectText.y += hLine )
3989 {
3990 // calculate the update rect in text positions for this line
3991 wxTextCoord colStart, colEnd, colRowStart;
3992 wxTextCtrlHitTestResult ht = HitTest2(y, x1, x2,
3993 &line, &colStart, &colEnd,
3994 &colRowStart);
3995
3996 if ( (ht == wxTE_HT_BEYOND) || (ht == wxTE_HT_BELOW) )
3997 {
3998 wxASSERT_MSG( line <= lineEnd, _T("how did we get that far?") );
3999
4000 if ( line == lineEnd )
4001 {
4002 // we redrew everything
4003 break;
4004 }
4005
4006 // the update rect is beyond the end of line, no need to redraw
4007 // anything on this line - but continue with the remaining ones
4008 continue;
4009 }
4010
4011 // for single line controls we may additionally cut off everything
4012 // which is to the right of the last visible position
4013 if ( IsSingleLine() )
4014 {
4015 // don't show the columns which are scrolled out to the left
4016 if ( colStart < SData().m_colStart )
4017 colStart = SData().m_colStart;
4018
4019 // colEnd may be less than colStart if colStart was changed by the
4020 // assignment above
4021 if ( colEnd < colStart )
4022 colEnd = colStart;
4023
4024 // don't draw the chars beyond the rightmost one
4025 if ( SData().m_colLastVisible == -1 )
4026 {
4027 // recalculate this rightmost column
4028 UpdateLastVisible();
4029 }
4030
4031 if ( colStart > SData().m_colLastVisible )
4032 {
4033 // don't bother redrawing something that is beyond the last
4034 // visible position
4035 continue;
4036 }
4037
4038 if ( colEnd > SData().m_colLastVisible )
4039 {
4040 colEnd = SData().m_colLastVisible;
4041 }
4042 }
4043
4044 // extract the part of line we need to redraw
4045 wxString textLine = GetTextToShow(GetLineText(line));
4046 wxString text = textLine.Mid(colStart, colEnd - colStart + 1);
4047
4048 // now deal with the selection: only do something if at least part of
4049 // the line is selected
4050 wxTextPos selStart, selEnd;
4051 if ( GetSelectedPartOfLine(line, &selStart, &selEnd) )
4052 {
4053 // and if this part is (at least partly) in the current row
4054 if ( (selStart <= colEnd) &&
4055 (selEnd >= wxMax(colStart, colRowStart)) )
4056 {
4057 // these values are relative to the start of the line while the
4058 // string passed to DrawTextLine() is only part of it, so
4059 // adjust the selection range accordingly
4060 selStart -= colStart;
4061 selEnd -= colStart;
4062
4063 if ( selStart < 0 )
4064 selStart = 0;
4065
4066 if ( (size_t)selEnd >= text.length() )
4067 selEnd = text.length();
4068 }
4069 else
4070 {
4071 // reset selStart and selEnd to avoid passing them to
4072 // DrawTextLine() below
4073 selStart =
4074 selEnd = -1;
4075 }
4076 }
4077
4078 // calculate the text coords on screen
4079 wxASSERT_MSG( colStart >= colRowStart, _T("invalid string part") );
4080 wxCoord ofsStart = GetTextWidth(
4081 textLine.Mid(colRowStart,
4082 colStart - colRowStart));
4083 rectText.x = m_rectText.x + ofsStart;
4084 rectText.width = GetTextWidth(text);
4085
4086 // do draw the text
4087 renderer->DrawTextLine(dc, text, rectText, selStart, selEnd,
4088 GetStateFlags());
4089 wxLogTrace(_T("text"), _T("Line %ld: positions %ld-%ld redrawn."),
4090 line, colStart, colEnd);
4091 }
4092 }
4093
4094 void wxTextCtrl::DoDrawLineWrapMarks(wxDC& dc, const wxRect& rectUpdate)
4095 {
4096 wxASSERT_MSG( WrapLines() && WData().m_widthMark,
4097 _T("shouldn't be called at all") );
4098
4099 wxRenderer *renderer = GetRenderer();
4100
4101 wxRect rectMark;
4102 rectMark.x = rectUpdate.x;
4103 rectMark.width = rectUpdate.width;
4104 wxCoord yTop = GetClientAreaOrigin().y;
4105 CalcUnscrolledPosition(0, rectUpdate.y - yTop, NULL, &rectMark.y);
4106 wxCoord hLine = GetLineHeight();
4107 rectMark.height = hLine;
4108
4109 wxTextCoord line, rowInLine;
4110
4111 wxCoord yBottom;
4112 CalcUnscrolledPosition(0, rectUpdate.GetBottom() - yTop, NULL, &yBottom);
4113 for ( ; rectMark.y < yBottom; rectMark.y += hLine )
4114 {
4115 if ( !GetLineAndRow(rectMark.y / hLine, &line, &rowInLine) )
4116 {
4117 // we went beyond the end of text
4118 break;
4119 }
4120
4121 // is this row continued on the next one?
4122 if ( !WData().m_linesData[line].IsLastRow(rowInLine) )
4123 {
4124 renderer->DrawLineWrapMark(dc, rectMark);
4125 }
4126 }
4127 }
4128
4129 void wxTextCtrl::DoDraw(wxControlRenderer *renderer)
4130 {
4131 // hide the caret while we're redrawing the window and show it after we are
4132 // done with it
4133 wxCaretSuspend cs(this);
4134
4135 // prepare the DC
4136 wxDC& dc = renderer->GetDC();
4137 dc.SetFont(GetFont());
4138 dc.SetTextForeground(GetForegroundColour());
4139
4140 // get the intersection of the update region with the text area: note that
4141 // the update region is in window coords and text area is in the client
4142 // ones, so it must be shifted before computing intersection
4143 wxRegion rgnUpdate = GetUpdateRegion();
4144
4145 wxRect rectTextArea = GetRealTextArea();
4146 wxPoint pt = GetClientAreaOrigin();
4147 wxRect rectTextAreaAdjusted = rectTextArea;
4148 rectTextAreaAdjusted.x += pt.x;
4149 rectTextAreaAdjusted.y += pt.y;
4150 rgnUpdate.Intersect(rectTextAreaAdjusted);
4151
4152 // even though the drawing is already clipped to the update region, we must
4153 // explicitly clip it to the rect we will use as otherwise parts of letters
4154 // might be drawn outside of it (if even a small part of a charater is
4155 // inside, HitTest() will return its column and DrawText() can't draw only
4156 // the part of the character, of course)
4157 #ifdef __WXMSW__
4158 // FIXME: is this really a bug in wxMSW?
4159 rectTextArea.width--;
4160 #endif // __WXMSW__
4161 dc.SetClippingRegion(rectTextArea);
4162
4163 // adjust for scrolling
4164 DoPrepareDC(dc);
4165
4166 // and now refresh the invalidated parts of the window
4167 wxRegionIterator iter(rgnUpdate);
4168 for ( ; iter.HaveRects(); iter++ )
4169 {
4170 wxRect r = iter.GetRect();
4171
4172 // this is a workaround for wxGTK::wxRegion bug
4173 #ifdef __WXGTK__
4174 if ( !r.width || !r.height )
4175 {
4176 // ignore invalid rect
4177 continue;
4178 }
4179 #endif // __WXGTK__
4180
4181 DoDrawTextInRect(dc, r);
4182 }
4183
4184 // now redraw the line wrap marks (if we draw them)
4185 if ( WrapLines() && WData().m_widthMark )
4186 {
4187 // this is the rect inside which line wrap marks are drawn
4188 wxRect rectMarks;
4189 rectMarks.x = rectTextAreaAdjusted.GetRight() + 1;
4190 rectMarks.y = rectTextAreaAdjusted.y;
4191 rectMarks.width = WData().m_widthMark;
4192 rectMarks.height = rectTextAreaAdjusted.height;
4193
4194 rgnUpdate = GetUpdateRegion();
4195 rgnUpdate.Intersect(rectMarks);
4196
4197 wxRect rectUpdate = rgnUpdate.GetBox();
4198 if ( rectUpdate.width && rectUpdate.height )
4199 {
4200 // the marks are outside previously set clipping region
4201 dc.DestroyClippingRegion();
4202
4203 DoDrawLineWrapMarks(dc, rectUpdate);
4204 }
4205 }
4206
4207 // show caret first time only: we must show it after drawing the text or
4208 // the display can be corrupted when it's hidden
4209 if ( !m_hasCaret && GetCaret() && (FindFocus() == this) )
4210 {
4211 ShowCaret();
4212
4213 m_hasCaret = true;
4214 }
4215 }
4216
4217 // ----------------------------------------------------------------------------
4218 // caret
4219 // ----------------------------------------------------------------------------
4220
4221 bool wxTextCtrl::SetFont(const wxFont& font)
4222 {
4223 if ( !wxControl::SetFont(font) )
4224 return false;
4225
4226 // and refresh everything, of course
4227 InitInsertionPoint();
4228 ClearSelection();
4229
4230 // update geometry parameters
4231 UpdateTextRect();
4232 RecalcFontMetrics();
4233 if ( !IsSingleLine() )
4234 {
4235 UpdateScrollbars();
4236 RecalcMaxWidth();
4237 }
4238
4239 // recreate it, in fact
4240 CreateCaret();
4241
4242 Refresh();
4243
4244 return true;
4245 }
4246
4247 bool wxTextCtrl::Enable(bool enable)
4248 {
4249 if ( !wxTextCtrlBase::Enable(enable) )
4250 return false;
4251
4252 if (FindFocus() == this && GetCaret() &&
4253 ((enable && !GetCaret()->IsVisible()) ||
4254 (!enable && GetCaret()->IsVisible())))
4255 ShowCaret(enable);
4256
4257 return true;
4258 }
4259
4260 void wxTextCtrl::CreateCaret()
4261 {
4262 wxCaret *caret;
4263
4264 if ( IsEditable() )
4265 {
4266 // FIXME use renderer
4267 caret = new wxCaret(this, 1, GetLineHeight());
4268 #ifndef __WXMSW__
4269 caret->SetBlinkTime(0);
4270 #endif // __WXMSW__
4271 }
4272 else
4273 {
4274 // read only controls don't have the caret
4275 caret = (wxCaret *)NULL;
4276 }
4277
4278 // SetCaret() will delete the old caret if any
4279 SetCaret(caret);
4280 }
4281
4282 void wxTextCtrl::ShowCaret(bool show)
4283 {
4284 wxCaret *caret = GetCaret();
4285 if ( caret )
4286 {
4287 // (re)position caret correctly
4288 caret->Move(GetCaretPosition());
4289
4290 // and show it there
4291 if ((show && !caret->IsVisible()) ||
4292 (!show && caret->IsVisible()))
4293 caret->Show(show);
4294 }
4295 }
4296
4297 // ----------------------------------------------------------------------------
4298 // vertical scrolling (multiline only)
4299 // ----------------------------------------------------------------------------
4300
4301 size_t wxTextCtrl::GetLinesPerPage() const
4302 {
4303 if ( IsSingleLine() )
4304 return 1;
4305
4306 return GetRealTextArea().height / GetLineHeight();
4307 }
4308
4309 wxTextPos wxTextCtrl::GetPositionAbove()
4310 {
4311 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE,
4312 _T("can't move cursor vertically in a single line control") );
4313
4314 // move the cursor up by one ROW not by one LINE: this means that
4315 // we should really use HitTest() and not just go to the same
4316 // position in the previous line
4317 wxPoint pt = GetCaretPosition() - m_rectText.GetPosition();
4318 if ( MData().m_xCaret == -1 )
4319 {
4320 // remember the initial cursor abscissa
4321 MData().m_xCaret = pt.x;
4322 }
4323 else
4324 {
4325 // use the remembered abscissa
4326 pt.x = MData().m_xCaret;
4327 }
4328
4329 CalcUnscrolledPosition(pt.x, pt.y, &pt.x, &pt.y);
4330 pt.y -= GetLineHeight();
4331
4332 wxTextCoord col, row;
4333 if ( HitTestLogical(pt, &col, &row) == wxTE_HT_BEFORE )
4334 {
4335 // can't move further
4336 return INVALID_POS_VALUE;
4337 }
4338
4339 return XYToPosition(col, row);
4340 }
4341
4342 wxTextPos wxTextCtrl::GetPositionBelow()
4343 {
4344 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE,
4345 _T("can't move cursor vertically in a single line control") );
4346
4347 // see comments for wxACTION_TEXT_UP
4348 wxPoint pt = GetCaretPosition() - m_rectText.GetPosition();
4349 if ( MData().m_xCaret == -1 )
4350 {
4351 // remember the initial cursor abscissa
4352 MData().m_xCaret = pt.x;
4353 }
4354 else
4355 {
4356 // use the remembered abscissa
4357 pt.x = MData().m_xCaret;
4358 }
4359
4360 CalcUnscrolledPosition(pt.x, pt.y, &pt.x, &pt.y);
4361 pt.y += GetLineHeight();
4362
4363 wxTextCoord col, row;
4364 if ( HitTestLogical(pt, &col, &row) == wxTE_HT_BELOW )
4365 {
4366 // can't go further down
4367 return INVALID_POS_VALUE;
4368 }
4369
4370 // note that wxTE_HT_BEYOND is ok: it happens when we go down
4371 // from a longer line to a shorter one, for example (OTOH
4372 // wxTE_HT_BEFORE can never happen)
4373 return XYToPosition(col, row);
4374 }
4375
4376 // ----------------------------------------------------------------------------
4377 // input
4378 // ----------------------------------------------------------------------------
4379
4380 bool wxTextCtrl::PerformAction(const wxControlAction& actionOrig,
4381 long numArg,
4382 const wxString& strArg)
4383 {
4384 // has the text changed as result of this action?
4385 bool textChanged = false;
4386
4387 // the remembered cursor abscissa for multiline text controls is usually
4388 // reset after each user action but for ones which do use it (UP and DOWN
4389 // for example) we shouldn't do it - as indicated by this flag
4390 bool rememberAbscissa = false;
4391
4392 // the command this action corresponds to or NULL if this action doesn't
4393 // change text at all or can't be undone
4394 wxTextCtrlCommand *command = (wxTextCtrlCommand *)NULL;
4395
4396 wxString action;
4397 bool del = false,
4398 sel = false;
4399 if ( actionOrig.StartsWith(wxACTION_TEXT_PREFIX_DEL, &action) )
4400 {
4401 if ( IsEditable() )
4402 del = true;
4403 }
4404 else if ( actionOrig.StartsWith(wxACTION_TEXT_PREFIX_SEL, &action) )
4405 {
4406 sel = true;
4407 }
4408 else // not selection nor delete action
4409 {
4410 action = actionOrig;
4411 }
4412
4413 // set newPos to -2 as it can't become equal to it in the assignments below
4414 // (but it can become -1)
4415 wxTextPos newPos = INVALID_POS_VALUE;
4416
4417 if ( action == wxACTION_TEXT_HOME )
4418 {
4419 newPos = m_curPos - m_curCol;
4420 }
4421 else if ( action == wxACTION_TEXT_END )
4422 {
4423 newPos = m_curPos + GetLineLength(m_curRow) - m_curCol;
4424 }
4425 else if ( (action == wxACTION_TEXT_GOTO) ||
4426 (action == wxACTION_TEXT_FIRST) ||
4427 (action == wxACTION_TEXT_LAST) )
4428 {
4429 if ( action == wxACTION_TEXT_FIRST )
4430 numArg = 0;
4431 else if ( action == wxACTION_TEXT_LAST )
4432 numArg = GetLastPosition();
4433 //else: numArg already contains the position
4434
4435 newPos = numArg;
4436 }
4437 else if ( action == wxACTION_TEXT_UP )
4438 {
4439 if ( !IsSingleLine() )
4440 {
4441 newPos = GetPositionAbove();
4442
4443 if ( newPos != INVALID_POS_VALUE )
4444 {
4445 // remember where the cursor original had been
4446 rememberAbscissa = true;
4447 }
4448 }
4449 }
4450 else if ( action == wxACTION_TEXT_DOWN )
4451 {
4452 if ( !IsSingleLine() )
4453 {
4454 newPos = GetPositionBelow();
4455
4456 if ( newPos != INVALID_POS_VALUE )
4457 {
4458 // remember where the cursor original had been
4459 rememberAbscissa = true;
4460 }
4461 }
4462 }
4463 else if ( action == wxACTION_TEXT_LEFT )
4464 {
4465 newPos = m_curPos - 1;
4466 }
4467 else if ( action == wxACTION_TEXT_WORD_LEFT )
4468 {
4469 newPos = GetWordStart();
4470 }
4471 else if ( action == wxACTION_TEXT_RIGHT )
4472 {
4473 newPos = m_curPos + 1;
4474 }
4475 else if ( action == wxACTION_TEXT_WORD_RIGHT )
4476 {
4477 newPos = GetWordEnd();
4478 }
4479 else if ( action == wxACTION_TEXT_INSERT )
4480 {
4481 if ( IsEditable() && !strArg.empty() )
4482 {
4483 // inserting text can be undone
4484 command = new wxTextCtrlInsertCommand(strArg);
4485
4486 textChanged = true;
4487 }
4488 }
4489 else if ( (action == wxACTION_TEXT_PAGE_UP) ||
4490 (action == wxACTION_TEXT_PAGE_DOWN) )
4491 {
4492 if ( !IsSingleLine() )
4493 {
4494 size_t count = GetLinesPerPage();
4495 if ( count > PAGE_OVERLAP_IN_LINES )
4496 {
4497 // pages should overlap slightly to allow the reader to keep
4498 // orientation in the text
4499 count -= PAGE_OVERLAP_IN_LINES;
4500 }
4501
4502 // remember where the cursor original had been
4503 rememberAbscissa = true;
4504
4505 bool goUp = action == wxACTION_TEXT_PAGE_UP;
4506 for ( size_t line = 0; line < count; line++ )
4507 {
4508 wxTextPos pos = goUp ? GetPositionAbove() : GetPositionBelow();
4509 if ( pos == INVALID_POS_VALUE )
4510 {
4511 // can't move further
4512 break;
4513 }
4514
4515 MoveInsertionPoint(pos);
4516 newPos = pos;
4517 }
4518
4519 // we implement the Unix scrolling model here: cursor will always
4520 // be on the first line after Page Down and on the last one after
4521 // Page Up
4522 //
4523 // Windows programs usually keep the cursor line offset constant
4524 // but do we really need it?
4525 wxCoord y;
4526 if ( goUp )
4527 {
4528 // find the line such that when it is the first one, the
4529 // current position is in the last line
4530 wxTextPos pos = 0;
4531 for ( size_t line = 0; line < count; line++ )
4532 {
4533 pos = GetPositionAbove();
4534 if ( pos == INVALID_POS_VALUE )
4535 break;
4536
4537 MoveInsertionPoint(pos);
4538 }
4539
4540 MoveInsertionPoint(newPos);
4541
4542 PositionToLogicalXY(pos, NULL, &y);
4543 }
4544 else // scrolled down
4545 {
4546 PositionToLogicalXY(newPos, NULL, &y);
4547 }
4548
4549 // scroll vertically only
4550 Scroll(wxDefaultCoord, y);
4551 }
4552 }
4553 else if ( action == wxACTION_TEXT_SEL_WORD )
4554 {
4555 SetSelection(GetWordStart(), GetWordEnd());
4556 }
4557 else if ( action == wxACTION_TEXT_ANCHOR_SEL )
4558 {
4559 newPos = numArg;
4560 }
4561 else if ( action == wxACTION_TEXT_EXTEND_SEL )
4562 {
4563 SetSelection(m_selAnchor, numArg);
4564 }
4565 else if ( action == wxACTION_TEXT_COPY )
4566 {
4567 Copy();
4568 }
4569 else if ( action == wxACTION_TEXT_CUT )
4570 {
4571 if ( IsEditable() )
4572 Cut();
4573 }
4574 else if ( action == wxACTION_TEXT_PASTE )
4575 {
4576 if ( IsEditable() )
4577 Paste();
4578 }
4579 else if ( action == wxACTION_TEXT_UNDO )
4580 {
4581 if ( CanUndo() )
4582 Undo();
4583 }
4584 else if ( action == wxACTION_TEXT_REDO )
4585 {
4586 if ( CanRedo() )
4587 Redo();
4588 }
4589 else
4590 {
4591 return wxControl::PerformAction(action, numArg, strArg);
4592 }
4593
4594 if ( newPos != INVALID_POS_VALUE )
4595 {
4596 // bring the new position into the range
4597 if ( newPos < 0 )
4598 newPos = 0;
4599
4600 wxTextPos posLast = GetLastPosition();
4601 if ( newPos > posLast )
4602 newPos = posLast;
4603
4604 if ( del )
4605 {
4606 // if we have the selection, remove just it
4607 wxTextPos from, to;
4608 if ( HasSelection() )
4609 {
4610 from = m_selStart;
4611 to = m_selEnd;
4612 }
4613 else
4614 {
4615 // otherwise delete everything between current position and
4616 // the new one
4617 if ( m_curPos != newPos )
4618 {
4619 from = m_curPos;
4620 to = newPos;
4621 }
4622 else // nothing to delete
4623 {
4624 // prevent test below from working
4625 from = INVALID_POS_VALUE;
4626
4627 // and this is just to silent the compiler warning
4628 to = 0;
4629 }
4630 }
4631
4632 if ( from != INVALID_POS_VALUE )
4633 {
4634 command = new wxTextCtrlRemoveCommand(from, to);
4635 }
4636 }
4637 else // cursor movement command
4638 {
4639 // just go there
4640 DoSetInsertionPoint(newPos);
4641
4642 if ( sel )
4643 {
4644 SetSelection(m_selAnchor, m_curPos);
4645 }
4646 else // simple movement
4647 {
4648 // clear the existing selection
4649 ClearSelection();
4650 }
4651 }
4652
4653 if ( !rememberAbscissa && !IsSingleLine() )
4654 {
4655 MData().m_xCaret = -1;
4656 }
4657 }
4658
4659 if ( command )
4660 {
4661 // execute and remember it to be able to undo it later
4662 m_cmdProcessor->Submit(command);
4663
4664 // undoable commands always change text
4665 textChanged = true;
4666 }
4667 else // no undoable command
4668 {
4669 // m_cmdProcessor->StopCompressing()
4670 }
4671
4672 if ( textChanged )
4673 {
4674 wxASSERT_MSG( IsEditable(), _T("non editable control changed?") );
4675
4676 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
4677 InitCommandEvent(event);
4678 GetEventHandler()->ProcessEvent(event);
4679
4680 // as the text changed...
4681 m_isModified = true;
4682 }
4683
4684 return true;
4685 }
4686
4687 void wxTextCtrl::OnChar(wxKeyEvent& event)
4688 {
4689 // only process the key events from "simple keys" here
4690 if ( !event.HasModifiers() )
4691 {
4692 int keycode = event.GetKeyCode();
4693 if ( keycode == WXK_RETURN )
4694 {
4695 if ( IsSingleLine() || (GetWindowStyle() & wxTE_PROCESS_ENTER) )
4696 {
4697 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, GetId());
4698 InitCommandEvent(event);
4699 event.SetString(GetValue());
4700 GetEventHandler()->ProcessEvent(event);
4701 }
4702 else // interpret <Enter> normally: insert new line
4703 {
4704 PerformAction(wxACTION_TEXT_INSERT, -1, _T('\n'));
4705 }
4706 }
4707 else if ( keycode < 255 && isprint(keycode) )
4708 {
4709 PerformAction(wxACTION_TEXT_INSERT, -1, (wxChar)keycode);
4710
4711 // skip event.Skip() below
4712 return;
4713 }
4714 }
4715 #ifdef __WXDEBUG__
4716 // Ctrl-R refreshes the control in debug mode
4717 else if ( event.ControlDown() && event.GetKeyCode() == 'r' )
4718 Refresh();
4719 #endif // __WXDEBUG__
4720
4721 event.Skip();
4722 }
4723
4724 // ----------------------------------------------------------------------------
4725 // wxStdTextCtrlInputHandler
4726 // ----------------------------------------------------------------------------
4727
4728 wxStdTextCtrlInputHandler::wxStdTextCtrlInputHandler(wxInputHandler *inphand)
4729 : wxStdInputHandler(inphand)
4730 {
4731 m_winCapture = (wxTextCtrl *)NULL;
4732 }
4733
4734 /* static */
4735 wxTextPos wxStdTextCtrlInputHandler::HitTest(const wxTextCtrl *text,
4736 const wxPoint& pt)
4737 {
4738 wxTextCoord col, row;
4739 wxTextCtrlHitTestResult ht = text->HitTest(pt, &col, &row);
4740
4741 wxTextPos pos = text->XYToPosition(col, row);
4742
4743 // if the point is after the last column we must adjust the position to be
4744 // the last position in the line (unless it is already the last)
4745 if ( (ht == wxTE_HT_BEYOND) && (pos < text->GetLastPosition()) )
4746 {
4747 pos++;
4748 }
4749
4750 return pos;
4751 }
4752
4753 bool wxStdTextCtrlInputHandler::HandleKey(wxInputConsumer *consumer,
4754 const wxKeyEvent& event,
4755 bool pressed)
4756 {
4757 // we're only interested in key presses
4758 if ( !pressed )
4759 return false;
4760
4761 int keycode = event.GetKeyCode();
4762
4763 wxControlAction action;
4764 wxString str;
4765 bool ctrlDown = event.ControlDown(),
4766 shiftDown = event.ShiftDown();
4767 if ( shiftDown )
4768 {
4769 action = wxACTION_TEXT_PREFIX_SEL;
4770 }
4771
4772 // the only key combination with Alt we recognize is Alt-Bksp for undo, so
4773 // treat it first separately
4774 if ( event.AltDown() )
4775 {
4776 if ( keycode == WXK_BACK && !ctrlDown && !shiftDown )
4777 action = wxACTION_TEXT_UNDO;
4778 }
4779 else switch ( keycode )
4780 {
4781 // cursor movement
4782 case WXK_HOME:
4783 action << (ctrlDown ? wxACTION_TEXT_FIRST
4784 : wxACTION_TEXT_HOME);
4785 break;
4786
4787 case WXK_END:
4788 action << (ctrlDown ? wxACTION_TEXT_LAST
4789 : wxACTION_TEXT_END);
4790 break;
4791
4792 case WXK_UP:
4793 if ( !ctrlDown )
4794 action << wxACTION_TEXT_UP;
4795 break;
4796
4797 case WXK_DOWN:
4798 if ( !ctrlDown )
4799 action << wxACTION_TEXT_DOWN;
4800 break;
4801
4802 case WXK_LEFT:
4803 action << (ctrlDown ? wxACTION_TEXT_WORD_LEFT
4804 : wxACTION_TEXT_LEFT);
4805 break;
4806
4807 case WXK_RIGHT:
4808 action << (ctrlDown ? wxACTION_TEXT_WORD_RIGHT
4809 : wxACTION_TEXT_RIGHT);
4810 break;
4811
4812 case WXK_PAGEDOWN:
4813 case WXK_NEXT:
4814 // we don't map Ctrl-PgUp/Dn to anything special - what should it
4815 // to? for now, it's the same as without control
4816 action << wxACTION_TEXT_PAGE_DOWN;
4817 break;
4818
4819 case WXK_PAGEUP:
4820 case WXK_PRIOR:
4821 action << wxACTION_TEXT_PAGE_UP;
4822 break;
4823
4824 // delete
4825 case WXK_DELETE:
4826 if ( !ctrlDown )
4827 action << wxACTION_TEXT_PREFIX_DEL << wxACTION_TEXT_RIGHT;
4828 break;
4829
4830 case WXK_BACK:
4831 if ( !ctrlDown )
4832 action << wxACTION_TEXT_PREFIX_DEL << wxACTION_TEXT_LEFT;
4833 break;
4834
4835 // something else
4836 default:
4837 // reset the action as it could be already set to one of the
4838 // prefixes
4839 action = wxACTION_NONE;
4840
4841 if ( ctrlDown )
4842 {
4843 switch ( keycode )
4844 {
4845 case 'A':
4846 action = wxACTION_TEXT_REDO;
4847 break;
4848
4849 case 'C':
4850 action = wxACTION_TEXT_COPY;
4851 break;
4852
4853 case 'V':
4854 action = wxACTION_TEXT_PASTE;
4855 break;
4856
4857 case 'X':
4858 action = wxACTION_TEXT_CUT;
4859 break;
4860
4861 case 'Z':
4862 action = wxACTION_TEXT_UNDO;
4863 break;
4864 }
4865 }
4866 }
4867
4868 if ( (action != wxACTION_NONE) && (action != wxACTION_TEXT_PREFIX_SEL) )
4869 {
4870 consumer->PerformAction(action, -1, str);
4871
4872 return true;
4873 }
4874
4875 return wxStdInputHandler::HandleKey(consumer, event, pressed);
4876 }
4877
4878 bool wxStdTextCtrlInputHandler::HandleMouse(wxInputConsumer *consumer,
4879 const wxMouseEvent& event)
4880 {
4881 if ( event.LeftDown() )
4882 {
4883 wxASSERT_MSG( !m_winCapture, _T("left button going down twice?") );
4884
4885 wxTextCtrl *text = wxStaticCast(consumer->GetInputWindow(), wxTextCtrl);
4886
4887 m_winCapture = text;
4888 m_winCapture->CaptureMouse();
4889
4890 text->HideCaret();
4891
4892 wxTextPos pos = HitTest(text, event.GetPosition());
4893 if ( pos != -1 )
4894 {
4895 text->PerformAction(wxACTION_TEXT_ANCHOR_SEL, pos);
4896 }
4897 }
4898 else if ( event.LeftDClick() )
4899 {
4900 // select the word the cursor is on
4901 consumer->PerformAction(wxACTION_TEXT_SEL_WORD);
4902 }
4903 else if ( event.LeftUp() )
4904 {
4905 if ( m_winCapture )
4906 {
4907 m_winCapture->ShowCaret();
4908
4909 m_winCapture->ReleaseMouse();
4910 m_winCapture = (wxTextCtrl *)NULL;
4911 }
4912 }
4913
4914 return wxStdInputHandler::HandleMouse(consumer, event);
4915 }
4916
4917 bool wxStdTextCtrlInputHandler::HandleMouseMove(wxInputConsumer *consumer,
4918 const wxMouseEvent& event)
4919 {
4920 if ( m_winCapture )
4921 {
4922 // track it
4923 wxTextCtrl *text = wxStaticCast(m_winCapture, wxTextCtrl);
4924 wxTextPos pos = HitTest(text, event.GetPosition());
4925 if ( pos != -1 )
4926 {
4927 text->PerformAction(wxACTION_TEXT_EXTEND_SEL, pos);
4928 }
4929 }
4930
4931 return wxStdInputHandler::HandleMouseMove(consumer, event);
4932 }
4933
4934 bool
4935 wxStdTextCtrlInputHandler::HandleFocus(wxInputConsumer *consumer,
4936 const wxFocusEvent& event)
4937 {
4938 wxTextCtrl *text = wxStaticCast(consumer->GetInputWindow(), wxTextCtrl);
4939
4940 // the selection appearance changes depending on whether we have the focus
4941 text->RefreshSelection();
4942
4943 if (event.GetEventType() == wxEVT_SET_FOCUS)
4944 {
4945 if (text->GetCaret() && !text->GetCaret()->IsVisible())
4946 text->ShowCaret();
4947 }
4948 else
4949 {
4950 if (text->GetCaret() && text->GetCaret()->IsVisible())
4951 text->HideCaret();
4952 }
4953
4954 // never refresh entirely
4955 return false;
4956 }
4957
4958 #endif // wxUSE_TEXTCTRL