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