1 /////////////////////////////////////////////////////////////////////////////
2 // Name: univ/textctrl.cpp
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 2000 Vadim Zeitlin
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
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
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
25 6. backspace refreshes too much (until end of line)
29 Optimisation hints from PureQuantify:
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
36 For line wrapping controls HitTest2 takes 50% of program time. The results
37 of GetRowsPerLine and GetPartOfWrappedLine *MUST* be cached.
39 Search for "OPT!" for things which must be optimized.
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.
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.
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.
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.
65 An example of positions and lines/columns for a control without wrapping
66 containing the text "Hello, Universe!\nGoodbye"
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
80 The same example for a control with line wrap assuming "Universe" is too
81 long to fit on the same line with "Hello,":
84 H e l l o , line 0 (row 0)
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
93 (line 1 == row 2 same as above)
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).
103 Search for "OPT" for possible optimizations
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.
112 // ============================================================================
114 // ============================================================================
116 // ----------------------------------------------------------------------------
118 // ----------------------------------------------------------------------------
121 #pragma implementation "univtextctrl.h"
124 #include "wx/wxprec.h"
135 #include "wx/dcclient.h"
136 #include "wx/validate.h"
137 #include "wx/textctrl.h"
140 #include "wx/clipbrd.h"
142 #include "wx/textfile.h"
144 #include "wx/caret.h"
146 #include "wx/univ/inphand.h"
147 #include "wx/univ/renderer.h"
148 #include "wx/univ/colschem.h"
149 #include "wx/univ/theme.h"
151 #include "wx/cmdproc.h"
153 // turn extra wxTextCtrl-specific debugging on/off
156 // turn wxTextCtrl::Replace() debugging on (slows down code a *lot*!)
157 #define WXDEBUG_TEXT_REPLACE
161 #undef WXDEBUG_TEXT_REPLACE
164 // wxStringTokenize only needed for debug checks
165 #ifdef WXDEBUG_TEXT_REPLACE
166 #include "wx/tokenzr.h"
167 #endif // WXDEBUG_TEXT_REPLACE
169 // ----------------------------------------------------------------------------
171 // ----------------------------------------------------------------------------
173 // exchange two positions so that from is always less than or equal to to
174 static inline void OrderPositions(wxTextPos
& from
, wxTextPos
& to
)
178 wxTextPos tmp
= from
;
184 // ----------------------------------------------------------------------------
186 // ----------------------------------------------------------------------------
188 // names of text ctrl commands
189 #define wxTEXT_COMMAND_INSERT _T("insert")
190 #define wxTEXT_COMMAND_REMOVE _T("remove")
192 // the value which is never used for text position, even not -1 which is
193 // sometimes used for some special meaning
194 static const wxTextPos INVALID_POS_VALUE
= -2;
196 // overlap between pages (when using PageUp/Dn) in lines
197 static const size_t PAGE_OVERLAP_IN_LINES
= 1;
199 // ----------------------------------------------------------------------------
200 // private data of wxTextCtrl
201 // ----------------------------------------------------------------------------
203 // the data only used by single line text controls
204 struct WXDLLEXPORT wxTextSingleLineData
206 // the position of the first visible pixel and the first visible column
208 wxTextCoord m_colStart
;
210 // and the last ones (m_posLastVisible is the width but m_colLastVisible
211 // is an absolute value)
212 wxCoord m_posLastVisible
;
213 wxTextCoord m_colLastVisible
;
216 wxTextSingleLineData()
221 m_colLastVisible
= -1;
222 m_posLastVisible
= -1;
227 // the data only used by multi line text controls
228 struct WXDLLEXPORT wxTextMultiLineData
231 wxArrayString m_lines
;
233 // the current ranges of the scrollbars
237 // should we adjust the horz/vert scrollbar?
238 bool m_updateScrollbarX
,
241 // the max line length in pixels
244 // the index of the line which has the length of m_widthMax
245 wxTextCoord m_lineLongest
;
247 // the rect in which text appears: it is even less than m_rectText because
248 // only the last _complete_ line is shown, hence there is an unoccupied
249 // horizontal band at the bottom of it
250 wxRect m_rectTextReal
;
252 // the x-coordinate of the caret before we started moving it vertically:
253 // this is used to ensure that moving the caret up and then down will
254 // return it to the same position as if we always round it in one direction
255 // we would shift it in that direction
257 // when m_xCaret == -1, we don't have any remembered position
261 wxTextMultiLineData()
267 m_updateScrollbarY
= FALSE
;
276 // the data only used by multi line text controls in line wrap mode
277 class WXDLLEXPORT wxWrappedLineData
279 // these functions set all our values, so give them access to them
280 friend void wxTextCtrl::LayoutLine(wxTextCoord line
,
281 wxWrappedLineData
& lineData
) const;
282 friend void wxTextCtrl::LayoutLines(wxTextCoord
) const;
291 // get the start of any row (remember that accessing m_rowsStart doesn't work
292 // for the first one)
293 wxTextCoord
GetRowStart(wxTextCoord row
) const
295 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
297 return row
? m_rowsStart
[row
- 1] : 0;
300 // get the length of the row (using the total line length which we don't
301 // have here but need to calculate the length of the last row, so it must
303 wxTextCoord
GetRowLength(wxTextCoord row
, wxTextCoord lenLine
) const
305 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
307 // note that m_rowsStart[row] is the same as GetRowStart(row + 1) (but
308 // slightly more efficient) and lenLine is the same as the start of the
309 // first row of the next line
310 return ((size_t)row
== m_rowsStart
.GetCount() ? lenLine
: m_rowsStart
[row
])
314 // return the width of the row in pixels
315 wxCoord
GetRowWidth(wxTextCoord row
) const
317 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
319 return m_rowsWidth
[row
];
322 // return the number of rows
323 size_t GetRowCount() const
325 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
327 return m_rowsStart
.GetCount() + 1;
330 // return the number of additional (i.e. after the first one) rows
331 size_t GetExtraRowCount() const
333 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
335 return m_rowsStart
.GetCount();
338 // return the first row of this line
339 wxTextCoord
GetFirstRow() const
341 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
346 // return the first row of the next line
347 wxTextCoord
GetNextRow() const
349 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
351 return m_rowFirst
+ m_rowsStart
.GetCount() + 1;
354 // this just provides direct access to m_rowsStart aerray for efficiency
355 wxTextCoord
GetExtraRowStart(wxTextCoord row
) const
357 wxASSERT_MSG( IsValid(), _T("this line hadn't been laid out") );
359 return m_rowsStart
[row
];
362 // this code is unused any longer
364 // return TRUE if the column is in the start of the last row (hence the row
365 // it is in is not wrapped)
366 bool IsLastRow(wxTextCoord colRowStart
) const
368 return colRowStart
== GetRowStart(m_rowsStart
.GetCount());
371 // return TRUE if the column is the last column of the row starting in
373 bool IsLastColInRow(wxTextCoord colRowStart
,
374 wxTextCoord colRowEnd
,
375 wxTextCoord lenLine
) const
377 // find the row which starts with colRowStart
378 size_t nRows
= GetRowCount();
379 for ( size_t n
= 0; n
< nRows
; n
++ )
381 if ( GetRowStart(n
) == colRowStart
)
383 wxTextCoord colNextRowStart
= n
== nRows
- 1
385 : GetRowStart(n
+ 1);
387 wxASSERT_MSG( colRowEnd
< colNextRowStart
,
388 _T("this column is not in this row at all!") );
390 return colRowEnd
== colNextRowStart
- 1;
394 // caller got it wrong
395 wxFAIL_MSG( _T("this column is not in the start of the row!") );
401 // is this row the last one in its line?
402 bool IsLastRow(wxTextCoord row
) const
404 return (size_t)row
== GetExtraRowCount();
407 // the line is valid if it had been laid out correctly: note that just
408 // shiwting the line (because one of previous lines changed) doesn't make
410 bool IsValid() const { return !m_rowsWidth
.IsEmpty(); }
412 // invalidating line will relayout it
413 void Invalidate() { m_rowsWidth
.Empty(); }
416 // for each line we remember the starting columns of all its rows after the
417 // first one (which always starts at 0), i.e. if a line is wrapped twice
418 // (== takes 3 rows) its m_rowsStart[0] may be 10 and m_rowsStart[1] == 15
419 wxArrayLong m_rowsStart
;
421 // and the width of each row in pixels (this array starts from 0, as usual)
422 wxArrayInt m_rowsWidth
;
424 // and also its starting row (0 for the first line, first lines'
425 // m_rowsStart.GetCount() + 1 for the second &c): it is set to -1 initially
426 // and this means that the struct hadn't yet been initialized
427 wxTextCoord m_rowFirst
;
429 // the last modification "time"-stamp used by LayoutLines()
433 WX_DECLARE_OBJARRAY(wxWrappedLineData
, wxArrayWrappedLinesData
);
434 #include "wx/arrimpl.cpp"
435 WX_DEFINE_OBJARRAY(wxArrayWrappedLinesData
);
437 struct WXDLLEXPORT wxTextWrappedData
: public wxTextMultiLineData
439 // the width of the column to the right of the text rect used for the
440 // indicator mark display for the wrapped lines
443 // the data for each line
444 wxArrayWrappedLinesData m_linesData
;
446 // flag telling us to recalculate all starting rows starting from this line
447 // (if it is -1, we don't have to recalculate anything) - it is set when
448 // the number of the rows in the middle of the control changes
449 wxTextCoord m_rowFirstInvalid
;
451 // the current timestamp used by LayoutLines()
454 // invalidate starting rows of all lines (NOT rows!) after this one
455 void InvalidateLinesBelow(wxTextCoord line
)
457 if ( m_rowFirstInvalid
== -1 || m_rowFirstInvalid
> line
)
459 m_rowFirstInvalid
= line
;
463 // check if this line is valid: i.e. before the first invalid one
464 bool IsValidLine(wxTextCoord line
) const
466 return ((m_rowFirstInvalid
== -1) || (line
< m_rowFirstInvalid
)) &&
467 m_linesData
[line
].IsValid();
474 m_rowFirstInvalid
= -1;
479 // ----------------------------------------------------------------------------
480 // private classes for undo/redo management
481 // ----------------------------------------------------------------------------
484 We use custom versions of wxWindows command processor to implement undo/redo
485 as we want to avoid storing the backpointer to wxTextCtrl in wxCommand
486 itself: this is a waste of memory as all commands in the given command
487 processor always have the same associated wxTextCtrl and so it makes sense
488 to store the backpointer there.
490 As for the rest of the implementation, it's fairly standard: we have 2
491 command classes corresponding to adding and removing text.
494 // a command corresponding to a wxTextCtrl action
495 class wxTextCtrlCommand
: public wxCommand
498 wxTextCtrlCommand(const wxString
& name
) : wxCommand(TRUE
, name
) { }
500 // we don't use these methods as they don't make sense for us as we need a
501 // wxTextCtrl to be applied
502 virtual bool Do() { wxFAIL_MSG(_T("shouldn't be called")); return FALSE
; }
503 virtual bool Undo() { wxFAIL_MSG(_T("shouldn't be called")); return FALSE
; }
505 // instead, our command processor uses these methods
506 virtual bool Do(wxTextCtrl
*text
) = 0;
507 virtual bool Undo(wxTextCtrl
*text
) = 0;
510 // insert text command
511 class wxTextCtrlInsertCommand
: public wxTextCtrlCommand
514 wxTextCtrlInsertCommand(const wxString
& textToInsert
)
515 : wxTextCtrlCommand(wxTEXT_COMMAND_INSERT
), m_text(textToInsert
)
520 // combine the 2 commands together
521 void Append(wxTextCtrlInsertCommand
*other
);
523 virtual bool CanUndo() const;
524 virtual bool Do(wxTextCtrl
*text
);
525 virtual bool Undo(wxTextCtrl
*text
);
528 // the text we insert
531 // the position where we inserted the text
535 // remove text command
536 class wxTextCtrlRemoveCommand
: public wxTextCtrlCommand
539 wxTextCtrlRemoveCommand(wxTextPos from
, wxTextPos to
)
540 : wxTextCtrlCommand(wxTEXT_COMMAND_REMOVE
)
546 virtual bool CanUndo() const;
547 virtual bool Do(wxTextCtrl
*text
);
548 virtual bool Undo(wxTextCtrl
*text
);
551 // the range of text to delete
555 // the text which was deleted when this command was Do()ne
556 wxString m_textDeleted
;
559 // a command processor for a wxTextCtrl
560 class wxTextCtrlCommandProcessor
: public wxCommandProcessor
563 wxTextCtrlCommandProcessor(wxTextCtrl
*text
)
565 m_compressInserts
= FALSE
;
570 // override Store() to compress multiple wxTextCtrlInsertCommand into one
571 virtual void Store(wxCommand
*command
);
573 // stop compressing insert commands when this is called
574 void StopCompressing() { m_compressInserts
= FALSE
; }
577 wxTextCtrl
*GetTextCtrl() const { return m_text
; }
578 bool IsCompressing() const { return m_compressInserts
; }
581 virtual bool DoCommand(wxCommand
& cmd
)
582 { return ((wxTextCtrlCommand
&)cmd
).Do(m_text
); }
583 virtual bool UndoCommand(wxCommand
& cmd
)
584 { return ((wxTextCtrlCommand
&)cmd
).Undo(m_text
); }
586 // check if this command is a wxTextCtrlInsertCommand and return it casted
587 // to the right type if it is or NULL otherwise
588 wxTextCtrlInsertCommand
*IsInsertCommand(wxCommand
*cmd
);
591 // the control we're associated with
594 // if the flag is TRUE we're compressing subsequent insert commands into
595 // one so that the entire typing could be undone in one call to Undo()
596 bool m_compressInserts
;
599 // ============================================================================
601 // ============================================================================
603 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
604 EVT_CHAR(wxTextCtrl::OnChar
)
606 EVT_SIZE(wxTextCtrl::OnSize
)
608 EVT_IDLE(wxTextCtrl::OnIdle
)
611 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
613 // ----------------------------------------------------------------------------
615 // ----------------------------------------------------------------------------
617 void wxTextCtrl::Init()
623 m_isModified
= FALSE
;
634 // init wxScrollHelper
637 // init the undo manager
638 m_cmdProcessor
= new wxTextCtrlCommandProcessor(this);
644 bool wxTextCtrl::Create(wxWindow
*parent
,
646 const wxString
& value
,
650 const wxValidator
& validator
,
651 const wxString
&name
)
653 if ( style
& wxTE_MULTILINE
)
655 // for compatibility with wxMSW we create the controls with vertical
656 // scrollbar always shown unless they have wxTE_RICH style (because
657 // Windows text controls always has vert scrollbar but richedit one
659 if ( !(style
& wxTE_RICH
) )
661 style
|= wxALWAYS_SHOW_SB
;
664 if ( style
& wxTE_WORDWRAP
)
666 // wrapping words means wrapping, hence no horz scrollbar
670 // TODO: support wxTE_NO_VSCROLL (?)
672 // create data object for normal multiline or for controls with line
674 if ( style
& wxHSCROLL
)
675 m_data
.mdata
= new wxTextMultiLineData
;
677 m_data
.wdata
= new wxTextWrappedData
;
681 // this doesn't make sense for single line controls
684 // create data object for single line controls
685 m_data
.sdata
= new wxTextSingleLineData
;
688 if ( !wxControl::Create(parent
, id
, pos
, size
, style
,
694 SetCursor(wxCURSOR_IBEAM
);
696 if ( style
& wxTE_MULTILINE
)
698 // we should always have at least one line in a multiline control
699 MData().m_lines
.Add(wxEmptyString
);
701 if ( !(style
& wxHSCROLL
) )
703 WData().m_linesData
.Add(new wxWrappedLineData
);
704 WData().InvalidateLinesBelow(0);
707 // we might support it but it's quite useless and other ports don't
709 wxASSERT_MSG( !(style
& wxTE_PASSWORD
),
710 _T("wxTE_PASSWORD can't be used with multiline ctrls") );
717 m_isEditable
= !(style
& wxTE_READONLY
);
720 InitInsertionPoint();
722 // we can't show caret right now as we're not shown yet and so it would
723 // result in garbage on the screen - we'll do it after first OnPaint()
726 CreateInputHandler(wxINP_HANDLER_TEXTCTRL
);
731 wxTextCtrl::~wxTextCtrl()
733 delete m_cmdProcessor
;
737 if ( IsSingleLine() )
739 else if ( WrapLines() )
746 // ----------------------------------------------------------------------------
748 // ----------------------------------------------------------------------------
750 void wxTextCtrl::SetValue(const wxString
& value
)
752 if ( IsSingleLine() && (value
== GetValue()) )
758 Replace(0, GetLastPosition(), value
);
760 if ( IsSingleLine() )
762 SetInsertionPoint(0);
765 // TODO: should we generate the event or not, finally?
768 const wxArrayString
& wxTextCtrl::GetLines() const
770 return MData().m_lines
;
773 size_t wxTextCtrl::GetLineCount() const
775 return MData().m_lines
.GetCount();
778 wxString
wxTextCtrl::GetValue() const
780 // for multiline controls we don't always store the total value but only
781 // recompute it when asked - and to invalidate it we just empty it in
783 if ( !IsSingleLine() && m_value
.empty() )
785 // recalculate: note that we always do it for empty multilien control,
786 // but then it's so quick that it's not important
788 // the first line is special as there is no \n before it, so it's
790 const wxArrayString
& lines
= GetLines();
791 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
792 self
->m_value
<< lines
[0u];
793 size_t count
= lines
.GetCount();
794 for ( size_t n
= 1; n
< count
; n
++ )
796 self
->m_value
<< _T('\n') << lines
[n
];
803 void wxTextCtrl::Clear()
808 bool wxTextCtrl::ReplaceLine(wxTextCoord line
,
809 const wxString
& text
)
813 // first, we have to relayout the line entirely
815 // OPT: we might try not to recalc the unchanged part of line
817 wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
819 // if we had some number of rows before, use this number, otherwise
820 // just make sure that the test below (rowsNew != rowsOld) will be true
822 if ( lineData
.IsValid() )
824 rowsOld
= lineData
.GetExtraRowCount();
826 else // line wasn't laid out yet
828 // assume it changed entirely as we can't do anything better
832 // now change the line
833 MData().m_lines
[line
] = text
;
835 // OPT: we choose to lay it our immediately instead of delaying it
836 // until it is needed because it allows us to avoid invalidating
837 // lines further down if the number of rows didn't chnage, but
838 // maybe we can imporve this even further?
839 LayoutLine(line
, lineData
);
841 int rowsNew
= lineData
.GetExtraRowCount();
843 if ( rowsNew
!= rowsOld
)
845 // we have to update the line wrap marks as this is normally done
846 // by LayoutLines() which we bypassed by calling LayoutLine()
848 wxTextCoord rowFirst
= lineData
.GetFirstRow(),
849 rowCount
= wxMax(rowsOld
, rowsNew
);
850 RefreshLineWrapMarks(rowFirst
, rowFirst
+ rowCount
);
852 // next, if this is not the last line, as the number of rows in it
853 // changed, we need to shift all the lines below it
854 if ( (size_t)line
< WData().m_linesData
.GetCount() )
856 // number of rows changed shifting all lines below
857 WData().InvalidateLinesBelow(line
+ 1);
860 // the number of rows changed
866 MData().m_lines
[line
] = text
;
869 // the number of rows didn't change
873 void wxTextCtrl::RemoveLine(wxTextCoord line
)
875 MData().m_lines
.RemoveAt(line
);
878 // we need to recalculate all the starting rows from this line, but we
879 // can avoid doing it if this line was never calculated: this means
880 // that we will recalculate all lines below it anyhow later if needed
881 if ( WData().IsValidLine(line
) )
883 WData().InvalidateLinesBelow(line
);
886 WData().m_linesData
.RemoveAt(line
);
890 void wxTextCtrl::InsertLine(wxTextCoord line
, const wxString
& text
)
892 MData().m_lines
.Insert(text
, line
);
895 WData().m_linesData
.Insert(new wxWrappedLineData
, line
);
897 // invalidate everything below it
898 WData().InvalidateLinesBelow(line
);
902 void wxTextCtrl::Replace(wxTextPos from
, wxTextPos to
, const wxString
& text
)
904 wxTextCoord colStart
, colEnd
,
908 !PositionToXY(from
, &colStart
, &lineStart
) ||
909 !PositionToXY(to
, &colEnd
, &lineEnd
) )
911 wxFAIL_MSG(_T("invalid range in wxTextCtrl::Replace"));
916 #ifdef WXDEBUG_TEXT_REPLACE
917 // a straighforward (but very inefficient) way of calculating what the new
919 wxString textTotal
= GetValue();
920 wxString
textTotalNew(textTotal
, (size_t)from
);
921 textTotalNew
+= text
;
922 if ( (size_t)to
< textTotal
.length() )
923 textTotalNew
+= textTotal
.c_str() + (size_t)to
;
924 #endif // WXDEBUG_TEXT_REPLACE
926 // remember the old selection and reset it immediately: we must do it
927 // before calling Refresh(anything) as, at least under GTK, this leads to
928 // an _immediate_ repaint (under MSW it is delayed) and hence parts of
929 // text would be redrawn as selected if we didn't reset the selection
930 int selStartOld
= m_selStart
,
931 selEndOld
= m_selEnd
;
936 if ( IsSingleLine() )
938 // replace the part of the text with the new value
939 wxString
valueNew(m_value
, (size_t)from
);
941 // remember it for later use
942 wxCoord startNewText
= GetTextWidth(valueNew
);
945 if ( (size_t)to
< m_value
.length() )
947 valueNew
+= m_value
.c_str() + (size_t)to
;
950 // we usually refresh till the end of line except of the most common case
951 // when some text is appended to the end of the string in which case we
953 wxCoord widthNewText
;
955 if ( (size_t)from
< m_value
.length() )
957 // refresh till the end of line
960 else // text appended, not replaced
962 // refresh only the new text
963 widthNewText
= GetTextWidth(text
);
968 // force SData().m_colLastVisible update
969 SData().m_colLastVisible
= -1;
972 RefreshPixelRange(0, startNewText
, widthNewText
);
976 //OPT: special case for replacements inside single line?
979 Join all the lines in the replacement range into one string, then
980 replace a part of it with the new text and break it into lines again.
983 // (0) we want to know if this replacement changes the number of rows
984 // as if it does we need to refresh everything below the changed
985 // text (it will be shifted...) and we can avoid it if there is no
987 bool rowsNumberChanged
= FALSE
;
990 const wxArrayString
& linesOld
= GetLines();
993 for ( line
= lineStart
; line
<= lineEnd
; line
++ )
995 if ( line
> lineStart
)
997 // from the previous line
998 textOrig
+= _T('\n');
1001 textOrig
+= linesOld
[line
];
1004 // we need to append the '\n' for the last line unless there is no
1006 size_t countOld
= linesOld
.GetCount();
1008 // (2) replace text in the combined string
1010 // (2a) leave the part before replaced area unchanged
1011 wxString
textNew(textOrig
, colStart
);
1013 // these values will be used to refresh the changed area below
1014 wxCoord widthNewText
,
1015 startNewText
= GetTextWidth(textNew
);
1016 if ( (size_t)colStart
== linesOld
[lineStart
].length() )
1018 // text appended, refresh just enough to show the new text
1019 widthNewText
= GetTextWidth(text
.BeforeFirst(_T('\n')));
1021 else // text inserted, refresh till the end of line
1026 // (2b) insert new text
1029 // (2c) and append the end of the old text
1031 // adjust for index shift: to is relative to colStart, not 0
1032 size_t toRel
= (size_t)((to
- from
) + colStart
);
1033 if ( toRel
< textOrig
.length() )
1035 textNew
+= textOrig
.c_str() + toRel
;
1038 // (3) break it into lines
1040 wxArrayString lines
;
1041 const wxChar
*curLineStart
= textNew
.c_str();
1042 for ( const wxChar
*p
= textNew
.c_str(); ; p
++ )
1044 // end of line/text?
1045 if ( !*p
|| *p
== _T('\n') )
1047 lines
.Add(wxString(curLineStart
, p
));
1051 curLineStart
= p
+ 1;
1055 #ifdef WXDEBUG_TEXT_REPLACE
1056 // (3a) all empty tokens should be counted as replacing with "foo" and
1057 // with "foo\n" should have different effects
1058 wxArrayString lines2
= wxStringTokenize(textNew
, _T("\n"),
1059 wxTOKEN_RET_EMPTY_ALL
);
1061 if ( lines2
.IsEmpty() )
1063 lines2
.Add(wxEmptyString
);
1066 wxASSERT_MSG( lines
.GetCount() == lines2
.GetCount(),
1067 _T("Replace() broken") );
1068 for ( size_t n
= 0; n
< lines
.GetCount(); n
++ )
1070 wxASSERT_MSG( lines
[n
] == lines2
[n
], _T("Replace() broken") );
1072 #endif // WXDEBUG_TEXT_REPLACE
1074 // (3b) special case: if we replace everything till the end we need to
1075 // keep an empty line or the lines would disappear completely
1076 // (this also takes care of never leaving m_lines empty)
1077 if ( ((size_t)lineEnd
== countOld
- 1) && lines
.IsEmpty() )
1079 lines
.Add(wxEmptyString
);
1082 size_t nReplaceCount
= lines
.GetCount(),
1085 // (4) merge into the array
1088 for ( line
= lineStart
; line
<= lineEnd
; line
++, nReplaceLine
++ )
1090 if ( nReplaceLine
< nReplaceCount
)
1092 // we have the replacement line for this one
1093 if ( ReplaceLine(line
, lines
[nReplaceLine
]) )
1095 rowsNumberChanged
= TRUE
;
1098 UpdateMaxWidth(line
);
1100 else // no more replacement lines
1102 // (4b) delete all extra lines (note that we need to delete
1103 // them backwards because indices shift while we do it)
1104 bool deletedLongestLine
= FALSE
;
1105 for ( wxTextCoord lineDel
= lineEnd
; lineDel
>= line
; lineDel
-- )
1107 if ( lineDel
== MData().m_lineLongest
)
1109 // we will need to recalc the max line width
1110 deletedLongestLine
= TRUE
;
1113 RemoveLine(lineDel
);
1116 if ( deletedLongestLine
)
1121 // even the line number changed
1122 rowsNumberChanged
= TRUE
;
1124 // update line to exit the loop
1129 // (4c) insert the new lines
1130 if ( nReplaceLine
< nReplaceCount
)
1132 // even the line number changed
1133 rowsNumberChanged
= TRUE
;
1137 InsertLine(++lineEnd
, lines
[nReplaceLine
++]);
1139 UpdateMaxWidth(lineEnd
);
1141 while ( nReplaceLine
< nReplaceCount
);
1144 // (5) now refresh the changed area
1146 // update the (cached) last position first as refresh functions use it
1147 m_posLast
+= text
.length() - to
+ from
;
1149 // we may optimize refresh if the number of rows didn't change - but if
1150 // it did we have to refresh everything below the part we chanegd as
1151 // well as it might have moved
1152 if ( !rowsNumberChanged
)
1154 // refresh the line we changed
1157 RefreshPixelRange(lineStart
++, startNewText
, widthNewText
);
1161 //OPT: we shouldn't refresh the unchanged part of the line in
1162 // this case, but instead just refresh the tail of it - the
1163 // trouble is that we don't know here where does this tail
1167 // number of rows didn't change, refresh the updated rows and the
1169 if ( lineStart
<= lineEnd
)
1170 RefreshLineRange(lineStart
, lineEnd
);
1172 else // rows number did change
1176 // refresh only part of the first line
1177 RefreshPixelRange(lineStart
++, startNewText
, widthNewText
);
1179 //else: we have to refresh everything as some part of the text
1180 // could be in the previous row before but moved to the next
1181 // one now (due to word wrap)
1183 wxTextCoord lineEnd
= GetLines().GetCount() - 1;
1184 if ( lineStart
<= lineEnd
)
1185 RefreshLineRange(lineStart
, lineEnd
);
1187 // refresh text rect left below
1188 RefreshLineRange(lineEnd
+ 1, 0);
1190 // the vert scrollbar might [dis]appear
1191 MData().m_updateScrollbarY
= TRUE
;
1194 // must recalculate it - will do later
1198 #ifdef WXDEBUG_TEXT_REPLACE
1199 // optimized code above should give the same result as straightforward
1200 // computation in the beginning
1201 wxASSERT_MSG( GetValue() == textTotalNew
, _T("error in Replace()") );
1202 #endif // WXDEBUG_TEXT_REPLACE
1204 // update the current position: note that we always put the cursor at the
1205 // end of the replacement text
1206 DoSetInsertionPoint(from
+ text
.length());
1208 // and the selection: this is complicated by the fact that selection coords
1209 // must be first updated to reflect change in text coords, i.e. if we had
1210 // selection from 17 to 19 and we just removed this range, we don't have to
1211 // refresh anything, so we can't just use ClearSelection() here
1212 if ( selStartOld
!= -1 )
1214 // refresh the parst of the selection outside the changed text (which
1215 // we already refreshed)
1216 if ( selStartOld
< from
)
1217 RefreshTextRange(selStartOld
, from
);
1218 if ( to
< selEndOld
)
1219 RefreshTextRange(to
, selEndOld
);
1223 // now call it to do the rest (not related to refreshing)
1227 void wxTextCtrl::Remove(wxTextPos from
, wxTextPos to
)
1229 // Replace() only works with correctly ordered arguments, so exchange them
1231 OrderPositions(from
, to
);
1233 Replace(from
, to
, _T(""));
1236 void wxTextCtrl::WriteText(const wxString
& text
)
1238 // replace the selection with the new text
1241 Replace(m_curPos
, m_curPos
, text
);
1244 void wxTextCtrl::AppendText(const wxString
& text
)
1246 SetInsertionPointEnd();
1250 // ----------------------------------------------------------------------------
1252 // ----------------------------------------------------------------------------
1254 void wxTextCtrl::SetInsertionPoint(wxTextPos pos
)
1256 wxCHECK_RET( pos
>= 0 && pos
<= GetLastPosition(),
1257 _T("insertion point position out of range") );
1259 // don't do anything if it didn't change
1260 if ( pos
!= m_curPos
)
1262 DoSetInsertionPoint(pos
);
1265 if ( !IsSingleLine() )
1267 // moving cursor should reset the stored abscissa (even if the cursor
1268 // position didn't actually change!)
1269 MData().m_xCaret
= -1;
1275 void wxTextCtrl::InitInsertionPoint()
1277 // so far always put it in the beginning
1278 DoSetInsertionPoint(0);
1280 // this will also set the selection anchor correctly
1284 void wxTextCtrl::MoveInsertionPoint(wxTextPos pos
)
1286 wxASSERT_MSG( pos
>= 0 && pos
<= GetLastPosition(),
1287 _T("DoSetInsertionPoint() can only be called with valid pos") );
1290 PositionToXY(m_curPos
, &m_curCol
, &m_curRow
);
1293 void wxTextCtrl::DoSetInsertionPoint(wxTextPos pos
)
1295 MoveInsertionPoint(pos
);
1300 void wxTextCtrl::SetInsertionPointEnd()
1302 SetInsertionPoint(GetLastPosition());
1305 wxTextPos
wxTextCtrl::GetInsertionPoint() const
1310 wxTextPos
wxTextCtrl::GetLastPosition() const
1313 if ( IsSingleLine() )
1315 pos
= m_value
.length();
1321 size_t nLineCount
= GetLineCount();
1322 for ( size_t nLine
= 0; nLine
< nLineCount
; nLine
++ )
1324 // +1 is because the positions at the end of this line and of the
1325 // start of the next one are different
1326 pos
+= GetLines()[nLine
].length() + 1;
1331 // the last position is at the end of the last line, not in the
1332 // beginning of the next line after it
1336 // more probable reason of this would be to forget to update m_posLast
1337 wxASSERT_MSG( pos
== m_posLast
, _T("bug in GetLastPosition()") );
1338 #endif // WXDEBUG_TEXT
1346 // ----------------------------------------------------------------------------
1348 // ----------------------------------------------------------------------------
1350 void wxTextCtrl::GetSelection(wxTextPos
* from
, wxTextPos
* to
) const
1358 wxString
wxTextCtrl::GetSelectionText() const
1362 if ( HasSelection() )
1364 if ( IsSingleLine() )
1366 sel
= m_value
.Mid(m_selStart
, m_selEnd
- m_selStart
);
1370 wxTextCoord colStart
, lineStart
,
1372 PositionToXY(m_selStart
, &colStart
, &lineStart
);
1373 PositionToXY(m_selEnd
, &colEnd
, &lineEnd
);
1375 // as always, we need to check for the special case when the start
1376 // and end line are the same
1377 if ( lineEnd
== lineStart
)
1379 sel
= GetLines()[lineStart
].Mid(colStart
, colEnd
- colStart
);
1381 else // sel on multiple lines
1383 // take the end of the first line
1384 sel
= GetLines()[lineStart
].c_str() + colStart
;
1387 // all intermediate ones
1388 for ( wxTextCoord line
= lineStart
+ 1; line
< lineEnd
; line
++ )
1390 sel
<< GetLines()[line
] << _T('\n');
1393 // and the start of the last one
1394 sel
+= GetLines()[lineEnd
].Left(colEnd
);
1402 void wxTextCtrl::SetSelection(wxTextPos from
, wxTextPos to
)
1404 // selecting till -1 is the same as selecting to the end
1405 if ( to
== -1 && from
!= -1 )
1407 to
= GetLastPosition();
1410 if ( from
== -1 || to
== from
)
1414 else // valid sel range
1416 OrderPositions(from
, to
);
1418 wxCHECK_RET( to
<= GetLastPosition(),
1419 _T("invalid range in wxTextCtrl::SetSelection") );
1421 if ( from
!= m_selStart
|| to
!= m_selEnd
)
1423 // we need to use temp vars as RefreshTextRange() may call DoDraw()
1424 // directly and so m_selStart/End must be reset by then
1425 wxTextPos selStartOld
= m_selStart
,
1426 selEndOld
= m_selEnd
;
1431 wxLogTrace(_T("text"), _T("Selection range is %ld-%ld"),
1432 m_selStart
, m_selEnd
);
1434 // refresh only the part of text which became (un)selected if
1436 if ( selStartOld
== m_selStart
)
1438 RefreshTextRange(selEndOld
, m_selEnd
);
1440 else if ( selEndOld
== m_selEnd
)
1442 RefreshTextRange(m_selStart
, selStartOld
);
1446 // OPT: could check for other cases too but it is probably not
1447 // worth it as the two above are the most common ones
1448 if ( selStartOld
!= -1 )
1449 RefreshTextRange(selStartOld
, selEndOld
);
1450 if ( m_selStart
!= -1 )
1451 RefreshTextRange(m_selStart
, m_selEnd
);
1454 // we need to fully repaint the invalidated areas of the window
1455 // before scrolling it (from DoSetInsertionPoint which is typically
1456 // called after SetSelection()), otherwise they may stay unpainted
1457 m_targetWindow
->Update();
1459 //else: nothing to do
1461 // the insertion point is put at the end of selection
1462 DoSetInsertionPoint(to
);
1466 void wxTextCtrl::ClearSelection()
1468 if ( HasSelection() )
1470 // we need to use temp vars as RefreshTextRange() may call DoDraw()
1471 // directly (see above as well)
1472 wxTextPos selStart
= m_selStart
,
1475 // no selection any more
1479 // refresh the old selection
1480 RefreshTextRange(selStart
, selEnd
);
1483 // the anchor should be moved even if there was no selection previously
1484 m_selAnchor
= m_curPos
;
1487 void wxTextCtrl::RemoveSelection()
1489 if ( !HasSelection() )
1492 Remove(m_selStart
, m_selEnd
);
1495 bool wxTextCtrl::GetSelectedPartOfLine(wxTextCoord line
,
1496 wxTextPos
*start
, wxTextPos
*end
) const
1503 if ( !HasSelection() )
1505 // no selection at all, hence no selection in this line
1509 wxTextCoord lineStart
, colStart
;
1510 PositionToXY(m_selStart
, &colStart
, &lineStart
);
1511 if ( lineStart
> line
)
1513 // this line is entirely above the selection
1517 wxTextCoord lineEnd
, colEnd
;
1518 PositionToXY(m_selEnd
, &colEnd
, &lineEnd
);
1519 if ( lineEnd
< line
)
1521 // this line is entirely below the selection
1525 if ( line
== lineStart
)
1530 *end
= lineEnd
== lineStart
? colEnd
: GetLineLength(line
);
1532 else if ( line
== lineEnd
)
1535 *start
= lineEnd
== lineStart
? colStart
: 0;
1539 else // the line is entirely inside the selection
1544 *end
= GetLineLength(line
);
1550 // ----------------------------------------------------------------------------
1552 // ----------------------------------------------------------------------------
1554 bool wxTextCtrl::IsModified() const
1556 return m_isModified
;
1559 bool wxTextCtrl::IsEditable() const
1561 // disabled control can never be edited
1562 return m_isEditable
&& IsEnabled();
1565 void wxTextCtrl::DiscardEdits()
1567 m_isModified
= FALSE
;
1570 void wxTextCtrl::SetEditable(bool editable
)
1572 if ( editable
!= m_isEditable
)
1574 m_isEditable
= editable
;
1576 // the caret (dis)appears
1579 // the appearance of the control might have changed
1584 // ----------------------------------------------------------------------------
1585 // col/lines <-> position correspondence
1586 // ----------------------------------------------------------------------------
1589 A few remarks about this stuff:
1591 o The numbering of the text control columns/rows starts from 0.
1592 o Start of first line is position 0, its last position is line.length()
1593 o Start of the next line is the last position of the previous line + 1
1596 int wxTextCtrl::GetLineLength(wxTextCoord line
) const
1598 if ( IsSingleLine() )
1600 wxASSERT_MSG( line
== 0, _T("invalid GetLineLength() parameter") );
1602 return m_value
.length();
1606 wxCHECK_MSG( (size_t)line
< GetLineCount(), -1,
1607 _T("line index out of range") );
1609 return GetLines()[line
].length();
1613 wxString
wxTextCtrl::GetLineText(wxTextCoord line
) const
1615 if ( IsSingleLine() )
1617 wxASSERT_MSG( line
== 0, _T("invalid GetLineLength() parameter") );
1623 wxCHECK_MSG( (size_t)line
< GetLineCount(), _T(""),
1624 _T("line index out of range") );
1626 return GetLines()[line
];
1630 int wxTextCtrl::GetNumberOfLines() const
1632 // there is always 1 line, even if the text is empty
1633 return IsSingleLine() ? 1 : GetLineCount();
1636 wxTextPos
wxTextCtrl::XYToPosition(wxTextCoord x
, wxTextCoord y
) const
1638 // note that this method should accept any values of x and y and return -1
1639 // if they are out of range
1640 if ( IsSingleLine() )
1642 return x
> GetLastPosition() || y
> 0 ? -1 : x
;
1646 if ( (size_t)y
>= GetLineCount() )
1648 // this position is below the text
1649 return GetLastPosition();
1653 for ( size_t nLine
= 0; nLine
< (size_t)y
; nLine
++ )
1655 // +1 is because the positions at the end of this line and of the
1656 // start of the next one are different
1657 pos
+= GetLines()[nLine
].length() + 1;
1660 // take into account also the position in line
1661 if ( (size_t)x
> GetLines()[y
].length() )
1663 // don't return position in the next line
1664 x
= GetLines()[y
].length();
1671 bool wxTextCtrl::PositionToXY(wxTextPos pos
,
1672 wxTextCoord
*x
, wxTextCoord
*y
) const
1674 if ( IsSingleLine() )
1676 if ( (size_t)pos
> m_value
.length() )
1688 wxTextPos posCur
= 0;
1689 size_t nLineCount
= GetLineCount();
1690 for ( size_t nLine
= 0; nLine
< nLineCount
; nLine
++ )
1692 // +1 is because the start the start of the next line is one
1693 // position after the end of this one
1694 wxTextPos posNew
= posCur
+ GetLines()[nLine
].length() + 1;
1697 // we've found the line, now just calc the column
1705 wxASSERT_MSG( XYToPosition(pos
- posCur
, nLine
) == pos
,
1706 _T("XYToPosition() or PositionToXY() broken") );
1707 #endif // WXDEBUG_TEXT
1711 else // go further down
1717 // beyond the last line
1722 wxTextCoord
wxTextCtrl::GetRowsPerLine(wxTextCoord line
) const
1724 // a normal line has one row
1725 wxTextCoord numRows
= 1;
1729 // add the number of additional rows
1730 numRows
+= WData().m_linesData
[line
].GetExtraRowCount();
1736 wxTextCoord
wxTextCtrl::GetRowCount() const
1738 wxTextCoord count
= GetLineCount();
1743 count
= GetFirstRowOfLine(count
- 1) +
1744 WData().m_linesData
[count
- 1].GetRowCount();
1750 wxTextCoord
wxTextCtrl::GetRowAfterLine(wxTextCoord line
) const
1755 if ( !WData().IsValidLine(line
) )
1760 return WData().m_linesData
[line
].GetNextRow();
1763 wxTextCoord
wxTextCtrl::GetFirstRowOfLine(wxTextCoord line
) const
1768 if ( !WData().IsValidLine(line
) )
1773 return WData().m_linesData
[line
].GetFirstRow();
1776 bool wxTextCtrl::PositionToLogicalXY(wxTextPos pos
,
1778 wxCoord
*yOut
) const
1780 wxTextCoord col
, line
;
1782 // optimization for special (but common) case when we already have the col
1784 if ( pos
== m_curPos
)
1789 else // must really calculate col/line from pos
1791 if ( !PositionToXY(pos
, &col
, &line
) )
1795 int hLine
= GetLineHeight();
1797 wxString textLine
= GetLineText(line
);
1798 if ( IsSingleLine() || !WrapLines() )
1800 x
= GetTextWidth(textLine
.Left(col
));
1803 else // difficult case: multline control with line wrap
1805 y
= GetFirstRowOfLine(line
);
1807 wxTextCoord colRowStart
;
1808 y
+= GetRowInLine(line
, col
, &colRowStart
);
1812 // x is the width of the text before this position in this row
1813 x
= GetTextWidth(textLine
.Mid(colRowStart
, col
- colRowStart
));
1824 bool wxTextCtrl::PositionToDeviceXY(wxTextPos pos
,
1826 wxCoord
*yOut
) const
1829 if ( !PositionToLogicalXY(pos
, &x
, &y
) )
1832 // finally translate the logical text rect coords into physical client
1834 CalcScrolledPosition(m_rectText
.x
+ x
, m_rectText
.y
+ y
, xOut
, yOut
);
1839 wxPoint
wxTextCtrl::GetCaretPosition() const
1841 wxCoord xCaret
, yCaret
;
1842 if ( !PositionToDeviceXY(m_curPos
, &xCaret
, &yCaret
) )
1844 wxFAIL_MSG( _T("Caret can't be beyond the text!") );
1847 return wxPoint(xCaret
, yCaret
);
1850 // pos may be -1 to show the current position
1851 void wxTextCtrl::ShowPosition(wxTextPos pos
)
1855 if ( IsSingleLine() )
1857 ShowHorzPosition(GetTextWidth(m_value
.Left(pos
)));
1859 else if ( MData().m_scrollRangeX
|| MData().m_scrollRangeY
) // multiline with scrollbars
1862 GetViewStart(&xStart
, &yStart
);
1868 PositionToLogicalXY(pos
, &x
, &y
);
1870 wxRect rectText
= GetRealTextArea();
1872 // scroll the position vertically into view: if it is currently above
1873 // it, make it the first one, otherwise the last one
1874 if ( MData().m_scrollRangeY
)
1876 y
/= GetLineHeight();
1882 else // we are currently in or below the view area
1884 // find the last row currently shown
1889 // to find the last row we need to use the generic HitTest
1892 // OPT this is a bit silly: we undo this in HitTest(), so
1893 // it would be better to factor out the common
1894 // functionality into a separate function (OTOH it
1895 // won't probably save us that much)
1896 wxPoint
pt(0, rectText
.height
- 1);
1897 pt
+= GetClientAreaOrigin();
1898 pt
+= m_rectText
.GetPosition();
1899 HitTest(pt
, &col
, &yEnd
);
1901 // find the row inside the line
1902 yEnd
= GetFirstRowOfLine(yEnd
) + GetRowInLine(yEnd
, col
);
1906 // finding the last line is easy if each line has exactly
1908 yEnd
= yStart
+ rectText
.height
/ GetLineHeight() - 1;
1913 // scroll down: the current item should appear at the
1914 // bottom of the view
1915 Scroll(0, y
- (yEnd
- yStart
));
1920 // scroll the position horizontally into view
1922 // we follow what I believe to be Windows behaviour here, that is if
1923 // the position is already entirely in the view we do nothing, but if
1924 // we do have to scroll the window to bring it into view, we scroll it
1925 // not just enough to show the position but slightly more so that this
1926 // position is at 1/3 of the window width from the closest border to it
1927 // (I'm not sure that Windows does exactly this but it looks like this)
1928 if ( MData().m_scrollRangeX
)
1930 // unlike for the rows, xStart doesn't correspond to the starting
1931 // column as they all have different widths, so we need to
1932 // translate everything to pixels
1934 // we want the text between x and x2 be entirely inside the view
1935 // (i.e. the current character)
1937 // make xStart the first visible pixel (and not position)
1938 int wChar
= GetAverageWidth();
1943 // we want the position of this column be 1/3 to the right of
1945 x
-= rectText
.width
/ 3;
1948 Scroll(x
/ wChar
, y
);
1950 else // maybe we're beyond the right border of the view?
1952 wxTextCoord col
, row
;
1953 if ( PositionToXY(pos
, &col
, &row
) )
1955 wxString lineText
= GetLineText(row
);
1956 wxCoord x2
= x
+ GetTextWidth(lineText
[(size_t)col
]);
1957 if ( x2
> xStart
+ rectText
.width
)
1959 // we want the position of this column be 1/3 to the
1960 // left of the right edge, i.e. 2/3 right of the left
1962 x2
-= (2*rectText
.width
)/3;
1965 Scroll(x2
/ wChar
, row
);
1971 //else: multiline but no scrollbars, hence nothing to do
1976 // ----------------------------------------------------------------------------
1978 // ----------------------------------------------------------------------------
1981 TODO: we could have (easy to do) vi-like options for word movement, i.e.
1982 distinguish between inlusive/exclusive words and between words and
1983 WORDS (in vim sense) and also, finally, make the set of characters
1984 which make up a word configurable - currently we use the exclusive
1985 WORDS only (coincidentally, this is what Windows edit control does)
1987 For future references, here is what vim help says:
1989 A word consists of a sequence of letters, digits and underscores, or
1990 a sequence of other non-blank characters, separated with white space
1991 (spaces, tabs, <EOL>). This can be changed with the 'iskeyword'
1994 A WORD consists of a sequence of non-blank characters, separated with
1995 white space. An empty line is also considered to be a word and a
1999 static inline bool IsWordChar(wxChar ch
)
2001 return !wxIsspace(ch
);
2004 wxTextPos
wxTextCtrl::GetWordStart() const
2006 if ( m_curPos
== -1 || m_curPos
== 0 )
2009 if ( m_curCol
== 0 )
2011 // go to the end of the previous line
2012 return m_curPos
- 1;
2015 // it shouldn't be possible to learn where the word starts in the password
2020 // start at the previous position
2021 const wxChar
*p0
= GetLineText(m_curRow
).c_str();
2022 const wxChar
*p
= p0
+ m_curCol
- 1;
2024 // find the end of the previous word
2025 while ( (p
> p0
) && !IsWordChar(*p
) )
2028 // now find the beginning of this word
2029 while ( (p
> p0
) && IsWordChar(*p
) )
2032 // we might have gone too far
2033 if ( !IsWordChar(*p
) )
2036 return (m_curPos
- m_curCol
) + p
- p0
;
2039 wxTextPos
wxTextCtrl::GetWordEnd() const
2041 if ( m_curPos
== -1 )
2044 wxString line
= GetLineText(m_curRow
);
2045 if ( (size_t)m_curCol
== line
.length() )
2047 // if we're on the last position in the line, go to the next one - if
2049 wxTextPos pos
= m_curPos
;
2050 if ( pos
< GetLastPosition() )
2056 // it shouldn't be possible to learn where the word ends in the password
2059 return GetLastPosition();
2061 // start at the current position
2062 const wxChar
*p0
= line
.c_str();
2063 const wxChar
*p
= p0
+ m_curCol
;
2065 // find the start of the next word
2066 while ( *p
&& !IsWordChar(*p
) )
2069 // now find the end of it
2070 while ( *p
&& IsWordChar(*p
) )
2073 // and find the start of the next word
2074 while ( *p
&& !IsWordChar(*p
) )
2077 return (m_curPos
- m_curCol
) + p
- p0
;
2080 // ----------------------------------------------------------------------------
2082 // ----------------------------------------------------------------------------
2084 void wxTextCtrl::Copy()
2087 if ( HasSelection() )
2089 wxClipboardLocker clipLock
;
2091 // wxTextFile::Translate() is needed to transform all '\n' into "\r\n"
2092 wxString text
= wxTextFile::Translate(GetTextToShow(GetSelectionText()));
2093 wxTextDataObject
*data
= new wxTextDataObject(text
);
2094 wxTheClipboard
->SetData(data
);
2096 #endif // wxUSE_CLIPBOARD
2099 void wxTextCtrl::Cut()
2104 bool wxTextCtrl::DoCut()
2106 if ( !HasSelection() )
2116 void wxTextCtrl::Paste()
2121 bool wxTextCtrl::DoPaste()
2124 wxClipboardLocker clipLock
;
2126 wxTextDataObject data
;
2127 if ( wxTheClipboard
->IsSupported(data
.GetFormat())
2128 && wxTheClipboard
->GetData(data
) )
2130 // reverse transformation: '\r\n\" -> '\n'
2131 wxString text
= wxTextFile::Translate(data
.GetText(),
2132 wxTextFileType_Unix
);
2133 if ( !text
.empty() )
2140 #endif // wxUSE_CLIPBOARD
2145 // ----------------------------------------------------------------------------
2147 // ----------------------------------------------------------------------------
2149 wxTextCtrlInsertCommand
*
2150 wxTextCtrlCommandProcessor::IsInsertCommand(wxCommand
*command
)
2152 return (wxTextCtrlInsertCommand
*)
2153 (command
&& (command
->GetName() == wxTEXT_COMMAND_INSERT
)
2157 void wxTextCtrlCommandProcessor::Store(wxCommand
*command
)
2159 wxTextCtrlInsertCommand
*cmdIns
= IsInsertCommand(command
);
2162 if ( IsCompressing() )
2164 wxTextCtrlInsertCommand
*
2165 cmdInsLast
= IsInsertCommand(GetCurrentCommand());
2167 // it is possible that we don't have any last command at all if,
2168 // for example, it was undone since the last Store(), so deal with
2172 cmdInsLast
->Append(cmdIns
);
2176 // don't need to call the base class version
2181 // append the following insert commands to this one
2182 m_compressInserts
= TRUE
;
2184 // let the base class version will do the job normally
2186 else // not an insert command
2188 // stop compressing insert commands - this won't work with the last
2189 // command not being an insert one anyhow
2192 // let the base class version will do the job normally
2195 wxCommandProcessor::Store(command
);
2198 void wxTextCtrlInsertCommand::Append(wxTextCtrlInsertCommand
*other
)
2200 m_text
+= other
->m_text
;
2203 bool wxTextCtrlInsertCommand::CanUndo() const
2205 return m_from
!= -1;
2208 bool wxTextCtrlInsertCommand::Do(wxTextCtrl
*text
)
2210 // the text is going to be inserted at the current position, remember where
2212 m_from
= text
->GetInsertionPoint();
2214 // and now do insert it
2215 text
->WriteText(m_text
);
2220 bool wxTextCtrlInsertCommand::Undo(wxTextCtrl
*text
)
2222 wxCHECK_MSG( CanUndo(), FALSE
, _T("impossible to undo insert cmd") );
2224 // remove the text from where we inserted it
2225 text
->Remove(m_from
, m_from
+ m_text
.length());
2230 bool wxTextCtrlRemoveCommand::CanUndo() const
2232 // if we were executed, we should have the text we removed
2233 return !m_textDeleted
.empty();
2236 bool wxTextCtrlRemoveCommand::Do(wxTextCtrl
*text
)
2238 text
->SetSelection(m_from
, m_to
);
2239 m_textDeleted
= text
->GetSelectionText();
2240 text
->RemoveSelection();
2245 bool wxTextCtrlRemoveCommand::Undo(wxTextCtrl
*text
)
2247 // it is possible that the text was deleted and that we can't restore text
2248 // at the same position we removed it any more
2249 wxTextPos posLast
= text
->GetLastPosition();
2250 text
->SetInsertionPoint(m_from
> posLast
? posLast
: m_from
);
2251 text
->WriteText(m_textDeleted
);
2256 void wxTextCtrl::Undo()
2258 // the caller must check it
2259 wxASSERT_MSG( CanUndo(), _T("can't call Undo() if !CanUndo()") );
2261 m_cmdProcessor
->Undo();
2264 void wxTextCtrl::Redo()
2266 // the caller must check it
2267 wxASSERT_MSG( CanRedo(), _T("can't call Undo() if !CanUndo()") );
2269 m_cmdProcessor
->Redo();
2272 bool wxTextCtrl::CanUndo() const
2274 return IsEditable() && m_cmdProcessor
->CanUndo();
2277 bool wxTextCtrl::CanRedo() const
2279 return IsEditable() && m_cmdProcessor
->CanRedo();
2282 // ----------------------------------------------------------------------------
2284 // ----------------------------------------------------------------------------
2286 wxSize
wxTextCtrl::DoGetBestClientSize() const
2288 // when we're called for the very first time from Create() we must
2289 // calculate the font metrics here because we can't do it before calling
2290 // Create() (there is no window yet and wxGTK crashes) but we need them
2292 if ( m_heightLine
== -1 )
2294 wxConstCast(this, wxTextCtrl
)->RecalcFontMetrics();
2298 GetTextExtent(GetTextToShow(GetLineText(0)), &w
, &h
);
2300 int wChar
= GetAverageWidth(),
2301 hChar
= GetLineHeight();
2303 int widthMin
= wxMax(10*wChar
, 100);
2309 if ( !IsSingleLine() )
2311 // let the control have a reasonable number of lines
2312 int lines
= GetNumberOfLines();
2315 else if ( lines
> 10 )
2322 rectText
.height
= h
;
2323 wxRect rectTotal
= GetRenderer()->GetTextTotalArea(this, rectText
);
2324 return wxSize(rectTotal
.width
, rectTotal
.height
);
2327 void wxTextCtrl::UpdateTextRect()
2329 wxRect
rectTotal(wxPoint(0, 0), GetClientSize());
2330 wxCoord
*extraSpace
= WrapLines() ? &WData().m_widthMark
: NULL
;
2331 m_rectText
= GetRenderer()->GetTextClientArea(this, rectTotal
, extraSpace
);
2333 // code elsewhere is confused by negative rect size
2334 if ( m_rectText
.width
<= 0 )
2335 m_rectText
.width
= 1;
2336 if ( m_rectText
.height
<= 0 )
2337 m_rectText
.height
= 1;
2339 if ( !IsSingleLine() )
2341 // invalidate it so that GetRealTextArea() will recalc it
2342 MData().m_rectTextReal
.width
= 0;
2344 // only scroll this rect when the window is scrolled: note that we have
2345 // to scroll not only the text but the line wrap marks too if we show
2347 wxRect rectText
= GetRealTextArea();
2348 if ( extraSpace
&& *extraSpace
)
2350 rectText
.width
+= *extraSpace
;
2352 SetTargetRect(rectText
);
2354 // relayout all lines
2357 WData().m_rowFirstInvalid
= 0;
2359 // increase timestamp: this means that the lines which had been
2360 // laid out before will be relayd out the next time LayoutLines()
2361 // is called because their timestamp will be smaller than the
2363 WData().m_timestamp
++;
2367 UpdateLastVisible();
2370 void wxTextCtrl::UpdateLastVisible()
2372 // this method is only used for horizontal "scrollbarless" scrolling which
2373 // is used only with single line controls
2374 if ( !IsSingleLine() )
2377 // use (efficient) HitTestLine to find the last visible character
2378 wxString text
= m_value
.Mid((size_t)SData().m_colStart
/* to the end */);
2380 switch ( HitTestLine(text
, m_rectText
.width
, &col
) )
2382 case wxTE_HT_BEYOND
:
2383 // everything is visible
2384 SData().m_colLastVisible
= text
.length();
2387 SData().m_posLastVisible
= -1;
2391 case wxTE_HT_BEFORE:
2395 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2398 case wxTE_HT_ON_TEXT
:
2401 // the last entirely seen character is the previous one because
2402 // this one is only partly visible - unless the width of the
2403 // string is exactly the max width
2404 SData().m_posLastVisible
= GetTextWidth(text
.Truncate(col
+ 1));
2405 if ( SData().m_posLastVisible
> m_rectText
.width
)
2407 // this character is not entirely visible, take the
2412 SData().m_posLastVisible
= -1;
2414 //else: we can just see it
2416 SData().m_colLastVisible
= col
;
2421 // calculate the width of the text really shown
2422 if ( SData().m_posLastVisible
== -1 )
2424 SData().m_posLastVisible
= GetTextWidth(text
.Truncate(SData().m_colLastVisible
+ 1));
2427 // current value is relative the start of the string text which starts at
2428 // SData().m_colStart, we need an absolute offset into string
2429 SData().m_colLastVisible
+= SData().m_colStart
;
2431 wxLogTrace(_T("text"), _T("Last visible column/position is %d/%ld"),
2432 SData().m_colLastVisible
, SData().m_posLastVisible
);
2435 void wxTextCtrl::OnSize(wxSizeEvent
& event
)
2439 if ( !IsSingleLine() )
2442 // update them immediately because if we are called for the first time,
2443 // we need to create them in order for the base class version to
2444 // position the scrollbars correctly - if we don't do it now, it won't
2445 // happen at all if we don't get more size events
2449 MData().m_updateScrollbarX
=
2450 MData().m_updateScrollbarY
= TRUE
;
2456 wxCoord
wxTextCtrl::GetTotalWidth() const
2459 CalcUnscrolledPosition(m_rectText
.width
, 0, &w
, NULL
);
2463 wxCoord
wxTextCtrl::GetTextWidth(const wxString
& text
) const
2466 GetTextExtent(GetTextToShow(text
), &w
, NULL
);
2470 wxRect
wxTextCtrl::GetRealTextArea() const
2472 // for single line text control it's just the same as text rect
2473 if ( IsSingleLine() )
2476 // the real text area always holds an entire number of lines, so the only
2477 // difference with the text area is a narrow strip along the bottom border
2478 wxRect rectText
= MData().m_rectTextReal
;
2479 if ( !rectText
.width
)
2482 rectText
= m_rectText
;
2484 // when we're called for the very first time, the line height might not
2485 // had been calculated yet, so do get it now
2486 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2487 self
->RecalcFontMetrics();
2489 int hLine
= GetLineHeight();
2490 rectText
.height
= (m_rectText
.height
/ hLine
) * hLine
;
2493 self
->MData().m_rectTextReal
= rectText
;
2499 wxTextCoord
wxTextCtrl::GetRowInLine(wxTextCoord line
,
2501 wxTextCoord
*colRowStart
) const
2503 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2505 const wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
2507 if ( !WData().IsValidLine(line
) )
2510 // row is here counted a bit specially: 0 is the 2nd row of the line (1st
2513 rowMax
= lineData
.GetExtraRowCount();
2517 while ( (row
< rowMax
) && (col
>= lineData
.GetExtraRowStart(row
)) )
2520 // it's ok here that row is 1 greater than needed: like this, it is
2521 // counted as a normal (and not extra) row
2523 //else: only one row anyhow
2527 // +1 because we need a real row number, not the extra row one
2528 *colRowStart
= lineData
.GetRowStart(row
);
2530 // this can't happen, of course
2531 wxASSERT_MSG( *colRowStart
<= col
, _T("GetRowInLine() is broken") );
2537 void wxTextCtrl::LayoutLine(wxTextCoord line
, wxWrappedLineData
& lineData
) const
2539 // FIXME: this uses old GetPartOfWrappedLine() which is not used anywhere
2540 // else now and has rather awkward interface for our needs here
2542 lineData
.m_rowsStart
.Empty();
2543 lineData
.m_rowsWidth
.Empty();
2545 const wxString
& text
= GetLineText(line
);
2547 size_t colRowStart
= 0;
2550 size_t lenRow
= GetPartOfWrappedLine
2552 text
.c_str() + colRowStart
,
2556 // remember the start of this row (not for the first one as
2557 // it's always 0) and its width
2559 lineData
.m_rowsStart
.Add(colRowStart
);
2560 lineData
.m_rowsWidth
.Add(widthRow
);
2562 colRowStart
+= lenRow
;
2564 while ( colRowStart
< text
.length() );
2566 // put the current timestamp on it
2567 lineData
.m_timestamp
= WData().m_timestamp
;
2570 void wxTextCtrl::LayoutLines(wxTextCoord lineLast
) const
2572 wxASSERT_MSG( WrapLines(), _T("should only be used for line wrapping") );
2574 // if we were called, some line was dirty and if it was dirty we must have
2575 // had m_rowFirstInvalid set to something too
2576 wxTextCoord lineFirst
= WData().m_rowFirstInvalid
;
2577 wxASSERT_MSG( lineFirst
!= -1, _T("nothing to layout?") );
2579 wxTextCoord rowFirst
, rowCur
;
2582 // start after the last known valid line
2583 const wxWrappedLineData
& lineData
= WData().m_linesData
[lineFirst
- 1];
2584 rowFirst
= lineData
.GetFirstRow() + lineData
.GetRowCount();
2586 else // no valid lines, start at row 0
2592 for ( wxTextCoord line
= lineFirst
; line
<= lineLast
; line
++ )
2594 // set the starting row for this line
2595 wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
2596 lineData
.m_rowFirst
= rowCur
;
2598 // had the line been already broken into rows?
2600 // if so, compare its timestamp with the current one: if nothing has
2601 // been changed, don't relayout it
2602 if ( !lineData
.IsValid() ||
2603 (lineData
.m_timestamp
< WData().m_timestamp
) )
2605 // now do break it in rows
2606 LayoutLine(line
, lineData
);
2609 rowCur
+= lineData
.GetRowCount();
2612 // we are now valid at least up to this line, but if it is the last one we
2613 // just don't have any more invalid rows at all
2614 if ( (size_t)lineLast
== WData().m_linesData
.GetCount() -1 )
2619 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2620 self
->WData().m_rowFirstInvalid
= lineLast
;
2622 // also refresh the line end indicators (FIXME shouldn't do it always!)
2623 self
->RefreshLineWrapMarks(rowFirst
, rowCur
);
2626 size_t wxTextCtrl::GetPartOfWrappedLine(const wxChar
* text
,
2627 wxCoord
*widthReal
) const
2629 // this function is slow, it shouldn't be called unless really needed
2630 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2635 switch ( HitTestLine(s
, m_rectText
.width
, &col
) )
2638 case wxTE_HT_BEFORE:
2642 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2645 case wxTE_HT_ON_TEXT
:
2648 // the last entirely seen character is the previous one because
2649 // this one is only partly visible - unless the width of the
2650 // string is exactly the max width
2651 wReal
= GetTextWidth(s
.Truncate(col
+ 1));
2652 if ( wReal
> m_rectText
.width
)
2654 // this character is not entirely visible, take the
2661 //else: we can just see it
2663 // wrap at any character or only at words boundaries?
2664 if ( !(GetWindowStyle() & wxTE_LINEWRAP
) )
2666 // find the (last) not word char before this word
2667 wxTextCoord colWordStart
;
2668 for ( colWordStart
= col
;
2669 colWordStart
&& IsWordChar(s
[(size_t)colWordStart
]);
2673 if ( colWordStart
> 0 )
2675 if ( colWordStart
!= col
)
2677 // will have to recalc the real width
2683 //else: only a single word, have to wrap it here
2688 case wxTE_HT_BEYOND
:
2692 // we return the number of characters, not the index of the last one
2693 if ( (size_t)col
< s
.length() )
2695 // but don't return more than this (empty) string has
2703 // calc it if not done yet
2704 wReal
= GetTextWidth(s
.Truncate(col
));
2710 // VZ: old, horribly inefficient code which can still be used for checking
2711 // the result (in line, not word, wrap mode only) - to be removed later
2713 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2714 wxClientDC
dc(self
);
2715 dc
.SetFont(GetFont());
2716 self
->DoPrepareDC(dc
);
2718 wxCoord widthMax
= m_rectText
.width
;
2720 // the text which we can keep in this ROW
2723 for ( wOld
= w
= 0; *text
&& (w
<= widthMax
); )
2727 dc
.GetTextExtent(str
, &w
, NULL
);
2732 // if we wrapped, the last letter was one too much
2733 if ( str
.length() > 1 )
2736 str
.erase(str
.length() - 1, 1);
2738 else // but always keep at least one letter in each row
2740 // the real width then is the last value of w and not teh one
2745 else // we didn't wrap
2750 wxASSERT( col
== str
.length() );
2754 wxASSERT( *widthReal
== wOld
);
2759 //return str.length();
2765 // OPT: this function is called a lot - would be nice to optimize it but I
2766 // don't really know how yet
2767 wxTextCtrlHitTestResult
wxTextCtrl::HitTestLine(const wxString
& line
,
2769 wxTextCoord
*colOut
) const
2771 wxTextCtrlHitTestResult res
= wxTE_HT_ON_TEXT
;
2774 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2775 wxClientDC
dc(self
);
2776 dc
.SetFont(GetFont());
2777 self
->DoPrepareDC(dc
);
2780 dc
.GetTextExtent(line
, &width
, NULL
);
2783 // clicking beyond the end of line is equivalent to clicking at
2784 // the end of it, so return the last line column
2785 col
= line
.length();
2788 // unless the line is empty and so doesn't have any column at all -
2789 // in this case return 0, what else can we do?
2793 res
= wxTE_HT_BEYOND
;
2799 res
= wxTE_HT_BEFORE
;
2801 else // we're inside the line
2803 // now calculate the column: first, approximate it with fixed-width
2804 // value and then calculate the correct value iteratively: note that
2805 // we use the first character of the line instead of (average)
2806 // GetCharWidth(): it is common to have lines of dashes, for example,
2807 // and this should give us much better approximation in such case
2809 // OPT: maybe using (cache) m_widthAvg would be still faster? profile!
2810 dc
.GetTextExtent(line
[0], &width
, NULL
);
2817 else if ( (size_t)col
> line
.length() )
2819 col
= line
.length();
2822 // matchDir is the direction in which we should move to reach the
2823 // character containing the given position
2829 } matchDir
= Match_None
;
2832 // check that we didn't go beyond the line boundary
2838 if ( (size_t)col
> line
.length() )
2840 col
= line
.length();
2844 wxString
strBefore(line
, (size_t)col
);
2845 dc
.GetTextExtent(strBefore
, &width
, NULL
);
2848 if ( matchDir
== Match_Right
)
2850 // we were going to the right and, finally, moved beyond
2851 // the original position - stop on the previous one
2857 if ( matchDir
== Match_None
)
2859 // we just started iterating, now we know that we should
2861 matchDir
= Match_Left
;
2863 //else: we are still to the right of the target, continue
2867 // invert the logic above
2868 if ( matchDir
== Match_Left
)
2870 // with the exception that we don't need to backtrack here
2874 if ( matchDir
== Match_None
)
2877 matchDir
= Match_Right
;
2881 // this is not supposed to happen
2882 wxASSERT_MSG( matchDir
, _T("logic error in wxTextCtrl::HitTest") );
2884 if ( matchDir
== Match_Right
)
2891 // check that we calculated it correctly
2893 if ( res
== wxTE_HT_ON_TEXT
)
2896 wxString text
= line
.Left(col
);
2897 dc
.GetTextExtent(text
, &width1
, NULL
);
2898 if ( (size_t)col
< line
.length() )
2903 dc
.GetTextExtent(text
, &width2
, NULL
);
2905 wxASSERT_MSG( (width1
<= x
) && (x
< width2
),
2906 _T("incorrect HitTestLine() result") );
2908 else // we return last char
2910 wxASSERT_MSG( x
>= width1
, _T("incorrect HitTestLine() result") );
2913 #endif // WXDEBUG_TEXT
2921 wxTextCtrlHitTestResult
wxTextCtrl::HitTest(const wxPoint
& pos
,
2922 wxTextCoord
*colOut
,
2923 wxTextCoord
*rowOut
) const
2925 return HitTest2(pos
.y
, pos
.x
, 0, rowOut
, colOut
, NULL
, NULL
);
2928 wxTextCtrlHitTestResult
wxTextCtrl::HitTestLogical(const wxPoint
& pos
,
2929 wxTextCoord
*colOut
,
2930 wxTextCoord
*rowOut
) const
2932 return HitTest2(pos
.y
, pos
.x
, 0, rowOut
, colOut
, NULL
, NULL
, FALSE
);
2935 wxTextCtrlHitTestResult
wxTextCtrl::HitTest2(wxCoord y0
,
2938 wxTextCoord
*rowOut
,
2939 wxTextCoord
*colStart
,
2940 wxTextCoord
*colEnd
,
2941 wxTextCoord
*colRowStartOut
,
2942 bool deviceCoords
) const
2944 // is the point in the text area or to the right or below it?
2945 wxTextCtrlHitTestResult res
= wxTE_HT_ON_TEXT
;
2947 // translate the window coords x0 and y0 into the client coords in the text
2948 // area by adjusting for both the client and text area offsets (unless this
2949 // was already done)
2953 wxPoint pt
= GetClientAreaOrigin() + m_rectText
.GetPosition();
2954 CalcUnscrolledPosition(x10
- pt
.x
, y0
- pt
.y
, &x1
, &y
);
2962 // calculate the row (it is really a LINE, not a ROW)
2965 // these vars are used only for WrapLines() case
2966 wxTextCoord colRowStart
= 0;
2969 if ( colRowStartOut
)
2970 *colRowStartOut
= 0;
2972 int hLine
= GetLineHeight();
2975 // and clicking before it is the same as clicking on the first one
2978 res
= wxTE_HT_BEFORE
;
2982 wxTextCoord rowLast
= GetNumberOfLines() - 1;
2984 if ( IsSingleLine() || !WrapLines() )
2986 // in this case row calculation is simple as all lines have the
2987 // same height and so row is the same as line
2988 if ( row
> rowLast
)
2990 // clicking below the text is the same as clicking on the last
2994 res
= wxTE_HT_BELOW
;
2997 else // multline control with line wrap
2999 // use binary search to find the line containing this row
3000 const wxArrayWrappedLinesData
& linesData
= WData().m_linesData
;
3002 hi
= linesData
.GetCount(),
3007 const wxWrappedLineData
& lineData
= linesData
[cur
];
3008 if ( !WData().IsValidLine(cur
) )
3010 wxTextCoord rowFirst
= lineData
.GetFirstRow();
3012 if ( row
< rowFirst
)
3018 // our row is after the first row of the cur line:
3019 // obviously, if cur is the last line, it contains this
3020 // row, otherwise we have to test that it is before the
3021 // first row of the next line
3022 bool found
= cur
== linesData
.GetCount() - 1;
3025 // if the row is beyond the end of text, adjust it to
3026 // be the last one and set res accordingly
3027 if ( (size_t)(row
- rowFirst
) >= lineData
.GetRowCount() )
3029 res
= wxTE_HT_BELOW
;
3031 row
= lineData
.GetRowCount() + rowFirst
- 1;
3034 else // not the last row
3036 const wxWrappedLineData
&
3037 lineNextData
= linesData
[cur
+ 1];
3038 if ( !WData().IsValidLine(cur
+ 1) )
3039 LayoutLines(cur
+ 1);
3040 found
= row
< lineNextData
.GetFirstRow();
3045 colRowStart
= lineData
.GetRowStart(row
- rowFirst
);
3046 rowLen
= lineData
.GetRowLength(row
- rowFirst
,
3047 GetLines()[cur
].length());
3061 if ( res
== wxTE_HT_ON_TEXT
)
3063 // now find the position in the line
3064 wxString lineText
= GetLineText(row
),
3067 if ( colRowStart
|| rowLen
)
3069 // look in this row only, not in whole line
3070 rowText
= lineText
.Mid(colRowStart
, rowLen
);
3074 // just take the whole string
3080 res
= HitTestLine(GetTextToShow(rowText
), x1
, colStart
);
3084 if ( colRowStartOut
)
3086 // give them the column offset in this ROW in pixels
3087 *colRowStartOut
= colRowStart
;
3090 // take into account that the ROW doesn't start in the
3091 // beginning of the LINE
3092 *colStart
+= colRowStart
;
3097 // the hit test result we return is for x1, so throw out
3098 // the result for x2 here
3099 int x2
= x1
+ x20
- x10
;
3100 (void)HitTestLine(GetTextToShow(rowText
), x2
, colEnd
);
3102 *colEnd
+= colRowStart
;
3106 else // before/after vertical text span
3110 // fill the column with the first/last position in the
3111 // corresponding line
3112 if ( res
== wxTE_HT_BEFORE
)
3114 else // res == wxTE_HT_BELOW
3115 *colStart
= GetLineText(GetNumberOfLines() - 1).length();
3121 // give them the row in text coords (as is)
3128 bool wxTextCtrl::GetLineAndRow(wxTextCoord row
,
3129 wxTextCoord
*lineOut
,
3130 wxTextCoord
*rowInLineOut
) const
3138 int nLines
= GetNumberOfLines();
3141 const wxArrayWrappedLinesData
& linesData
= WData().m_linesData
;
3142 for ( line
= 0; line
< nLines
; line
++ )
3144 if ( !WData().IsValidLine(line
) )
3147 if ( row
< linesData
[line
].GetNextRow() )
3149 // we found the right line
3150 rowInLine
= row
- linesData
[line
].GetFirstRow();
3156 if ( line
== nLines
)
3158 // the row is out of range
3162 else // no line wrapping, everything is easy
3164 if ( row
>= nLines
)
3173 *rowInLineOut
= rowInLine
;
3178 // ----------------------------------------------------------------------------
3180 // ----------------------------------------------------------------------------
3183 wxTextCtrl has not one but two scrolling mechanisms: one is semi-automatic
3184 scrolling in both horizontal and vertical direction implemented using
3185 wxScrollHelper and the second one is manual scrolling implemented using
3186 SData().m_ofsHorz and used by the single line controls without scroll bar.
3188 The first version (the standard one) always scrolls by fixed amount which is
3189 fine for vertical scrolling as all lines have the same height but is rather
3190 ugly for horizontal scrolling if proportional font is used. This is why we
3191 manually update and use SData().m_ofsHorz which contains the length of the string
3192 which is hidden beyond the left borde. An important property of text
3193 controls using this kind of scrolling is that an entire number of characters
3194 is always shown and that parts of characters never appear on display -
3195 neither in the leftmost nor rightmost positions.
3197 Once again, for multi line controls SData().m_ofsHorz is always 0 and scrolling is
3198 done as usual for wxScrollWindow.
3201 void wxTextCtrl::ShowHorzPosition(wxCoord pos
)
3203 wxASSERT_MSG( IsSingleLine(), _T("doesn't work for multiline") );
3205 // pos is the logical position to show
3207 // SData().m_ofsHorz is the fisrt logical position shown
3208 if ( pos
< SData().m_ofsHorz
)
3212 HitTestLine(m_value
, pos
, &col
);
3217 wxCoord width
= m_rectText
.width
;
3220 // if we are called from the ctor, m_rectText is not initialized
3221 // yet, so do it now
3223 width
= m_rectText
.width
;
3226 // SData().m_ofsHorz + width is the last logical position shown
3227 if ( pos
> SData().m_ofsHorz
+ width
)
3231 HitTestLine(m_value
, pos
- width
, &col
);
3232 ScrollText(col
+ 1);
3237 // scroll the window horizontally so that the first visible character becomes
3238 // the one at this position
3239 void wxTextCtrl::ScrollText(wxTextCoord col
)
3241 wxASSERT_MSG( IsSingleLine(),
3242 _T("ScrollText() is for single line controls only") );
3244 // never scroll beyond the left border
3248 // OPT: could only get the extent of the part of the string between col
3249 // and SData().m_colStart
3250 wxCoord ofsHorz
= GetTextWidth(GetLineText(0).Left(col
));
3252 if ( ofsHorz
!= SData().m_ofsHorz
)
3254 // remember the last currently used pixel
3255 int posLastVisible
= SData().m_posLastVisible
;
3256 if ( posLastVisible
== -1 )
3258 // this may happen when we're called very early, during the
3259 // controls construction
3260 UpdateLastVisible();
3262 posLastVisible
= SData().m_posLastVisible
;
3265 // NB1: to scroll to the right, offset must be negative, hence the
3266 // order of operands
3267 int dx
= SData().m_ofsHorz
- ofsHorz
;
3269 // NB2: we call Refresh() below which results in a call to
3270 // DoDraw(), so we must update SData().m_ofsHorz before calling it
3271 SData().m_ofsHorz
= ofsHorz
;
3272 SData().m_colStart
= col
;
3274 // after changing m_colStart, recalc the last visible position: we need
3275 // to recalc the last visible position beore scrolling in order to make
3276 // it appear exactly at the right edge of the text area after scrolling
3277 UpdateLastVisible();
3282 // we want to force the update of it after scrolling
3283 SData().m_colLastVisible
= -1;
3287 // scroll only the rectangle inside which there is the text
3288 wxRect rect
= m_rectText
;
3289 rect
.width
= posLastVisible
;
3291 rect
= ScrollNoRefresh(dx
, 0, &rect
);
3294 we need to manually refresh the part which ScrollWindow() doesn't
3295 refresh (with new API this means the part outside the rect returned
3296 by ScrollNoRefresh): indeed, if we had this:
3300 where '*' is text and 'o' is blank area at the end (too small to
3301 hold the next char) then after scrolling by 2 positions to the left
3306 where 'R' is the area refreshed by ScrollWindow() - but we still
3307 need to refresh the 'o' at the end as it may be now big enough to
3308 hold the new character shifted into view.
3310 when we are scrolling to the right, we need to update this rect as
3311 well because it might have contained something before but doesn't
3312 contain anything any more
3315 // we can combine both rectangles into one when scrolling to the left,
3316 // but we need two separate Refreshes() otherwise
3319 // refresh the uncovered part on the left
3320 Refresh(TRUE
, &rect
);
3322 // and now the area on the right
3323 rect
.x
= m_rectText
.x
+ posLastVisible
;
3324 rect
.width
= m_rectText
.width
- posLastVisible
;
3326 else // scrolling to the left
3328 // just extend the rect covering the uncovered area to the edge of
3330 rect
.width
+= m_rectText
.width
- posLastVisible
;
3333 Refresh(TRUE
, &rect
);
3335 // I don't know exactly why is this needed here but without it we may
3336 // scroll the window again (from the same method) before the previously
3337 // invalidated area is repainted when typing *very* quickly - and this
3338 // may lead to the display corruption
3343 void wxTextCtrl::CalcUnscrolledPosition(int x
, int y
, int *xx
, int *yy
) const
3345 if ( IsSingleLine() )
3347 // we don't use wxScrollHelper
3349 *xx
= x
+ SData().m_ofsHorz
;
3355 // let the base class do it
3356 wxScrollHelper::CalcUnscrolledPosition(x
, y
, xx
, yy
);
3360 void wxTextCtrl::CalcScrolledPosition(int x
, int y
, int *xx
, int *yy
) const
3362 if ( IsSingleLine() )
3364 // we don't use wxScrollHelper
3366 *xx
= x
- SData().m_ofsHorz
;
3372 // let the base class do it
3373 wxScrollHelper::CalcScrolledPosition(x
, y
, xx
, yy
);
3377 void wxTextCtrl::DoPrepareDC(wxDC
& dc
)
3379 // for single line controls we only have to deal with SData().m_ofsHorz and it's
3380 // useless to call base class version as they don't use normal scrolling
3381 if ( IsSingleLine() && SData().m_ofsHorz
)
3383 // adjust the DC origin if the text is shifted
3384 wxPoint pt
= dc
.GetDeviceOrigin();
3385 dc
.SetDeviceOrigin(pt
.x
- SData().m_ofsHorz
, pt
.y
);
3389 wxScrollHelper::DoPrepareDC(dc
);
3393 void wxTextCtrl::UpdateMaxWidth(wxTextCoord line
)
3397 // check if the max width changes after this line was modified
3398 wxCoord widthMaxOld
= MData().m_widthMax
,
3400 GetTextExtent(GetLineText(line
), &width
, NULL
);
3402 if ( line
== MData().m_lineLongest
)
3404 // this line was the longest one, is it still?
3405 if ( width
> MData().m_widthMax
)
3407 MData().m_widthMax
= width
;
3409 else if ( width
< MData().m_widthMax
)
3411 // we need to find the new longest line
3414 //else: its length didn't change, nothing to do
3416 else // it wasn't the longest line, but maybe it became it?
3418 // GetMaxWidth() and not MData().m_widthMax as it might be not calculated yet
3419 if ( width
> GetMaxWidth() )
3421 MData().m_widthMax
= width
;
3422 MData().m_lineLongest
= line
;
3426 MData().m_updateScrollbarX
= MData().m_widthMax
!= widthMaxOld
;
3429 void wxTextCtrl::RecalcFontMetrics()
3431 m_heightLine
= GetCharHeight();
3432 m_widthAvg
= GetCharWidth();
3435 void wxTextCtrl::RecalcMaxWidth()
3437 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3439 MData().m_widthMax
= -1;
3440 (void)GetMaxWidth();
3443 wxCoord
wxTextCtrl::GetMaxWidth() const
3445 if ( MData().m_widthMax
== -1 )
3449 // OPT: should we remember the widths of all the lines?
3451 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
3452 wxClientDC
dc(self
);
3453 dc
.SetFont(GetFont());
3455 self
->MData().m_widthMax
= 0;
3457 size_t count
= GetLineCount();
3458 for ( size_t n
= 0; n
< count
; n
++ )
3461 dc
.GetTextExtent(GetLines()[n
], &width
, NULL
);
3462 if ( width
> MData().m_widthMax
)
3464 // remember the width and the line which has it
3465 self
->MData().m_widthMax
= width
;
3466 self
->MData().m_lineLongest
= n
;
3471 wxASSERT_MSG( MData().m_widthMax
!= -1, _T("should have at least 1 line") );
3473 return MData().m_widthMax
;
3476 void wxTextCtrl::UpdateScrollbars()
3478 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3480 wxSize size
= GetRealTextArea().GetSize();
3482 // is our height enough to show all items?
3483 wxTextCoord nRows
= GetRowCount();
3484 wxCoord lineHeight
= GetLineHeight();
3485 bool showScrollbarY
= nRows
*lineHeight
> size
.y
;
3487 // is our width enough to show the longest line?
3488 wxCoord charWidth
, maxWidth
;
3489 bool showScrollbarX
;
3492 charWidth
= GetAverageWidth();
3493 maxWidth
= GetMaxWidth();
3494 showScrollbarX
= maxWidth
> size
.x
;
3496 else // never show the horz scrollbar
3498 // just to suppress compiler warnings about using uninit vars below
3499 charWidth
= maxWidth
= 0;
3501 showScrollbarX
= FALSE
;
3504 // calc the scrollbars ranges
3505 int scrollRangeX
= showScrollbarX
3506 ? (maxWidth
+ 2*charWidth
- 1) / charWidth
3508 int scrollRangeY
= showScrollbarY
? nRows
: 0;
3510 int scrollRangeXOld
= MData().m_scrollRangeX
,
3511 scrollRangeYOld
= MData().m_scrollRangeY
;
3512 if ( (scrollRangeY
!= scrollRangeYOld
) || (scrollRangeX
!= scrollRangeXOld
) )
3515 GetViewStart(&x
, &y
);
3518 // we want to leave the scrollbars at the same position which means
3519 // that x and y have to be adjusted as the number of positions may have
3522 // the number of positions is calculated from knowing that last
3523 // position = range - thumbSize and thumbSize == pageSize which is
3524 // equal to the window width / pixelsPerLine
3525 if ( scrollRangeXOld
)
3527 x
*= scrollRangeX
- m_rectText
.width
/ charWidth
;
3528 x
/= scrollRangeXOld
- m_rectText
.width
/ charWidth
;
3531 if ( scrollRangeYOld
)
3532 y
*= scrollRangeY
/ scrollRangeYOld
;
3535 SetScrollbars(charWidth
, lineHeight
,
3536 scrollRangeX
, scrollRangeY
,
3538 TRUE
/* no refresh */);
3540 if ( scrollRangeXOld
)
3542 x
*= scrollRangeX
- m_rectText
.width
/ charWidth
;
3543 x
/= scrollRangeXOld
- m_rectText
.width
/ charWidth
;
3547 MData().m_scrollRangeX
= scrollRangeX
;
3548 MData().m_scrollRangeY
= scrollRangeY
;
3550 // bring the current position in view
3554 MData().m_updateScrollbarX
=
3555 MData().m_updateScrollbarY
= FALSE
;
3558 void wxTextCtrl::OnIdle(wxIdleEvent
& event
)
3560 // notice that single line text control never has scrollbars
3561 if ( !IsSingleLine() &&
3562 (MData().m_updateScrollbarX
|| MData().m_updateScrollbarY
) )
3570 bool wxTextCtrl::SendAutoScrollEvents(wxScrollWinEvent
& event
) const
3572 bool forward
= event
.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN
;
3573 if ( event
.GetOrientation() == wxHORIZONTAL
)
3575 return forward
? m_curCol
<= GetLineLength(m_curRow
) : m_curCol
> 0;
3579 return forward
? m_curRow
< GetNumberOfLines() : m_curRow
> 0;
3583 // ----------------------------------------------------------------------------
3585 // ----------------------------------------------------------------------------
3587 void wxTextCtrl::RefreshSelection()
3589 if ( HasSelection() )
3591 RefreshTextRange(m_selStart
, m_selEnd
);
3595 void wxTextCtrl::RefreshLineRange(wxTextCoord lineFirst
, wxTextCoord lineLast
)
3597 wxASSERT_MSG( lineFirst
<= lineLast
|| !lineLast
,
3598 _T("no lines to refresh") );
3601 // rect.x is already 0
3602 rect
.width
= m_rectText
.width
;
3603 wxCoord h
= GetLineHeight();
3605 wxTextCoord rowFirst
;
3606 if ( lineFirst
< GetNumberOfLines() )
3608 rowFirst
= GetFirstRowOfLine(lineFirst
);
3610 else // lineFirst == GetNumberOfLines()
3612 // lineFirst may be beyond the last line only if we refresh till
3613 // the end, otherwise it's illegal
3614 wxASSERT_MSG( lineFirst
== GetNumberOfLines() && !lineLast
,
3615 _T("invalid line range") );
3617 rowFirst
= GetRowAfterLine(lineFirst
- 1);
3620 rect
.y
= rowFirst
*h
;
3624 // refresh till this line (inclusive)
3625 wxTextCoord rowLast
= GetRowAfterLine(lineLast
);
3627 rect
.height
= (rowLast
- rowFirst
+ 1)*h
;
3629 else // lineLast == 0 means to refresh till the end
3631 // FIXME: calc it exactly
3632 rect
.height
= 32000;
3635 RefreshTextRect(rect
);
3638 void wxTextCtrl::RefreshTextRange(wxTextPos start
, wxTextPos end
)
3640 wxCHECK_RET( start
!= -1 && end
!= -1,
3641 _T("invalid RefreshTextRange() arguments") );
3643 // accept arguments in any order as it is more conenient for the caller
3644 OrderPositions(start
, end
);
3646 // this is acceptable but we don't do anything in this case
3650 wxTextPos colStart
, lineStart
;
3651 if ( !PositionToXY(start
, &colStart
, &lineStart
) )
3653 // the range is entirely beyond the end of the text, nothing to do
3657 wxTextCoord colEnd
, lineEnd
;
3658 if ( !PositionToXY(end
, &colEnd
, &lineEnd
) )
3660 // the range spans beyond the end of text, refresh to the end
3662 lineEnd
= GetNumberOfLines() - 1;
3665 // refresh all lines one by one
3666 for ( wxTextCoord line
= lineStart
; line
<= lineEnd
; line
++ )
3668 // refresh the first line from the start of the range to the end, the
3669 // intermediate ones entirely and the last one from the beginning to
3670 // the end of the range
3671 wxTextPos posStart
= line
== lineStart
? colStart
: 0;
3673 if ( (line
!= lineEnd
) || (colEnd
== -1) )
3675 // intermediate line or the last one but we need to refresh it
3676 // until the end anyhow - do it
3677 posCount
= wxSTRING_MAXLEN
;
3681 // refresh just the positions in between the start and the end one
3682 posCount
= colEnd
- posStart
;
3686 RefreshColRange(line
, posStart
, posCount
);
3690 void wxTextCtrl::RefreshColRange(wxTextCoord line
,
3694 wxString text
= GetLineText(line
);
3696 wxASSERT_MSG( (size_t)start
<= text
.length() && count
,
3697 _T("invalid RefreshColRange() parameter") );
3699 RefreshPixelRange(line
,
3700 GetTextWidth(text
.Left((size_t)start
)),
3701 GetTextWidth(text
.Mid((size_t)start
, (size_t)count
)));
3704 // this method accepts "logical" coords in the sense that they are coordinates
3705 // in a logical line but it can span several rows if we wrap lines and
3706 // RefreshPixelRange() will then refresh several rows
3707 void wxTextCtrl::RefreshPixelRange(wxTextCoord line
,
3711 // we will use line text only in line wrap case
3715 text
= GetLineText(line
);
3718 // special case: width == 0 means to refresh till the end of line
3721 // refresh till the end of visible line
3722 width
= GetTotalWidth();
3726 // refresh till the end of text
3727 wxCoord widthAll
= GetTextWidth(text
);
3729 // extend width to the end of ROW
3730 width
= widthAll
- widthAll
% width
+ width
;
3733 // no need to refresh beyond the end of line
3736 //else: just refresh the specified part
3738 wxCoord h
= GetLineHeight();
3741 rect
.y
= GetFirstRowOfLine(line
)*h
;
3746 // (1) skip all rows which we don't touch at all
3747 const wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
3748 if ( !WData().IsValidLine(line
) )
3751 wxCoord wLine
= 0; // suppress compiler warning about uninit var
3752 size_t rowLast
= lineData
.GetRowCount(),
3754 while ( (row
< rowLast
) &&
3755 (rect
.x
> (wLine
= lineData
.GetRowWidth(row
++))) )
3761 // (2) now refresh all lines except the last one: note that the first
3762 // line is refreshed from the given start to the end, all the next
3764 while ( (row
< rowLast
) && (width
> wLine
- rect
.x
) )
3766 rect
.width
= GetTotalWidth() - rect
.x
;
3767 RefreshTextRect(rect
);
3769 width
-= wLine
- rect
.x
;
3773 wLine
= lineData
.GetRowWidth(row
++);
3776 // (3) the code below will refresh the last line
3781 RefreshTextRect(rect
);
3784 void wxTextCtrl::RefreshTextRect(const wxRect
& rectClient
, bool textOnly
)
3787 CalcScrolledPosition(rectClient
.x
, rectClient
.y
, &rect
.x
, &rect
.y
);
3788 rect
.width
= rectClient
.width
;
3789 rect
.height
= rectClient
.height
;
3791 // account for the text area offset
3792 rect
.Offset(m_rectText
.GetPosition());
3794 // don't refresh beyond the text area unless we're refreshing the line wrap
3795 // marks in which case textOnly is FALSE
3798 if ( rect
.GetRight() > m_rectText
.GetRight() )
3800 rect
.SetRight(m_rectText
.GetRight());
3802 if ( rect
.width
<= 0 )
3804 // nothing to refresh
3810 // check the bottom boundary always, even for the line wrap marks
3811 if ( rect
.GetBottom() > m_rectText
.GetBottom() )
3813 rect
.SetBottom(m_rectText
.GetBottom());
3815 if ( rect
.height
<= 0 )
3817 // nothing to refresh
3822 // never refresh before the visible rect
3823 if ( rect
.x
< m_rectText
.x
)
3824 rect
.x
= m_rectText
.x
;
3826 if ( rect
.y
< m_rectText
.y
)
3827 rect
.y
= m_rectText
.y
;
3829 wxLogTrace(_T("text"), _T("Refreshing (%d, %d)-(%d, %d)"),
3830 rect
.x
, rect
.y
, rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
3832 Refresh(TRUE
, &rect
);
3835 void wxTextCtrl::RefreshLineWrapMarks(wxTextCoord rowFirst
,
3836 wxTextCoord rowLast
)
3838 if ( WData().m_widthMark
)
3841 rectMarks
.x
= m_rectText
.width
;
3842 rectMarks
.width
= WData().m_widthMark
;
3843 rectMarks
.y
= rowFirst
*GetLineHeight();
3844 rectMarks
.height
= (rowLast
- rowFirst
)*GetLineHeight();
3846 RefreshTextRect(rectMarks
, FALSE
/* don't limit to text area */);
3850 // ----------------------------------------------------------------------------
3852 // ----------------------------------------------------------------------------
3854 void wxTextCtrl::DoDrawBorder(wxDC
& dc
, const wxRect
& rect
)
3856 m_renderer
->DrawTextBorder(dc
, GetBorder(), rect
, GetStateFlags());
3859 // ----------------------------------------------------------------------------
3860 // client area drawing
3861 // ----------------------------------------------------------------------------
3864 Several remarks about wxTextCtrl redraw logic:
3866 1. only the regions which must be updated are redrawn, this means that we
3867 never Refresh() the entire window but use RefreshPixelRange() and
3868 ScrollWindow() which only refresh small parts of it and iterate over the
3869 update region in our DoDraw()
3871 2. the text displayed on the screen is obtained using GetTextToShow(): it
3872 should be used for all drawing/measuring
3875 wxString
wxTextCtrl::GetTextToShow(const wxString
& text
) const
3879 textShown
= wxString(_T('*'), text
.length());
3886 void wxTextCtrl::DoDrawTextInRect(wxDC
& dc
, const wxRect
& rectUpdate
)
3888 // debugging trick to see the update rect visually
3890 static int s_countUpdates
= -1;
3891 if ( s_countUpdates
!= -1 )
3893 wxWindowDC
dc(this);
3894 dc
.SetBrush(*(++s_countUpdates
% 2 ? wxRED_BRUSH
: wxGREEN_BRUSH
));
3895 dc
.SetPen(*wxTRANSPARENT_PEN
);
3896 dc
.DrawRectangle(rectUpdate
);
3898 #endif // WXDEBUG_TEXT
3900 // calculate the range lineStart..lineEnd of lines to redraw
3901 wxTextCoord lineStart
, lineEnd
;
3902 if ( IsSingleLine() )
3909 wxPoint pt
= rectUpdate
.GetPosition();
3910 (void)HitTest(pt
, NULL
, &lineStart
);
3912 pt
.y
+= rectUpdate
.height
;
3913 (void)HitTest(pt
, NULL
, &lineEnd
);
3916 // prepare for drawing
3917 wxCoord hLine
= GetLineHeight();
3919 // these vars will be used for hit testing of the current row
3920 wxCoord y
= rectUpdate
.y
;
3921 const wxCoord x1
= rectUpdate
.x
;
3922 const wxCoord x2
= rectUpdate
.x
+ rectUpdate
.width
;
3925 rectText
.height
= hLine
;
3926 wxCoord yClient
= y
- GetClientAreaOrigin().y
;
3928 // we want to always start at the top of the line, otherwise if we redraw a
3929 // rect whose top is in the middle of a line, we'd draw this line shifted
3930 yClient
-= (yClient
- m_rectText
.y
) % hLine
;
3932 if ( IsSingleLine() )
3934 rectText
.y
= yClient
;
3936 else // multiline, adjust for scrolling
3938 CalcUnscrolledPosition(0, yClient
, NULL
, &rectText
.y
);
3941 wxRenderer
*renderer
= GetRenderer();
3943 // do draw the invalidated parts of each line: note that we iterate here
3944 // over ROWs, not over LINEs
3945 for ( wxTextCoord line
= lineStart
;
3946 y
< rectUpdate
.y
+ rectUpdate
.height
;
3948 rectText
.y
+= hLine
)
3950 // calculate the update rect in text positions for this line
3951 wxTextCoord colStart
, colEnd
, colRowStart
;
3952 wxTextCtrlHitTestResult ht
= HitTest2(y
, x1
, x2
,
3953 &line
, &colStart
, &colEnd
,
3956 if ( (ht
== wxTE_HT_BEYOND
) || (ht
== wxTE_HT_BELOW
) )
3958 wxASSERT_MSG( line
<= lineEnd
, _T("how did we get that far?") );
3960 if ( line
== lineEnd
)
3962 // we redrew everything
3966 // the update rect is beyond the end of line, no need to redraw
3967 // anything on this line - but continue with the remaining ones
3971 // for single line controls we may additionally cut off everything
3972 // which is to the right of the last visible position
3973 if ( IsSingleLine() )
3975 // don't show the columns which are scrolled out to the left
3976 if ( colStart
< SData().m_colStart
)
3977 colStart
= SData().m_colStart
;
3979 // colEnd may be less than colStart if colStart was changed by the
3981 if ( colEnd
< colStart
)
3984 // don't draw the chars beyond the rightmost one
3985 if ( SData().m_colLastVisible
== -1 )
3987 // recalculate this rightmost column
3988 UpdateLastVisible();
3991 if ( colStart
> SData().m_colLastVisible
)
3993 // don't bother redrawing something that is beyond the last
3998 if ( colEnd
> SData().m_colLastVisible
)
4000 colEnd
= SData().m_colLastVisible
;
4004 // extract the part of line we need to redraw
4005 wxString textLine
= GetTextToShow(GetLineText(line
));
4006 wxString text
= textLine
.Mid(colStart
, colEnd
- colStart
+ 1);
4008 // now deal with the selection: only do something if at least part of
4009 // the line is selected
4010 wxTextPos selStart
, selEnd
;
4011 if ( GetSelectedPartOfLine(line
, &selStart
, &selEnd
) )
4013 // and if this part is (at least partly) in the current row
4014 if ( (selStart
<= colEnd
) &&
4015 (selEnd
>= wxMax(colStart
, colRowStart
)) )
4017 // these values are relative to the start of the line while the
4018 // string passed to DrawTextLine() is only part of it, so
4019 // adjust the selection range accordingly
4020 selStart
-= colStart
;
4026 if ( (size_t)selEnd
>= text
.length() )
4027 selEnd
= text
.length();
4031 // reset selStart and selEnd to avoid passing them to
4032 // DrawTextLine() below
4038 // calculate the text coords on screen
4039 wxASSERT_MSG( colStart
>= colRowStart
, _T("invalid string part") );
4040 wxCoord ofsStart
= GetTextWidth(
4041 textLine
.Mid(colRowStart
,
4042 colStart
- colRowStart
));
4043 rectText
.x
= m_rectText
.x
+ ofsStart
;
4044 rectText
.width
= GetTextWidth(text
);
4047 renderer
->DrawTextLine(dc
, text
, rectText
, selStart
, selEnd
,
4049 wxLogTrace(_T("text"), _T("Line %ld: positions %ld-%ld redrawn."),
4050 line
, colStart
, colEnd
);
4054 void wxTextCtrl::DoDrawLineWrapMarks(wxDC
& dc
, const wxRect
& rectUpdate
)
4056 wxASSERT_MSG( WrapLines() && WData().m_widthMark
,
4057 _T("shouldn't be called at all") );
4059 wxRenderer
*renderer
= GetRenderer();
4062 rectMark
.x
= rectUpdate
.x
;
4063 rectMark
.width
= rectUpdate
.width
;
4064 wxCoord yTop
= GetClientAreaOrigin().y
;
4065 CalcUnscrolledPosition(0, rectUpdate
.y
- yTop
, NULL
, &rectMark
.y
);
4066 wxCoord hLine
= GetLineHeight();
4067 rectMark
.height
= hLine
;
4069 wxTextCoord line
, rowInLine
;
4072 CalcUnscrolledPosition(0, rectUpdate
.GetBottom() - yTop
, NULL
, &yBottom
);
4073 for ( ; rectMark
.y
< yBottom
; rectMark
.y
+= hLine
)
4075 if ( !GetLineAndRow(rectMark
.y
/ hLine
, &line
, &rowInLine
) )
4077 // we went beyond the end of text
4081 // is this row continued on the next one?
4082 if ( !WData().m_linesData
[line
].IsLastRow(rowInLine
) )
4084 renderer
->DrawLineWrapMark(dc
, rectMark
);
4089 void wxTextCtrl::DoDraw(wxControlRenderer
*renderer
)
4091 // hide the caret while we're redrawing the window and show it after we are
4093 wxCaretSuspend
cs(this);
4096 wxDC
& dc
= renderer
->GetDC();
4097 dc
.SetFont(GetFont());
4098 dc
.SetTextForeground(GetForegroundColour());
4100 // get the intersection of the update region with the text area: note that
4101 // the update region is in window coords and text area is in the client
4102 // ones, so it must be shifted before computing intersection
4103 wxRegion rgnUpdate
= GetUpdateRegion();
4104 wxRect rectTextArea
= GetRealTextArea();
4105 wxPoint pt
= GetClientAreaOrigin();
4106 wxRect rectTextAreaAdjusted
= rectTextArea
;
4107 rectTextAreaAdjusted
.x
+= pt
.x
;
4108 rectTextAreaAdjusted
.y
+= pt
.y
;
4109 rgnUpdate
.Intersect(rectTextAreaAdjusted
);
4111 // even though the drawing is already clipped to the update region, we must
4112 // explicitly clip it to the rect we will use as otherwise parts of letters
4113 // might be drawn outside of it (if even a small part of a charater is
4114 // inside, HitTest() will return its column and DrawText() can't draw only
4115 // the part of the character, of course)
4117 // FIXME: is this really a bug in wxMSW?
4118 rectTextArea
.width
--;
4120 dc
.SetClippingRegion(rectTextArea
);
4122 // adjust for scrolling
4125 // and now refresh the invalidated parts of the window
4126 wxRegionIterator
iter(rgnUpdate
);
4127 for ( ; iter
.HaveRects(); iter
++ )
4129 wxRect r
= iter
.GetRect();
4131 // this is a workaround for wxGTK::wxRegion bug
4133 if ( !r
.width
|| !r
.height
)
4135 // ignore invalid rect
4140 DoDrawTextInRect(dc
, r
);
4143 // now redraw the line wrap marks (if we draw them)
4144 if ( WrapLines() && WData().m_widthMark
)
4146 // this is the rect inside which line wrap marks are drawn
4148 rectMarks
.x
= rectTextAreaAdjusted
.GetRight() + 1;
4149 rectMarks
.y
= rectTextAreaAdjusted
.y
;
4150 rectMarks
.width
= WData().m_widthMark
;
4151 rectMarks
.height
= rectTextAreaAdjusted
.height
;
4153 rgnUpdate
= GetUpdateRegion();
4154 rgnUpdate
.Intersect(rectMarks
);
4156 wxRect rectUpdate
= rgnUpdate
.GetBox();
4157 if ( rectUpdate
.width
&& rectUpdate
.height
)
4159 // the marks are outside previously set clipping region
4160 dc
.DestroyClippingRegion();
4162 DoDrawLineWrapMarks(dc
, rectUpdate
);
4166 // show caret first time only: we must show it after drawing the text or
4167 // the display can be corrupted when it's hidden
4168 if ( !m_hasCaret
&& GetCaret() )
4176 // ----------------------------------------------------------------------------
4178 // ----------------------------------------------------------------------------
4180 bool wxTextCtrl::SetFont(const wxFont
& font
)
4182 if ( !wxControl::SetFont(font
) )
4185 // and refresh everything, of course
4186 InitInsertionPoint();
4189 // update geometry parameters
4191 RecalcFontMetrics();
4192 if ( !IsSingleLine() )
4198 // recreate it, in fact
4206 bool wxTextCtrl::Enable(bool enable
)
4208 if ( !wxTextCtrlBase::Enable(enable
) )
4216 void wxTextCtrl::CreateCaret()
4222 // FIXME use renderer
4223 caret
= new wxCaret(this, 1, GetLineHeight());
4225 caret
->SetBlinkTime(0);
4230 // read only controls don't have the caret
4231 caret
= (wxCaret
*)NULL
;
4234 // SetCaret() will delete the old caret if any
4238 void wxTextCtrl::ShowCaret(bool show
)
4240 wxCaret
*caret
= GetCaret();
4243 // (re)position caret correctly
4244 caret
->Move(GetCaretPosition());
4246 // and show it there
4251 // ----------------------------------------------------------------------------
4252 // vertical scrolling (multiline only)
4253 // ----------------------------------------------------------------------------
4255 size_t wxTextCtrl::GetLinesPerPage() const
4257 if ( IsSingleLine() )
4260 return GetRealTextArea().height
/ GetLineHeight();
4263 wxTextPos
wxTextCtrl::GetPositionAbove()
4265 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE
,
4266 _T("can't move cursor vertically in a single line control") );
4268 // move the cursor up by one ROW not by one LINE: this means that
4269 // we should really use HitTest() and not just go to the same
4270 // position in the previous line
4271 wxPoint pt
= GetCaretPosition() - m_rectText
.GetPosition();
4272 if ( MData().m_xCaret
== -1 )
4274 // remember the initial cursor abscissa
4275 MData().m_xCaret
= pt
.x
;
4279 // use the remembered abscissa
4280 pt
.x
= MData().m_xCaret
;
4283 CalcUnscrolledPosition(pt
.x
, pt
.y
, &pt
.x
, &pt
.y
);
4284 pt
.y
-= GetLineHeight();
4286 wxTextCoord col
, row
;
4287 if ( HitTestLogical(pt
, &col
, &row
) == wxTE_HT_BEFORE
)
4289 // can't move further
4290 return INVALID_POS_VALUE
;
4293 return XYToPosition(col
, row
);
4296 wxTextPos
wxTextCtrl::GetPositionBelow()
4298 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE
,
4299 _T("can't move cursor vertically in a single line control") );
4301 // see comments for wxACTION_TEXT_UP
4302 wxPoint pt
= GetCaretPosition() - m_rectText
.GetPosition();
4303 if ( MData().m_xCaret
== -1 )
4305 // remember the initial cursor abscissa
4306 MData().m_xCaret
= pt
.x
;
4310 // use the remembered abscissa
4311 pt
.x
= MData().m_xCaret
;
4314 CalcUnscrolledPosition(pt
.x
, pt
.y
, &pt
.x
, &pt
.y
);
4315 pt
.y
+= GetLineHeight();
4317 wxTextCoord col
, row
;
4318 if ( HitTestLogical(pt
, &col
, &row
) == wxTE_HT_BELOW
)
4320 // can't go further down
4321 return INVALID_POS_VALUE
;
4324 // note that wxTE_HT_BEYOND is ok: it happens when we go down
4325 // from a longer line to a shorter one, for example (OTOH
4326 // wxTE_HT_BEFORE can never happen)
4327 return XYToPosition(col
, row
);
4330 // ----------------------------------------------------------------------------
4332 // ----------------------------------------------------------------------------
4334 bool wxTextCtrl::PerformAction(const wxControlAction
& actionOrig
,
4336 const wxString
& strArg
)
4338 // has the text changed as result of this action?
4339 bool textChanged
= FALSE
;
4341 // the remembered cursor abscissa for multiline text controls is usually
4342 // reset after each user action but for ones which do use it (UP and DOWN
4343 // for example) we shouldn't do it - as indicated by this flag
4344 bool rememberAbscissa
= FALSE
;
4346 // the command this action corresponds to or NULL if this action doesn't
4347 // change text at all or can't be undone
4348 wxTextCtrlCommand
*command
= (wxTextCtrlCommand
*)NULL
;
4353 if ( actionOrig
.StartsWith(wxACTION_TEXT_PREFIX_DEL
, &action
) )
4358 else if ( actionOrig
.StartsWith(wxACTION_TEXT_PREFIX_SEL
, &action
) )
4362 else // not selection nor delete action
4364 action
= actionOrig
;
4367 // set newPos to -2 as it can't become equal to it in the assignments below
4368 // (but it can become -1)
4369 wxTextPos newPos
= INVALID_POS_VALUE
;
4371 if ( action
== wxACTION_TEXT_HOME
)
4373 newPos
= m_curPos
- m_curCol
;
4375 else if ( action
== wxACTION_TEXT_END
)
4377 newPos
= m_curPos
+ GetLineLength(m_curRow
) - m_curCol
;
4379 else if ( (action
== wxACTION_TEXT_GOTO
) ||
4380 (action
== wxACTION_TEXT_FIRST
) ||
4381 (action
== wxACTION_TEXT_LAST
) )
4383 if ( action
== wxACTION_TEXT_FIRST
)
4385 else if ( action
== wxACTION_TEXT_LAST
)
4386 numArg
= GetLastPosition();
4387 //else: numArg already contains the position
4391 else if ( action
== wxACTION_TEXT_UP
)
4393 if ( !IsSingleLine() )
4395 newPos
= GetPositionAbove();
4397 if ( newPos
!= INVALID_POS_VALUE
)
4399 // remember where the cursor original had been
4400 rememberAbscissa
= TRUE
;
4404 else if ( action
== wxACTION_TEXT_DOWN
)
4406 if ( !IsSingleLine() )
4408 newPos
= GetPositionBelow();
4410 if ( newPos
!= INVALID_POS_VALUE
)
4412 // remember where the cursor original had been
4413 rememberAbscissa
= TRUE
;
4417 else if ( action
== wxACTION_TEXT_LEFT
)
4419 newPos
= m_curPos
- 1;
4421 else if ( action
== wxACTION_TEXT_WORD_LEFT
)
4423 newPos
= GetWordStart();
4425 else if ( action
== wxACTION_TEXT_RIGHT
)
4427 newPos
= m_curPos
+ 1;
4429 else if ( action
== wxACTION_TEXT_WORD_RIGHT
)
4431 newPos
= GetWordEnd();
4433 else if ( action
== wxACTION_TEXT_INSERT
)
4435 if ( IsEditable() && !strArg
.empty() )
4437 // inserting text can be undone
4438 command
= new wxTextCtrlInsertCommand(strArg
);
4443 else if ( (action
== wxACTION_TEXT_PAGE_UP
) ||
4444 (action
== wxACTION_TEXT_PAGE_DOWN
) )
4446 if ( !IsSingleLine() )
4448 size_t count
= GetLinesPerPage();
4449 if ( count
> PAGE_OVERLAP_IN_LINES
)
4451 // pages should overlap slightly to allow the reader to keep
4452 // orientation in the text
4453 count
-= PAGE_OVERLAP_IN_LINES
;
4456 // remember where the cursor original had been
4457 rememberAbscissa
= TRUE
;
4459 bool goUp
= action
== wxACTION_TEXT_PAGE_UP
;
4460 for ( size_t line
= 0; line
< count
; line
++ )
4462 wxTextPos pos
= goUp
? GetPositionAbove() : GetPositionBelow();
4463 if ( pos
== INVALID_POS_VALUE
)
4465 // can't move further
4469 MoveInsertionPoint(pos
);
4473 // we implement the Unix scrolling model here: cursor will always
4474 // be on the first line after Page Down and on the last one after
4477 // Windows programs usually keep the cursor line offset constant
4478 // but do we really need it?
4482 // find the line such that when it is the first one, the
4483 // current position is in the last line
4485 for ( size_t line
= 0; line
< count
; line
++ )
4487 pos
= GetPositionAbove();
4488 if ( pos
== INVALID_POS_VALUE
)
4491 MoveInsertionPoint(pos
);
4494 MoveInsertionPoint(newPos
);
4496 PositionToLogicalXY(pos
, NULL
, &y
);
4498 else // scrolled down
4500 PositionToLogicalXY(newPos
, NULL
, &y
);
4503 // scroll vertically only
4507 else if ( action
== wxACTION_TEXT_SEL_WORD
)
4509 SetSelection(GetWordStart(), GetWordEnd());
4511 else if ( action
== wxACTION_TEXT_ANCHOR_SEL
)
4515 else if ( action
== wxACTION_TEXT_EXTEND_SEL
)
4517 SetSelection(m_selAnchor
, numArg
);
4519 else if ( action
== wxACTION_TEXT_COPY
)
4523 else if ( action
== wxACTION_TEXT_CUT
)
4528 else if ( action
== wxACTION_TEXT_PASTE
)
4533 else if ( action
== wxACTION_TEXT_UNDO
)
4538 else if ( action
== wxACTION_TEXT_REDO
)
4545 return wxControl::PerformAction(action
, numArg
, strArg
);
4548 if ( newPos
!= INVALID_POS_VALUE
)
4550 // bring the new position into the range
4554 wxTextPos posLast
= GetLastPosition();
4555 if ( newPos
> posLast
)
4560 // if we have the selection, remove just it
4562 if ( HasSelection() )
4569 // otherwise delete everything between current position and
4571 if ( m_curPos
!= newPos
)
4576 else // nothing to delete
4578 // prevent test below from working
4579 from
= INVALID_POS_VALUE
;
4581 // and this is just to silent the compiler warning
4586 if ( from
!= INVALID_POS_VALUE
)
4588 command
= new wxTextCtrlRemoveCommand(from
, to
);
4591 else // cursor movement command
4594 DoSetInsertionPoint(newPos
);
4598 SetSelection(m_selAnchor
, m_curPos
);
4600 else // simple movement
4602 // clear the existing selection
4607 if ( !rememberAbscissa
&& !IsSingleLine() )
4609 MData().m_xCaret
= -1;
4615 // execute and remember it to be able to undo it later
4616 m_cmdProcessor
->Submit(command
);
4618 // undoable commands always change text
4621 else // no undoable command
4623 // m_cmdProcessor->StopCompressing()
4628 wxASSERT_MSG( IsEditable(), _T("non editable control changed?") );
4630 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, GetId());
4631 InitCommandEvent(event
);
4632 event
.SetString(GetValue());
4633 GetEventHandler()->ProcessEvent(event
);
4635 // as the text changed...
4636 m_isModified
= TRUE
;
4642 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
4644 // only process the key events from "simple keys" here
4645 if ( !event
.HasModifiers() )
4647 int keycode
= event
.GetKeyCode();
4648 if ( keycode
== WXK_RETURN
)
4650 if ( IsSingleLine() || (GetWindowStyle() & wxTE_PROCESS_ENTER
) )
4652 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, GetId());
4653 InitCommandEvent(event
);
4654 event
.SetString(GetValue());
4655 GetEventHandler()->ProcessEvent(event
);
4657 else // interpret <Enter> normally: insert new line
4659 PerformAction(wxACTION_TEXT_INSERT
, -1, _T('\n'));
4662 else if ( keycode
< 255 && isprint(keycode
) )
4664 PerformAction(wxACTION_TEXT_INSERT
, -1, (wxChar
)keycode
);
4666 // skip event.Skip() below
4671 // Ctrl-R refreshes the control in debug mode
4672 else if ( event
.ControlDown() && event
.GetKeyCode() == 'r' )
4674 #endif // __WXDEBUG__
4679 // ----------------------------------------------------------------------------
4680 // wxStdTextCtrlInputHandler
4681 // ----------------------------------------------------------------------------
4683 wxStdTextCtrlInputHandler::wxStdTextCtrlInputHandler(wxInputHandler
*inphand
)
4684 : wxStdInputHandler(inphand
)
4686 m_winCapture
= (wxTextCtrl
*)NULL
;
4690 wxTextPos
wxStdTextCtrlInputHandler::HitTest(const wxTextCtrl
*text
,
4693 wxTextCoord col
, row
;
4694 wxTextCtrlHitTestResult ht
= text
->HitTest(pt
, &col
, &row
);
4696 wxTextPos pos
= text
->XYToPosition(col
, row
);
4698 // if the point is after the last column we must adjust the position to be
4699 // the last position in the line (unless it is already the last)
4700 if ( (ht
== wxTE_HT_BEYOND
) && (pos
< text
->GetLastPosition()) )
4708 bool wxStdTextCtrlInputHandler::HandleKey(wxControl
*control
,
4709 const wxKeyEvent
& event
,
4712 // we're only interested in key presses
4716 int keycode
= event
.GetKeyCode();
4718 wxControlAction action
;
4720 bool ctrlDown
= event
.ControlDown(),
4721 shiftDown
= event
.ShiftDown();
4724 action
= wxACTION_TEXT_PREFIX_SEL
;
4727 // the only key combination with Alt we recognize is Alt-Bksp for undo, so
4728 // treat it first separately
4729 if ( event
.AltDown() )
4731 if ( keycode
== WXK_BACK
&& !ctrlDown
&& !shiftDown
)
4732 action
= wxACTION_TEXT_UNDO
;
4734 else switch ( keycode
)
4738 action
<< (ctrlDown
? wxACTION_TEXT_FIRST
4739 : wxACTION_TEXT_HOME
);
4743 action
<< (ctrlDown
? wxACTION_TEXT_LAST
4744 : wxACTION_TEXT_END
);
4749 action
<< wxACTION_TEXT_UP
;
4754 action
<< wxACTION_TEXT_DOWN
;
4758 action
<< (ctrlDown
? wxACTION_TEXT_WORD_LEFT
4759 : wxACTION_TEXT_LEFT
);
4763 action
<< (ctrlDown
? wxACTION_TEXT_WORD_RIGHT
4764 : wxACTION_TEXT_RIGHT
);
4769 // we don't map Ctrl-PgUp/Dn to anything special - what should it
4770 // to? for now, it's the same as without control
4771 action
<< wxACTION_TEXT_PAGE_DOWN
;
4776 action
<< wxACTION_TEXT_PAGE_UP
;
4782 action
<< wxACTION_TEXT_PREFIX_DEL
<< wxACTION_TEXT_RIGHT
;
4787 action
<< wxACTION_TEXT_PREFIX_DEL
<< wxACTION_TEXT_LEFT
;
4792 // reset the action as it could be already set to one of the
4794 action
= wxACTION_NONE
;
4801 action
= wxACTION_TEXT_REDO
;
4805 action
= wxACTION_TEXT_COPY
;
4809 action
= wxACTION_TEXT_PASTE
;
4813 action
= wxACTION_TEXT_CUT
;
4817 action
= wxACTION_TEXT_UNDO
;
4823 if ( (action
!= wxACTION_NONE
) && (action
!= wxACTION_TEXT_PREFIX_SEL
) )
4825 control
->PerformAction(action
, -1, str
);
4830 return wxStdInputHandler::HandleKey(control
, event
, pressed
);
4833 bool wxStdTextCtrlInputHandler::HandleMouse(wxControl
*control
,
4834 const wxMouseEvent
& event
)
4836 if ( event
.LeftDown() )
4838 wxASSERT_MSG( !m_winCapture
, _T("left button going down twice?") );
4840 wxTextCtrl
*text
= wxStaticCast(control
, wxTextCtrl
);
4842 m_winCapture
= text
;
4843 m_winCapture
->CaptureMouse();
4847 wxTextPos pos
= HitTest(text
, event
.GetPosition());
4850 text
->PerformAction(wxACTION_TEXT_ANCHOR_SEL
, pos
);
4853 else if ( event
.LeftDClick() )
4855 // select the word the cursor is on
4856 control
->PerformAction(wxACTION_TEXT_SEL_WORD
);
4858 else if ( event
.LeftUp() )
4862 m_winCapture
->ShowCaret();
4864 m_winCapture
->ReleaseMouse();
4865 m_winCapture
= (wxTextCtrl
*)NULL
;
4869 return wxStdInputHandler::HandleMouse(control
, event
);
4872 bool wxStdTextCtrlInputHandler::HandleMouseMove(wxControl
*control
,
4873 const wxMouseEvent
& event
)
4878 wxTextCtrl
*text
= wxStaticCast(m_winCapture
, wxTextCtrl
);
4879 wxTextPos pos
= HitTest(text
, event
.GetPosition());
4882 text
->PerformAction(wxACTION_TEXT_EXTEND_SEL
, pos
);
4886 return wxStdInputHandler::HandleMouseMove(control
, event
);
4889 bool wxStdTextCtrlInputHandler::HandleFocus(wxControl
*control
,
4890 const wxFocusEvent
& event
)
4892 wxTextCtrl
*text
= wxStaticCast(control
, wxTextCtrl
);
4894 // the selection appearance changes depending on whether we have the focus
4895 text
->RefreshSelection();
4897 // never refresh entirely
4901 #endif // wxUSE_TEXTCTRL