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();
1741 count
= GetFirstRowOfLine(count
- 1) +
1742 WData().m_linesData
[count
- 1].GetRowCount();
1748 wxTextCoord
wxTextCtrl::GetRowAfterLine(wxTextCoord line
) const
1753 if ( !WData().IsValidLine(line
) )
1758 return WData().m_linesData
[line
].GetNextRow();
1761 wxTextCoord
wxTextCtrl::GetFirstRowOfLine(wxTextCoord line
) const
1766 if ( !WData().IsValidLine(line
) )
1771 return WData().m_linesData
[line
].GetFirstRow();
1774 bool wxTextCtrl::PositionToLogicalXY(wxTextPos pos
,
1776 wxCoord
*yOut
) const
1778 wxTextCoord col
, line
;
1780 // optimization for special (but common) case when we already have the col
1782 if ( pos
== m_curPos
)
1787 else // must really calculate col/line from pos
1789 if ( !PositionToXY(pos
, &col
, &line
) )
1793 int hLine
= GetLineHeight();
1795 wxString textLine
= GetLineText(line
);
1796 if ( IsSingleLine() || !WrapLines() )
1798 x
= GetTextWidth(textLine
.Left(col
));
1801 else // difficult case: multline control with line wrap
1803 y
= GetFirstRowOfLine(line
);
1805 wxTextCoord colRowStart
;
1806 y
+= GetRowInLine(line
, col
, &colRowStart
);
1810 // x is the width of the text before this position in this row
1811 x
= GetTextWidth(textLine
.Mid(colRowStart
, col
- colRowStart
));
1822 bool wxTextCtrl::PositionToDeviceXY(wxTextPos pos
,
1824 wxCoord
*yOut
) const
1827 if ( !PositionToLogicalXY(pos
, &x
, &y
) )
1830 // finally translate the logical text rect coords into physical client
1832 CalcScrolledPosition(m_rectText
.x
+ x
, m_rectText
.y
+ y
, xOut
, yOut
);
1837 wxPoint
wxTextCtrl::GetCaretPosition() const
1839 wxCoord xCaret
, yCaret
;
1840 if ( !PositionToDeviceXY(m_curPos
, &xCaret
, &yCaret
) )
1842 wxFAIL_MSG( _T("Caret can't be beyond the text!") );
1845 return wxPoint(xCaret
, yCaret
);
1848 // pos may be -1 to show the current position
1849 void wxTextCtrl::ShowPosition(wxTextPos pos
)
1853 if ( IsSingleLine() )
1855 ShowHorzPosition(GetTextWidth(m_value
.Left(pos
)));
1857 else if ( MData().m_scrollRangeX
|| MData().m_scrollRangeY
) // multiline with scrollbars
1860 GetViewStart(&xStart
, &yStart
);
1866 PositionToLogicalXY(pos
, &x
, &y
);
1868 wxRect rectText
= GetRealTextArea();
1870 // scroll the position vertically into view: if it is currently above
1871 // it, make it the first one, otherwise the last one
1872 if ( MData().m_scrollRangeY
)
1874 y
/= GetLineHeight();
1880 else // we are currently in or below the view area
1882 // find the last row currently shown
1887 // to find the last row we need to use the generic HitTest
1890 // OPT this is a bit silly: we undo this in HitTest(), so
1891 // it would be better to factor out the common
1892 // functionality into a separate function (OTOH it
1893 // won't probably save us that much)
1894 wxPoint
pt(0, rectText
.height
- 1);
1895 pt
+= GetClientAreaOrigin();
1896 pt
+= m_rectText
.GetPosition();
1897 HitTest(pt
, &col
, &yEnd
);
1899 // find the row inside the line
1900 yEnd
= GetFirstRowOfLine(yEnd
) + GetRowInLine(yEnd
, col
);
1904 // finding the last line is easy if each line has exactly
1906 yEnd
= yStart
+ rectText
.height
/ GetLineHeight() - 1;
1911 // scroll down: the current item should appear at the
1912 // bottom of the view
1913 Scroll(0, y
- (yEnd
- yStart
));
1918 // scroll the position horizontally into view
1920 // we follow what I believe to be Windows behaviour here, that is if
1921 // the position is already entirely in the view we do nothing, but if
1922 // we do have to scroll the window to bring it into view, we scroll it
1923 // not just enough to show the position but slightly more so that this
1924 // position is at 1/3 of the window width from the closest border to it
1925 // (I'm not sure that Windows does exactly this but it looks like this)
1926 if ( MData().m_scrollRangeX
)
1928 // unlike for the rows, xStart doesn't correspond to the starting
1929 // column as they all have different widths, so we need to
1930 // translate everything to pixels
1932 // we want the text between x and x2 be entirely inside the view
1933 // (i.e. the current character)
1935 // make xStart the first visible pixel (and not position)
1936 int wChar
= GetAverageWidth();
1941 // we want the position of this column be 1/3 to the right of
1943 x
-= rectText
.width
/ 3;
1946 Scroll(x
/ wChar
, y
);
1948 else // maybe we're beyond the right border of the view?
1950 wxTextCoord col
, row
;
1951 if ( PositionToXY(pos
, &col
, &row
) )
1953 wxString lineText
= GetLineText(row
);
1954 wxCoord x2
= x
+ GetTextWidth(lineText
[(size_t)col
]);
1955 if ( x2
> xStart
+ rectText
.width
)
1957 // we want the position of this column be 1/3 to the
1958 // left of the right edge, i.e. 2/3 right of the left
1960 x2
-= (2*rectText
.width
)/3;
1963 Scroll(x2
/ wChar
, row
);
1969 //else: multiline but no scrollbars, hence nothing to do
1974 // ----------------------------------------------------------------------------
1976 // ----------------------------------------------------------------------------
1979 TODO: we could have (easy to do) vi-like options for word movement, i.e.
1980 distinguish between inlusive/exclusive words and between words and
1981 WORDS (in vim sense) and also, finally, make the set of characters
1982 which make up a word configurable - currently we use the exclusive
1983 WORDS only (coincidentally, this is what Windows edit control does)
1985 For future references, here is what vim help says:
1987 A word consists of a sequence of letters, digits and underscores, or
1988 a sequence of other non-blank characters, separated with white space
1989 (spaces, tabs, <EOL>). This can be changed with the 'iskeyword'
1992 A WORD consists of a sequence of non-blank characters, separated with
1993 white space. An empty line is also considered to be a word and a
1997 static inline bool IsWordChar(wxChar ch
)
1999 return !wxIsspace(ch
);
2002 wxTextPos
wxTextCtrl::GetWordStart() const
2004 if ( m_curPos
== -1 || m_curPos
== 0 )
2007 if ( m_curCol
== 0 )
2009 // go to the end of the previous line
2010 return m_curPos
- 1;
2013 // it shouldn't be possible to learn where the word starts in the password
2018 // start at the previous position
2019 const wxChar
*p0
= GetLineText(m_curRow
).c_str();
2020 const wxChar
*p
= p0
+ m_curCol
- 1;
2022 // find the end of the previous word
2023 while ( (p
> p0
) && !IsWordChar(*p
) )
2026 // now find the beginning of this word
2027 while ( (p
> p0
) && IsWordChar(*p
) )
2030 // we might have gone too far
2031 if ( !IsWordChar(*p
) )
2034 return (m_curPos
- m_curCol
) + p
- p0
;
2037 wxTextPos
wxTextCtrl::GetWordEnd() const
2039 if ( m_curPos
== -1 )
2042 wxString line
= GetLineText(m_curRow
);
2043 if ( (size_t)m_curCol
== line
.length() )
2045 // if we're on the last position in the line, go to the next one - if
2047 wxTextPos pos
= m_curPos
;
2048 if ( pos
< GetLastPosition() )
2054 // it shouldn't be possible to learn where the word ends in the password
2057 return GetLastPosition();
2059 // start at the current position
2060 const wxChar
*p0
= line
.c_str();
2061 const wxChar
*p
= p0
+ m_curCol
;
2063 // find the start of the next word
2064 while ( *p
&& !IsWordChar(*p
) )
2067 // now find the end of it
2068 while ( *p
&& IsWordChar(*p
) )
2071 // and find the start of the next word
2072 while ( *p
&& !IsWordChar(*p
) )
2075 return (m_curPos
- m_curCol
) + p
- p0
;
2078 // ----------------------------------------------------------------------------
2080 // ----------------------------------------------------------------------------
2082 void wxTextCtrl::Copy()
2085 if ( HasSelection() )
2087 wxClipboardLocker clipLock
;
2089 // wxTextFile::Translate() is needed to transform all '\n' into "\r\n"
2090 wxString text
= wxTextFile::Translate(GetTextToShow(GetSelectionText()));
2091 wxTextDataObject
*data
= new wxTextDataObject(text
);
2092 wxTheClipboard
->SetData(data
);
2094 #endif // wxUSE_CLIPBOARD
2097 void wxTextCtrl::Cut()
2102 bool wxTextCtrl::DoCut()
2104 if ( !HasSelection() )
2114 void wxTextCtrl::Paste()
2119 bool wxTextCtrl::DoPaste()
2122 wxClipboardLocker clipLock
;
2124 wxTextDataObject data
;
2125 if ( wxTheClipboard
->IsSupported(data
.GetFormat())
2126 && wxTheClipboard
->GetData(data
) )
2128 // reverse transformation: '\r\n\" -> '\n'
2129 wxString text
= wxTextFile::Translate(data
.GetText(),
2130 wxTextFileType_Unix
);
2131 if ( !text
.empty() )
2138 #endif // wxUSE_CLIPBOARD
2143 // ----------------------------------------------------------------------------
2145 // ----------------------------------------------------------------------------
2147 wxTextCtrlInsertCommand
*
2148 wxTextCtrlCommandProcessor::IsInsertCommand(wxCommand
*command
)
2150 return (wxTextCtrlInsertCommand
*)
2151 (command
&& (command
->GetName() == wxTEXT_COMMAND_INSERT
)
2155 void wxTextCtrlCommandProcessor::Store(wxCommand
*command
)
2157 wxTextCtrlInsertCommand
*cmdIns
= IsInsertCommand(command
);
2160 if ( IsCompressing() )
2162 wxTextCtrlInsertCommand
*
2163 cmdInsLast
= IsInsertCommand(GetCurrentCommand());
2165 // it is possible that we don't have any last command at all if,
2166 // for example, it was undone since the last Store(), so deal with
2170 cmdInsLast
->Append(cmdIns
);
2174 // don't need to call the base class version
2179 // append the following insert commands to this one
2180 m_compressInserts
= TRUE
;
2182 // let the base class version will do the job normally
2184 else // not an insert command
2186 // stop compressing insert commands - this won't work with the last
2187 // command not being an insert one anyhow
2190 // let the base class version will do the job normally
2193 wxCommandProcessor::Store(command
);
2196 void wxTextCtrlInsertCommand::Append(wxTextCtrlInsertCommand
*other
)
2198 m_text
+= other
->m_text
;
2201 bool wxTextCtrlInsertCommand::CanUndo() const
2203 return m_from
!= -1;
2206 bool wxTextCtrlInsertCommand::Do(wxTextCtrl
*text
)
2208 // the text is going to be inserted at the current position, remember where
2210 m_from
= text
->GetInsertionPoint();
2212 // and now do insert it
2213 text
->WriteText(m_text
);
2218 bool wxTextCtrlInsertCommand::Undo(wxTextCtrl
*text
)
2220 wxCHECK_MSG( CanUndo(), FALSE
, _T("impossible to undo insert cmd") );
2222 // remove the text from where we inserted it
2223 text
->Remove(m_from
, m_from
+ m_text
.length());
2228 bool wxTextCtrlRemoveCommand::CanUndo() const
2230 // if we were executed, we should have the text we removed
2231 return !m_textDeleted
.empty();
2234 bool wxTextCtrlRemoveCommand::Do(wxTextCtrl
*text
)
2236 text
->SetSelection(m_from
, m_to
);
2237 m_textDeleted
= text
->GetSelectionText();
2238 text
->RemoveSelection();
2243 bool wxTextCtrlRemoveCommand::Undo(wxTextCtrl
*text
)
2245 // it is possible that the text was deleted and that we can't restore text
2246 // at the same position we removed it any more
2247 wxTextPos posLast
= text
->GetLastPosition();
2248 text
->SetInsertionPoint(m_from
> posLast
? posLast
: m_from
);
2249 text
->WriteText(m_textDeleted
);
2254 void wxTextCtrl::Undo()
2256 // the caller must check it
2257 wxASSERT_MSG( CanUndo(), _T("can't call Undo() if !CanUndo()") );
2259 m_cmdProcessor
->Undo();
2262 void wxTextCtrl::Redo()
2264 // the caller must check it
2265 wxASSERT_MSG( CanRedo(), _T("can't call Undo() if !CanUndo()") );
2267 m_cmdProcessor
->Redo();
2270 bool wxTextCtrl::CanUndo() const
2272 return IsEditable() && m_cmdProcessor
->CanUndo();
2275 bool wxTextCtrl::CanRedo() const
2277 return IsEditable() && m_cmdProcessor
->CanRedo();
2280 // ----------------------------------------------------------------------------
2282 // ----------------------------------------------------------------------------
2284 wxSize
wxTextCtrl::DoGetBestClientSize() const
2286 // when we're called for the very first time from Create() we must
2287 // calculate the font metrics here because we can't do it before calling
2288 // Create() (there is no window yet and wxGTK crashes) but we need them
2290 if ( m_heightLine
== -1 )
2292 wxConstCast(this, wxTextCtrl
)->RecalcFontMetrics();
2296 GetTextExtent(GetTextToShow(GetLineText(0)), &w
, &h
);
2298 int wChar
= GetAverageWidth(),
2299 hChar
= GetLineHeight();
2301 int widthMin
= wxMax(10*wChar
, 100);
2307 if ( !IsSingleLine() )
2309 // let the control have a reasonable number of lines
2310 int lines
= GetNumberOfLines();
2313 else if ( lines
> 10 )
2320 rectText
.height
= h
;
2321 wxRect rectTotal
= GetRenderer()->GetTextTotalArea(this, rectText
);
2322 return wxSize(rectTotal
.width
, rectTotal
.height
);
2325 void wxTextCtrl::UpdateTextRect()
2327 wxRect
rectTotal(wxPoint(0, 0), GetClientSize());
2328 wxCoord
*extraSpace
= WrapLines() ? &WData().m_widthMark
: NULL
;
2329 m_rectText
= GetRenderer()->GetTextClientArea(this, rectTotal
, extraSpace
);
2331 // code elsewhere is confused by negative rect size
2332 if ( m_rectText
.width
<= 0 )
2333 m_rectText
.width
= 1;
2334 if ( m_rectText
.height
<= 0 )
2335 m_rectText
.height
= 1;
2337 if ( !IsSingleLine() )
2339 // invalidate it so that GetRealTextArea() will recalc it
2340 MData().m_rectTextReal
.width
= 0;
2342 // only scroll this rect when the window is scrolled: note that we have
2343 // to scroll not only the text but the line wrap marks too if we show
2345 wxRect rectText
= GetRealTextArea();
2346 if ( extraSpace
&& *extraSpace
)
2348 rectText
.width
+= *extraSpace
;
2350 SetTargetRect(rectText
);
2352 // relayout all lines
2355 WData().m_rowFirstInvalid
= 0;
2357 // increase timestamp: this means that the lines which had been
2358 // laid out before will be relayd out the next time LayoutLines()
2359 // is called because their timestamp will be smaller than the
2361 WData().m_timestamp
++;
2365 UpdateLastVisible();
2368 void wxTextCtrl::UpdateLastVisible()
2370 // this method is only used for horizontal "scrollbarless" scrolling which
2371 // is used only with single line controls
2372 if ( !IsSingleLine() )
2375 // use (efficient) HitTestLine to find the last visible character
2376 wxString text
= m_value
.Mid((size_t)SData().m_colStart
/* to the end */);
2378 switch ( HitTestLine(text
, m_rectText
.width
, &col
) )
2380 case wxTE_HT_BEYOND
:
2381 // everything is visible
2382 SData().m_colLastVisible
= text
.length();
2385 SData().m_posLastVisible
= -1;
2389 case wxTE_HT_BEFORE:
2393 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2396 case wxTE_HT_ON_TEXT
:
2399 // the last entirely seen character is the previous one because
2400 // this one is only partly visible - unless the width of the
2401 // string is exactly the max width
2402 SData().m_posLastVisible
= GetTextWidth(text
.Truncate(col
+ 1));
2403 if ( SData().m_posLastVisible
> m_rectText
.width
)
2405 // this character is not entirely visible, take the
2410 SData().m_posLastVisible
= -1;
2412 //else: we can just see it
2414 SData().m_colLastVisible
= col
;
2419 // calculate the width of the text really shown
2420 if ( SData().m_posLastVisible
== -1 )
2422 SData().m_posLastVisible
= GetTextWidth(text
.Truncate(SData().m_colLastVisible
+ 1));
2425 // current value is relative the start of the string text which starts at
2426 // SData().m_colStart, we need an absolute offset into string
2427 SData().m_colLastVisible
+= SData().m_colStart
;
2429 wxLogTrace(_T("text"), _T("Last visible column/position is %d/%ld"),
2430 SData().m_colLastVisible
, SData().m_posLastVisible
);
2433 void wxTextCtrl::OnSize(wxSizeEvent
& event
)
2437 if ( !IsSingleLine() )
2440 // update them immediately because if we are called for the first time,
2441 // we need to create them in order for the base class version to
2442 // position the scrollbars correctly - if we don't do it now, it won't
2443 // happen at all if we don't get more size events
2447 MData().m_updateScrollbarX
=
2448 MData().m_updateScrollbarY
= TRUE
;
2454 wxCoord
wxTextCtrl::GetTotalWidth() const
2457 CalcUnscrolledPosition(m_rectText
.width
, 0, &w
, NULL
);
2461 wxCoord
wxTextCtrl::GetTextWidth(const wxString
& text
) const
2464 GetTextExtent(GetTextToShow(text
), &w
, NULL
);
2468 wxRect
wxTextCtrl::GetRealTextArea() const
2470 // for single line text control it's just the same as text rect
2471 if ( IsSingleLine() )
2474 // the real text area always holds an entire number of lines, so the only
2475 // difference with the text area is a narrow strip along the bottom border
2476 wxRect rectText
= MData().m_rectTextReal
;
2477 if ( !rectText
.width
)
2480 rectText
= m_rectText
;
2482 // when we're called for the very first time, the line height might not
2483 // had been calculated yet, so do get it now
2484 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2485 self
->RecalcFontMetrics();
2487 int hLine
= GetLineHeight();
2488 rectText
.height
= (m_rectText
.height
/ hLine
) * hLine
;
2491 self
->MData().m_rectTextReal
= rectText
;
2497 wxTextCoord
wxTextCtrl::GetRowInLine(wxTextCoord line
,
2499 wxTextCoord
*colRowStart
) const
2501 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2503 const wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
2505 if ( !WData().IsValidLine(line
) )
2508 // row is here counted a bit specially: 0 is the 2nd row of the line (1st
2511 rowMax
= lineData
.GetExtraRowCount();
2515 while ( (row
< rowMax
) && (col
>= lineData
.GetExtraRowStart(row
)) )
2518 // it's ok here that row is 1 greater than needed: like this, it is
2519 // counted as a normal (and not extra) row
2521 //else: only one row anyhow
2525 // +1 because we need a real row number, not the extra row one
2526 *colRowStart
= lineData
.GetRowStart(row
);
2528 // this can't happen, of course
2529 wxASSERT_MSG( *colRowStart
<= col
, _T("GetRowInLine() is broken") );
2535 void wxTextCtrl::LayoutLine(wxTextCoord line
, wxWrappedLineData
& lineData
) const
2537 // FIXME: this uses old GetPartOfWrappedLine() which is not used anywhere
2538 // else now and has rather awkward interface for our needs here
2540 lineData
.m_rowsStart
.Empty();
2541 lineData
.m_rowsWidth
.Empty();
2543 const wxString
& text
= GetLineText(line
);
2545 size_t colRowStart
= 0;
2548 size_t lenRow
= GetPartOfWrappedLine
2550 text
.c_str() + colRowStart
,
2554 // remember the start of this row (not for the first one as
2555 // it's always 0) and its width
2557 lineData
.m_rowsStart
.Add(colRowStart
);
2558 lineData
.m_rowsWidth
.Add(widthRow
);
2560 colRowStart
+= lenRow
;
2562 while ( colRowStart
< text
.length() );
2564 // put the current timestamp on it
2565 lineData
.m_timestamp
= WData().m_timestamp
;
2568 void wxTextCtrl::LayoutLines(wxTextCoord lineLast
) const
2570 wxASSERT_MSG( WrapLines(), _T("should only be used for line wrapping") );
2572 // if we were called, some line was dirty and if it was dirty we must have
2573 // had m_rowFirstInvalid set to something too
2574 wxTextCoord lineFirst
= WData().m_rowFirstInvalid
;
2575 wxASSERT_MSG( lineFirst
!= -1, _T("nothing to layout?") );
2577 wxTextCoord rowFirst
, rowCur
;
2580 // start after the last known valid line
2581 const wxWrappedLineData
& lineData
= WData().m_linesData
[lineFirst
- 1];
2582 rowFirst
= lineData
.GetFirstRow() + lineData
.GetRowCount();
2584 else // no valid lines, start at row 0
2590 for ( wxTextCoord line
= lineFirst
; line
<= lineLast
; line
++ )
2592 // set the starting row for this line
2593 wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
2594 lineData
.m_rowFirst
= rowCur
;
2596 // had the line been already broken into rows?
2598 // if so, compare its timestamp with the current one: if nothing has
2599 // been changed, don't relayout it
2600 if ( !lineData
.IsValid() ||
2601 (lineData
.m_timestamp
< WData().m_timestamp
) )
2603 // now do break it in rows
2604 LayoutLine(line
, lineData
);
2607 rowCur
+= lineData
.GetRowCount();
2610 // we are now valid at least up to this line, but if it is the last one we
2611 // just don't have any more invalid rows at all
2612 if ( (size_t)lineLast
== WData().m_linesData
.GetCount() -1 )
2617 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2618 self
->WData().m_rowFirstInvalid
= lineLast
;
2620 // also refresh the line end indicators (FIXME shouldn't do it always!)
2621 self
->RefreshLineWrapMarks(rowFirst
, rowCur
);
2624 size_t wxTextCtrl::GetPartOfWrappedLine(const wxChar
* text
,
2625 wxCoord
*widthReal
) const
2627 // this function is slow, it shouldn't be called unless really needed
2628 wxASSERT_MSG( WrapLines(), _T("shouldn't be called") );
2633 switch ( HitTestLine(s
, m_rectText
.width
, &col
) )
2636 case wxTE_HT_BEFORE:
2640 wxFAIL_MSG(_T("unexpected HitTestLine() return value"));
2643 case wxTE_HT_ON_TEXT
:
2646 // the last entirely seen character is the previous one because
2647 // this one is only partly visible - unless the width of the
2648 // string is exactly the max width
2649 wReal
= GetTextWidth(s
.Truncate(col
+ 1));
2650 if ( wReal
> m_rectText
.width
)
2652 // this character is not entirely visible, take the
2659 //else: we can just see it
2661 // wrap at any character or only at words boundaries?
2662 if ( !(GetWindowStyle() & wxTE_LINEWRAP
) )
2664 // find the (last) not word char before this word
2665 wxTextCoord colWordStart
;
2666 for ( colWordStart
= col
;
2667 colWordStart
&& IsWordChar(s
[(size_t)colWordStart
]);
2671 if ( colWordStart
> 0 )
2673 if ( colWordStart
!= col
)
2675 // will have to recalc the real width
2681 //else: only a single word, have to wrap it here
2686 case wxTE_HT_BEYOND
:
2690 // we return the number of characters, not the index of the last one
2691 if ( (size_t)col
< s
.length() )
2693 // but don't return more than this (empty) string has
2701 // calc it if not done yet
2702 wReal
= GetTextWidth(s
.Truncate(col
));
2708 // VZ: old, horribly inefficient code which can still be used for checking
2709 // the result (in line, not word, wrap mode only) - to be removed later
2711 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2712 wxClientDC
dc(self
);
2713 dc
.SetFont(GetFont());
2714 self
->DoPrepareDC(dc
);
2716 wxCoord widthMax
= m_rectText
.width
;
2718 // the text which we can keep in this ROW
2721 for ( wOld
= w
= 0; *text
&& (w
<= widthMax
); )
2725 dc
.GetTextExtent(str
, &w
, NULL
);
2730 // if we wrapped, the last letter was one too much
2731 if ( str
.length() > 1 )
2734 str
.erase(str
.length() - 1, 1);
2736 else // but always keep at least one letter in each row
2738 // the real width then is the last value of w and not teh one
2743 else // we didn't wrap
2748 wxASSERT( col
== str
.length() );
2752 wxASSERT( *widthReal
== wOld
);
2757 //return str.length();
2763 // OPT: this function is called a lot - would be nice to optimize it but I
2764 // don't really know how yet
2765 wxTextCtrlHitTestResult
wxTextCtrl::HitTestLine(const wxString
& line
,
2767 wxTextCoord
*colOut
) const
2769 wxTextCtrlHitTestResult res
= wxTE_HT_ON_TEXT
;
2772 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
2773 wxClientDC
dc(self
);
2774 dc
.SetFont(GetFont());
2775 self
->DoPrepareDC(dc
);
2778 dc
.GetTextExtent(line
, &width
, NULL
);
2781 // clicking beyond the end of line is equivalent to clicking at
2782 // the end of it, so return the last line column
2783 col
= line
.length();
2786 // unless the line is empty and so doesn't have any column at all -
2787 // in this case return 0, what else can we do?
2791 res
= wxTE_HT_BEYOND
;
2797 res
= wxTE_HT_BEFORE
;
2799 else // we're inside the line
2801 // now calculate the column: first, approximate it with fixed-width
2802 // value and then calculate the correct value iteratively: note that
2803 // we use the first character of the line instead of (average)
2804 // GetCharWidth(): it is common to have lines of dashes, for example,
2805 // and this should give us much better approximation in such case
2807 // OPT: maybe using (cache) m_widthAvg would be still faster? profile!
2808 dc
.GetTextExtent(line
[0], &width
, NULL
);
2815 else if ( (size_t)col
> line
.length() )
2817 col
= line
.length();
2820 // matchDir is the direction in which we should move to reach the
2821 // character containing the given position
2827 } matchDir
= Match_None
;
2830 // check that we didn't go beyond the line boundary
2836 if ( (size_t)col
> line
.length() )
2838 col
= line
.length();
2842 wxString
strBefore(line
, (size_t)col
);
2843 dc
.GetTextExtent(strBefore
, &width
, NULL
);
2846 if ( matchDir
== Match_Right
)
2848 // we were going to the right and, finally, moved beyond
2849 // the original position - stop on the previous one
2855 if ( matchDir
== Match_None
)
2857 // we just started iterating, now we know that we should
2859 matchDir
= Match_Left
;
2861 //else: we are still to the right of the target, continue
2865 // invert the logic above
2866 if ( matchDir
== Match_Left
)
2868 // with the exception that we don't need to backtrack here
2872 if ( matchDir
== Match_None
)
2875 matchDir
= Match_Right
;
2879 // this is not supposed to happen
2880 wxASSERT_MSG( matchDir
, _T("logic error in wxTextCtrl::HitTest") );
2882 if ( matchDir
== Match_Right
)
2889 // check that we calculated it correctly
2891 if ( res
== wxTE_HT_ON_TEXT
)
2894 wxString text
= line
.Left(col
);
2895 dc
.GetTextExtent(text
, &width1
, NULL
);
2896 if ( (size_t)col
< line
.length() )
2901 dc
.GetTextExtent(text
, &width2
, NULL
);
2903 wxASSERT_MSG( (width1
<= x
) && (x
< width2
),
2904 _T("incorrect HitTestLine() result") );
2906 else // we return last char
2908 wxASSERT_MSG( x
>= width1
, _T("incorrect HitTestLine() result") );
2911 #endif // WXDEBUG_TEXT
2919 wxTextCtrlHitTestResult
wxTextCtrl::HitTest(const wxPoint
& pos
,
2920 wxTextCoord
*colOut
,
2921 wxTextCoord
*rowOut
) const
2923 return HitTest2(pos
.y
, pos
.x
, 0, rowOut
, colOut
, NULL
, NULL
);
2926 wxTextCtrlHitTestResult
wxTextCtrl::HitTestLogical(const wxPoint
& pos
,
2927 wxTextCoord
*colOut
,
2928 wxTextCoord
*rowOut
) const
2930 return HitTest2(pos
.y
, pos
.x
, 0, rowOut
, colOut
, NULL
, NULL
, FALSE
);
2933 wxTextCtrlHitTestResult
wxTextCtrl::HitTest2(wxCoord y0
,
2936 wxTextCoord
*rowOut
,
2937 wxTextCoord
*colStart
,
2938 wxTextCoord
*colEnd
,
2939 wxTextCoord
*colRowStartOut
,
2940 bool deviceCoords
) const
2942 // is the point in the text area or to the right or below it?
2943 wxTextCtrlHitTestResult res
= wxTE_HT_ON_TEXT
;
2945 // translate the window coords x0 and y0 into the client coords in the text
2946 // area by adjusting for both the client and text area offsets (unless this
2947 // was already done)
2951 wxPoint pt
= GetClientAreaOrigin() + m_rectText
.GetPosition();
2952 CalcUnscrolledPosition(x10
- pt
.x
, y0
- pt
.y
, &x1
, &y
);
2960 // calculate the row (it is really a LINE, not a ROW)
2963 // these vars are used only for WrapLines() case
2964 wxTextCoord colRowStart
= 0;
2967 if ( colRowStartOut
)
2968 *colRowStartOut
= 0;
2970 int hLine
= GetLineHeight();
2973 // and clicking before it is the same as clicking on the first one
2976 res
= wxTE_HT_BEFORE
;
2980 wxTextCoord rowLast
= GetNumberOfLines() - 1;
2982 if ( IsSingleLine() || !WrapLines() )
2984 // in this case row calculation is simple as all lines have the
2985 // same height and so row is the same as line
2986 if ( row
> rowLast
)
2988 // clicking below the text is the same as clicking on the last
2992 res
= wxTE_HT_BELOW
;
2995 else // multline control with line wrap
2997 // use binary search to find the line containing this row
2998 const wxArrayWrappedLinesData
& linesData
= WData().m_linesData
;
3000 hi
= linesData
.GetCount(),
3005 const wxWrappedLineData
& lineData
= linesData
[cur
];
3006 if ( !WData().IsValidLine(cur
) )
3008 wxTextCoord rowFirst
= lineData
.GetFirstRow();
3010 if ( row
< rowFirst
)
3016 // our row is after the first row of the cur line:
3017 // obviously, if cur is the last line, it contains this
3018 // row, otherwise we have to test that it is before the
3019 // first row of the next line
3020 bool found
= cur
== linesData
.GetCount() - 1;
3023 // if the row is beyond the end of text, adjust it to
3024 // be the last one and set res accordingly
3025 if ( (size_t)(row
- rowFirst
) >= lineData
.GetRowCount() )
3027 res
= wxTE_HT_BELOW
;
3029 row
= lineData
.GetRowCount() + rowFirst
- 1;
3032 else // not the last row
3034 const wxWrappedLineData
&
3035 lineNextData
= linesData
[cur
+ 1];
3036 if ( !WData().IsValidLine(cur
+ 1) )
3037 LayoutLines(cur
+ 1);
3038 found
= row
< lineNextData
.GetFirstRow();
3043 colRowStart
= lineData
.GetRowStart(row
- rowFirst
);
3044 rowLen
= lineData
.GetRowLength(row
- rowFirst
,
3045 GetLines()[cur
].length());
3059 if ( res
== wxTE_HT_ON_TEXT
)
3061 // now find the position in the line
3062 wxString lineText
= GetLineText(row
),
3065 if ( colRowStart
|| rowLen
)
3067 // look in this row only, not in whole line
3068 rowText
= lineText
.Mid(colRowStart
, rowLen
);
3072 // just take the whole string
3078 res
= HitTestLine(GetTextToShow(rowText
), x1
, colStart
);
3082 if ( colRowStartOut
)
3084 // give them the column offset in this ROW in pixels
3085 *colRowStartOut
= colRowStart
;
3088 // take into account that the ROW doesn't start in the
3089 // beginning of the LINE
3090 *colStart
+= colRowStart
;
3095 // the hit test result we return is for x1, so throw out
3096 // the result for x2 here
3097 int x2
= x1
+ x20
- x10
;
3098 (void)HitTestLine(GetTextToShow(rowText
), x2
, colEnd
);
3100 *colEnd
+= colRowStart
;
3104 else // before/after vertical text span
3108 // fill the column with the first/last position in the
3109 // corresponding line
3110 if ( res
== wxTE_HT_BEFORE
)
3112 else // res == wxTE_HT_BELOW
3113 *colStart
= GetLineText(GetNumberOfLines() - 1).length();
3119 // give them the row in text coords (as is)
3126 bool wxTextCtrl::GetLineAndRow(wxTextCoord row
,
3127 wxTextCoord
*lineOut
,
3128 wxTextCoord
*rowInLineOut
) const
3136 int nLines
= GetNumberOfLines();
3139 const wxArrayWrappedLinesData
& linesData
= WData().m_linesData
;
3140 for ( line
= 0; line
< nLines
; line
++ )
3142 if ( !WData().IsValidLine(line
) )
3145 if ( row
< linesData
[line
].GetNextRow() )
3147 // we found the right line
3148 rowInLine
= row
- linesData
[line
].GetFirstRow();
3154 if ( line
== nLines
)
3156 // the row is out of range
3160 else // no line wrapping, everything is easy
3162 if ( row
>= nLines
)
3171 *rowInLineOut
= rowInLine
;
3176 // ----------------------------------------------------------------------------
3178 // ----------------------------------------------------------------------------
3181 wxTextCtrl has not one but two scrolling mechanisms: one is semi-automatic
3182 scrolling in both horizontal and vertical direction implemented using
3183 wxScrollHelper and the second one is manual scrolling implemented using
3184 SData().m_ofsHorz and used by the single line controls without scroll bar.
3186 The first version (the standard one) always scrolls by fixed amount which is
3187 fine for vertical scrolling as all lines have the same height but is rather
3188 ugly for horizontal scrolling if proportional font is used. This is why we
3189 manually update and use SData().m_ofsHorz which contains the length of the string
3190 which is hidden beyond the left borde. An important property of text
3191 controls using this kind of scrolling is that an entire number of characters
3192 is always shown and that parts of characters never appear on display -
3193 neither in the leftmost nor rightmost positions.
3195 Once again, for multi line controls SData().m_ofsHorz is always 0 and scrolling is
3196 done as usual for wxScrollWindow.
3199 void wxTextCtrl::ShowHorzPosition(wxCoord pos
)
3201 wxASSERT_MSG( IsSingleLine(), _T("doesn't work for multiline") );
3203 // pos is the logical position to show
3205 // SData().m_ofsHorz is the fisrt logical position shown
3206 if ( pos
< SData().m_ofsHorz
)
3210 HitTestLine(m_value
, pos
, &col
);
3215 wxCoord width
= m_rectText
.width
;
3218 // if we are called from the ctor, m_rectText is not initialized
3219 // yet, so do it now
3221 width
= m_rectText
.width
;
3224 // SData().m_ofsHorz + width is the last logical position shown
3225 if ( pos
> SData().m_ofsHorz
+ width
)
3229 HitTestLine(m_value
, pos
- width
, &col
);
3230 ScrollText(col
+ 1);
3235 // scroll the window horizontally so that the first visible character becomes
3236 // the one at this position
3237 void wxTextCtrl::ScrollText(wxTextCoord col
)
3239 wxASSERT_MSG( IsSingleLine(),
3240 _T("ScrollText() is for single line controls only") );
3242 // never scroll beyond the left border
3246 // OPT: could only get the extent of the part of the string between col
3247 // and SData().m_colStart
3248 wxCoord ofsHorz
= GetTextWidth(GetLineText(0).Left(col
));
3250 if ( ofsHorz
!= SData().m_ofsHorz
)
3252 // remember the last currently used pixel
3253 int posLastVisible
= SData().m_posLastVisible
;
3254 if ( posLastVisible
== -1 )
3256 // this may happen when we're called very early, during the
3257 // controls construction
3258 UpdateLastVisible();
3260 posLastVisible
= SData().m_posLastVisible
;
3263 // NB1: to scroll to the right, offset must be negative, hence the
3264 // order of operands
3265 int dx
= SData().m_ofsHorz
- ofsHorz
;
3267 // NB2: we call Refresh() below which results in a call to
3268 // DoDraw(), so we must update SData().m_ofsHorz before calling it
3269 SData().m_ofsHorz
= ofsHorz
;
3270 SData().m_colStart
= col
;
3272 // after changing m_colStart, recalc the last visible position: we need
3273 // to recalc the last visible position beore scrolling in order to make
3274 // it appear exactly at the right edge of the text area after scrolling
3275 UpdateLastVisible();
3280 // we want to force the update of it after scrolling
3281 SData().m_colLastVisible
= -1;
3285 // scroll only the rectangle inside which there is the text
3286 wxRect rect
= m_rectText
;
3287 rect
.width
= posLastVisible
;
3289 rect
= ScrollNoRefresh(dx
, 0, &rect
);
3292 we need to manually refresh the part which ScrollWindow() doesn't
3293 refresh (with new API this means the part outside the rect returned
3294 by ScrollNoRefresh): indeed, if we had this:
3298 where '*' is text and 'o' is blank area at the end (too small to
3299 hold the next char) then after scrolling by 2 positions to the left
3304 where 'R' is the area refreshed by ScrollWindow() - but we still
3305 need to refresh the 'o' at the end as it may be now big enough to
3306 hold the new character shifted into view.
3308 when we are scrolling to the right, we need to update this rect as
3309 well because it might have contained something before but doesn't
3310 contain anything any more
3313 // we can combine both rectangles into one when scrolling to the left,
3314 // but we need two separate Refreshes() otherwise
3317 // refresh the uncovered part on the left
3318 Refresh(TRUE
, &rect
);
3320 // and now the area on the right
3321 rect
.x
= m_rectText
.x
+ posLastVisible
;
3322 rect
.width
= m_rectText
.width
- posLastVisible
;
3324 else // scrolling to the left
3326 // just extend the rect covering the uncovered area to the edge of
3328 rect
.width
+= m_rectText
.width
- posLastVisible
;
3331 Refresh(TRUE
, &rect
);
3333 // I don't know exactly why is this needed here but without it we may
3334 // scroll the window again (from the same method) before the previously
3335 // invalidated area is repainted when typing *very* quickly - and this
3336 // may lead to the display corruption
3341 void wxTextCtrl::CalcUnscrolledPosition(int x
, int y
, int *xx
, int *yy
) const
3343 if ( IsSingleLine() )
3345 // we don't use wxScrollHelper
3347 *xx
= x
+ SData().m_ofsHorz
;
3353 // let the base class do it
3354 wxScrollHelper::CalcUnscrolledPosition(x
, y
, xx
, yy
);
3358 void wxTextCtrl::CalcScrolledPosition(int x
, int y
, int *xx
, int *yy
) const
3360 if ( IsSingleLine() )
3362 // we don't use wxScrollHelper
3364 *xx
= x
- SData().m_ofsHorz
;
3370 // let the base class do it
3371 wxScrollHelper::CalcScrolledPosition(x
, y
, xx
, yy
);
3375 void wxTextCtrl::DoPrepareDC(wxDC
& dc
)
3377 // for single line controls we only have to deal with SData().m_ofsHorz and it's
3378 // useless to call base class version as they don't use normal scrolling
3379 if ( IsSingleLine() && SData().m_ofsHorz
)
3381 // adjust the DC origin if the text is shifted
3382 wxPoint pt
= dc
.GetDeviceOrigin();
3383 dc
.SetDeviceOrigin(pt
.x
- SData().m_ofsHorz
, pt
.y
);
3387 wxScrollHelper::DoPrepareDC(dc
);
3391 void wxTextCtrl::UpdateMaxWidth(wxTextCoord line
)
3395 // check if the max width changes after this line was modified
3396 wxCoord widthMaxOld
= MData().m_widthMax
,
3398 GetTextExtent(GetLineText(line
), &width
, NULL
);
3400 if ( line
== MData().m_lineLongest
)
3402 // this line was the longest one, is it still?
3403 if ( width
> MData().m_widthMax
)
3405 MData().m_widthMax
= width
;
3407 else if ( width
< MData().m_widthMax
)
3409 // we need to find the new longest line
3412 //else: its length didn't change, nothing to do
3414 else // it wasn't the longest line, but maybe it became it?
3416 // GetMaxWidth() and not MData().m_widthMax as it might be not calculated yet
3417 if ( width
> GetMaxWidth() )
3419 MData().m_widthMax
= width
;
3420 MData().m_lineLongest
= line
;
3424 MData().m_updateScrollbarX
= MData().m_widthMax
!= widthMaxOld
;
3427 void wxTextCtrl::RecalcFontMetrics()
3429 m_heightLine
= GetCharHeight();
3430 m_widthAvg
= GetCharWidth();
3433 void wxTextCtrl::RecalcMaxWidth()
3435 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3437 MData().m_widthMax
= -1;
3438 (void)GetMaxWidth();
3441 wxCoord
wxTextCtrl::GetMaxWidth() const
3443 if ( MData().m_widthMax
== -1 )
3447 // OPT: should we remember the widths of all the lines?
3449 wxTextCtrl
*self
= wxConstCast(this, wxTextCtrl
);
3450 wxClientDC
dc(self
);
3451 dc
.SetFont(GetFont());
3453 self
->MData().m_widthMax
= 0;
3455 size_t count
= GetLineCount();
3456 for ( size_t n
= 0; n
< count
; n
++ )
3459 dc
.GetTextExtent(GetLines()[n
], &width
, NULL
);
3460 if ( width
> MData().m_widthMax
)
3462 // remember the width and the line which has it
3463 self
->MData().m_widthMax
= width
;
3464 self
->MData().m_lineLongest
= n
;
3469 wxASSERT_MSG( MData().m_widthMax
!= -1, _T("should have at least 1 line") );
3471 return MData().m_widthMax
;
3474 void wxTextCtrl::UpdateScrollbars()
3476 wxASSERT_MSG( !IsSingleLine(), _T("only used for multiline") );
3478 wxSize size
= GetRealTextArea().GetSize();
3480 // is our height enough to show all items?
3481 wxTextCoord nRows
= GetRowCount();
3482 wxCoord lineHeight
= GetLineHeight();
3483 bool showScrollbarY
= nRows
*lineHeight
> size
.y
;
3485 // is our width enough to show the longest line?
3486 wxCoord charWidth
, maxWidth
;
3487 bool showScrollbarX
;
3490 charWidth
= GetAverageWidth();
3491 maxWidth
= GetMaxWidth();
3492 showScrollbarX
= maxWidth
> size
.x
;
3494 else // never show the horz scrollbar
3496 // just to suppress compiler warnings about using uninit vars below
3497 charWidth
= maxWidth
= 0;
3499 showScrollbarX
= FALSE
;
3502 // calc the scrollbars ranges
3503 int scrollRangeX
= showScrollbarX
3504 ? (maxWidth
+ 2*charWidth
- 1) / charWidth
3506 int scrollRangeY
= showScrollbarY
? nRows
: 0;
3508 int scrollRangeXOld
= MData().m_scrollRangeX
,
3509 scrollRangeYOld
= MData().m_scrollRangeY
;
3510 if ( (scrollRangeY
!= scrollRangeYOld
) || (scrollRangeX
!= scrollRangeXOld
) )
3513 GetViewStart(&x
, &y
);
3516 // we want to leave the scrollbars at the same position which means
3517 // that x and y have to be adjusted as the number of positions may have
3520 // the number of positions is calculated from knowing that last
3521 // position = range - thumbSize and thumbSize == pageSize which is
3522 // equal to the window width / pixelsPerLine
3523 if ( scrollRangeXOld
)
3525 x
*= scrollRangeX
- m_rectText
.width
/ charWidth
;
3526 x
/= scrollRangeXOld
- m_rectText
.width
/ charWidth
;
3529 if ( scrollRangeYOld
)
3530 y
*= scrollRangeY
/ scrollRangeYOld
;
3533 SetScrollbars(charWidth
, lineHeight
,
3534 scrollRangeX
, scrollRangeY
,
3536 TRUE
/* no refresh */);
3538 if ( scrollRangeXOld
)
3540 x
*= scrollRangeX
- m_rectText
.width
/ charWidth
;
3541 x
/= scrollRangeXOld
- m_rectText
.width
/ charWidth
;
3545 MData().m_scrollRangeX
= scrollRangeX
;
3546 MData().m_scrollRangeY
= scrollRangeY
;
3548 // bring the current position in view
3552 MData().m_updateScrollbarX
=
3553 MData().m_updateScrollbarY
= FALSE
;
3556 void wxTextCtrl::OnIdle(wxIdleEvent
& event
)
3558 // notice that single line text control never has scrollbars
3559 if ( !IsSingleLine() &&
3560 (MData().m_updateScrollbarX
|| MData().m_updateScrollbarY
) )
3568 bool wxTextCtrl::SendAutoScrollEvents(wxScrollWinEvent
& event
) const
3570 bool forward
= event
.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN
;
3571 if ( event
.GetOrientation() == wxHORIZONTAL
)
3573 return forward
? m_curCol
<= GetLineLength(m_curRow
) : m_curCol
> 0;
3577 return forward
? m_curRow
< GetNumberOfLines() : m_curRow
> 0;
3581 // ----------------------------------------------------------------------------
3583 // ----------------------------------------------------------------------------
3585 void wxTextCtrl::RefreshSelection()
3587 if ( HasSelection() )
3589 RefreshTextRange(m_selStart
, m_selEnd
);
3593 void wxTextCtrl::RefreshLineRange(wxTextCoord lineFirst
, wxTextCoord lineLast
)
3595 wxASSERT_MSG( lineFirst
<= lineLast
|| !lineLast
,
3596 _T("no lines to refresh") );
3599 // rect.x is already 0
3600 rect
.width
= m_rectText
.width
;
3601 wxCoord h
= GetLineHeight();
3603 wxTextCoord rowFirst
;
3604 if ( lineFirst
< GetNumberOfLines() )
3606 rowFirst
= GetFirstRowOfLine(lineFirst
);
3608 else // lineFirst == GetNumberOfLines()
3610 // lineFirst may be beyond the last line only if we refresh till
3611 // the end, otherwise it's illegal
3612 wxASSERT_MSG( lineFirst
== GetNumberOfLines() && !lineLast
,
3613 _T("invalid line range") );
3615 rowFirst
= GetRowAfterLine(lineFirst
- 1);
3618 rect
.y
= rowFirst
*h
;
3622 // refresh till this line (inclusive)
3623 wxTextCoord rowLast
= GetRowAfterLine(lineLast
);
3625 rect
.height
= (rowLast
- rowFirst
+ 1)*h
;
3627 else // lineLast == 0 means to refresh till the end
3629 // FIXME: calc it exactly
3630 rect
.height
= 32000;
3633 RefreshTextRect(rect
);
3636 void wxTextCtrl::RefreshTextRange(wxTextPos start
, wxTextPos end
)
3638 wxCHECK_RET( start
!= -1 && end
!= -1,
3639 _T("invalid RefreshTextRange() arguments") );
3641 // accept arguments in any order as it is more conenient for the caller
3642 OrderPositions(start
, end
);
3644 // this is acceptable but we don't do anything in this case
3648 wxTextPos colStart
, lineStart
;
3649 if ( !PositionToXY(start
, &colStart
, &lineStart
) )
3651 // the range is entirely beyond the end of the text, nothing to do
3655 wxTextCoord colEnd
, lineEnd
;
3656 if ( !PositionToXY(end
, &colEnd
, &lineEnd
) )
3658 // the range spans beyond the end of text, refresh to the end
3660 lineEnd
= GetNumberOfLines() - 1;
3663 // refresh all lines one by one
3664 for ( wxTextCoord line
= lineStart
; line
<= lineEnd
; line
++ )
3666 // refresh the first line from the start of the range to the end, the
3667 // intermediate ones entirely and the last one from the beginning to
3668 // the end of the range
3669 wxTextPos posStart
= line
== lineStart
? colStart
: 0;
3671 if ( (line
!= lineEnd
) || (colEnd
== -1) )
3673 // intermediate line or the last one but we need to refresh it
3674 // until the end anyhow - do it
3675 posCount
= wxSTRING_MAXLEN
;
3679 // refresh just the positions in between the start and the end one
3680 posCount
= colEnd
- posStart
;
3684 RefreshColRange(line
, posStart
, posCount
);
3688 void wxTextCtrl::RefreshColRange(wxTextCoord line
,
3692 wxString text
= GetLineText(line
);
3694 wxASSERT_MSG( (size_t)start
<= text
.length() && count
,
3695 _T("invalid RefreshColRange() parameter") );
3697 RefreshPixelRange(line
,
3698 GetTextWidth(text
.Left((size_t)start
)),
3699 GetTextWidth(text
.Mid((size_t)start
, (size_t)count
)));
3702 // this method accepts "logical" coords in the sense that they are coordinates
3703 // in a logical line but it can span several rows if we wrap lines and
3704 // RefreshPixelRange() will then refresh several rows
3705 void wxTextCtrl::RefreshPixelRange(wxTextCoord line
,
3709 // we will use line text only in line wrap case
3713 text
= GetLineText(line
);
3716 // special case: width == 0 means to refresh till the end of line
3719 // refresh till the end of visible line
3720 width
= GetTotalWidth();
3724 // refresh till the end of text
3725 wxCoord widthAll
= GetTextWidth(text
);
3727 // extend width to the end of ROW
3728 width
= widthAll
- widthAll
% width
+ width
;
3731 // no need to refresh beyond the end of line
3734 //else: just refresh the specified part
3736 wxCoord h
= GetLineHeight();
3739 rect
.y
= GetFirstRowOfLine(line
)*h
;
3744 // (1) skip all rows which we don't touch at all
3745 const wxWrappedLineData
& lineData
= WData().m_linesData
[line
];
3746 if ( !WData().IsValidLine(line
) )
3749 wxCoord wLine
= 0; // suppress compiler warning about uninit var
3750 size_t rowLast
= lineData
.GetRowCount(),
3752 while ( (row
< rowLast
) &&
3753 (rect
.x
> (wLine
= lineData
.GetRowWidth(row
++))) )
3759 // (2) now refresh all lines except the last one: note that the first
3760 // line is refreshed from the given start to the end, all the next
3762 while ( (row
< rowLast
) && (width
> wLine
- rect
.x
) )
3764 rect
.width
= GetTotalWidth() - rect
.x
;
3765 RefreshTextRect(rect
);
3767 width
-= wLine
- rect
.x
;
3771 wLine
= lineData
.GetRowWidth(row
++);
3774 // (3) the code below will refresh the last line
3779 RefreshTextRect(rect
);
3782 void wxTextCtrl::RefreshTextRect(const wxRect
& rectClient
, bool textOnly
)
3785 CalcScrolledPosition(rectClient
.x
, rectClient
.y
, &rect
.x
, &rect
.y
);
3786 rect
.width
= rectClient
.width
;
3787 rect
.height
= rectClient
.height
;
3789 // account for the text area offset
3790 rect
.Offset(m_rectText
.GetPosition());
3792 // don't refresh beyond the text area unless we're refreshing the line wrap
3793 // marks in which case textOnly is FALSE
3796 if ( rect
.GetRight() > m_rectText
.GetRight() )
3798 rect
.SetRight(m_rectText
.GetRight());
3800 if ( rect
.width
<= 0 )
3802 // nothing to refresh
3808 // check the bottom boundary always, even for the line wrap marks
3809 if ( rect
.GetBottom() > m_rectText
.GetBottom() )
3811 rect
.SetBottom(m_rectText
.GetBottom());
3813 if ( rect
.height
<= 0 )
3815 // nothing to refresh
3820 // never refresh before the visible rect
3821 if ( rect
.x
< m_rectText
.x
)
3822 rect
.x
= m_rectText
.x
;
3824 if ( rect
.y
< m_rectText
.y
)
3825 rect
.y
= m_rectText
.y
;
3827 wxLogTrace(_T("text"), _T("Refreshing (%d, %d)-(%d, %d)"),
3828 rect
.x
, rect
.y
, rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
3830 Refresh(TRUE
, &rect
);
3833 void wxTextCtrl::RefreshLineWrapMarks(wxTextCoord rowFirst
,
3834 wxTextCoord rowLast
)
3836 if ( WData().m_widthMark
)
3839 rectMarks
.x
= m_rectText
.width
;
3840 rectMarks
.width
= WData().m_widthMark
;
3841 rectMarks
.y
= rowFirst
*GetLineHeight();
3842 rectMarks
.height
= (rowLast
- rowFirst
)*GetLineHeight();
3844 RefreshTextRect(rectMarks
, FALSE
/* don't limit to text area */);
3848 // ----------------------------------------------------------------------------
3850 // ----------------------------------------------------------------------------
3852 void wxTextCtrl::DoDrawBorder(wxDC
& dc
, const wxRect
& rect
)
3854 m_renderer
->DrawTextBorder(dc
, GetBorder(), rect
, GetStateFlags());
3857 // ----------------------------------------------------------------------------
3858 // client area drawing
3859 // ----------------------------------------------------------------------------
3862 Several remarks about wxTextCtrl redraw logic:
3864 1. only the regions which must be updated are redrawn, this means that we
3865 never Refresh() the entire window but use RefreshPixelRange() and
3866 ScrollWindow() which only refresh small parts of it and iterate over the
3867 update region in our DoDraw()
3869 2. the text displayed on the screen is obtained using GetTextToShow(): it
3870 should be used for all drawing/measuring
3873 wxString
wxTextCtrl::GetTextToShow(const wxString
& text
) const
3877 textShown
= wxString(_T('*'), text
.length());
3884 void wxTextCtrl::DoDrawTextInRect(wxDC
& dc
, const wxRect
& rectUpdate
)
3886 // debugging trick to see the update rect visually
3888 static int s_countUpdates
= -1;
3889 if ( s_countUpdates
!= -1 )
3891 wxWindowDC
dc(this);
3892 dc
.SetBrush(*(++s_countUpdates
% 2 ? wxRED_BRUSH
: wxGREEN_BRUSH
));
3893 dc
.SetPen(*wxTRANSPARENT_PEN
);
3894 dc
.DrawRectangle(rectUpdate
);
3896 #endif // WXDEBUG_TEXT
3898 // calculate the range lineStart..lineEnd of lines to redraw
3899 wxTextCoord lineStart
, lineEnd
;
3900 if ( IsSingleLine() )
3907 wxPoint pt
= rectUpdate
.GetPosition();
3908 (void)HitTest(pt
, NULL
, &lineStart
);
3910 pt
.y
+= rectUpdate
.height
;
3911 (void)HitTest(pt
, NULL
, &lineEnd
);
3914 // prepare for drawing
3915 wxCoord hLine
= GetLineHeight();
3917 // these vars will be used for hit testing of the current row
3918 wxCoord y
= rectUpdate
.y
;
3919 const wxCoord x1
= rectUpdate
.x
;
3920 const wxCoord x2
= rectUpdate
.x
+ rectUpdate
.width
;
3923 rectText
.height
= hLine
;
3924 wxCoord yClient
= y
- GetClientAreaOrigin().y
;
3926 // we want to always start at the top of the line, otherwise if we redraw a
3927 // rect whose top is in the middle of a line, we'd draw this line shifted
3928 yClient
-= (yClient
- m_rectText
.y
) % hLine
;
3930 if ( IsSingleLine() )
3932 rectText
.y
= yClient
;
3934 else // multiline, adjust for scrolling
3936 CalcUnscrolledPosition(0, yClient
, NULL
, &rectText
.y
);
3939 wxRenderer
*renderer
= GetRenderer();
3941 // do draw the invalidated parts of each line: note that we iterate here
3942 // over ROWs, not over LINEs
3943 for ( wxTextCoord line
= lineStart
;
3944 y
< rectUpdate
.y
+ rectUpdate
.height
;
3946 rectText
.y
+= hLine
)
3948 // calculate the update rect in text positions for this line
3949 wxTextCoord colStart
, colEnd
, colRowStart
;
3950 wxTextCtrlHitTestResult ht
= HitTest2(y
, x1
, x2
,
3951 &line
, &colStart
, &colEnd
,
3954 if ( (ht
== wxTE_HT_BEYOND
) || (ht
== wxTE_HT_BELOW
) )
3956 wxASSERT_MSG( line
<= lineEnd
, _T("how did we get that far?") );
3958 if ( line
== lineEnd
)
3960 // we redrew everything
3964 // the update rect is beyond the end of line, no need to redraw
3965 // anything on this line - but continue with the remaining ones
3969 // for single line controls we may additionally cut off everything
3970 // which is to the right of the last visible position
3971 if ( IsSingleLine() )
3973 // don't show the columns which are scrolled out to the left
3974 if ( colStart
< SData().m_colStart
)
3975 colStart
= SData().m_colStart
;
3977 // colEnd may be less than colStart if colStart was changed by the
3979 if ( colEnd
< colStart
)
3982 // don't draw the chars beyond the rightmost one
3983 if ( SData().m_colLastVisible
== -1 )
3985 // recalculate this rightmost column
3986 UpdateLastVisible();
3989 if ( colStart
> SData().m_colLastVisible
)
3991 // don't bother redrawing something that is beyond the last
3996 if ( colEnd
> SData().m_colLastVisible
)
3998 colEnd
= SData().m_colLastVisible
;
4002 // extract the part of line we need to redraw
4003 wxString textLine
= GetTextToShow(GetLineText(line
));
4004 wxString text
= textLine
.Mid(colStart
, colEnd
- colStart
+ 1);
4006 // now deal with the selection: only do something if at least part of
4007 // the line is selected
4008 wxTextPos selStart
, selEnd
;
4009 if ( GetSelectedPartOfLine(line
, &selStart
, &selEnd
) )
4011 // and if this part is (at least partly) in the current row
4012 if ( (selStart
<= colEnd
) &&
4013 (selEnd
>= wxMax(colStart
, colRowStart
)) )
4015 // these values are relative to the start of the line while the
4016 // string passed to DrawTextLine() is only part of it, so
4017 // adjust the selection range accordingly
4018 selStart
-= colStart
;
4024 if ( (size_t)selEnd
>= text
.length() )
4025 selEnd
= text
.length();
4029 // reset selStart and selEnd to avoid passing them to
4030 // DrawTextLine() below
4036 // calculate the text coords on screen
4037 wxASSERT_MSG( colStart
>= colRowStart
, _T("invalid string part") );
4038 wxCoord ofsStart
= GetTextWidth(
4039 textLine
.Mid(colRowStart
,
4040 colStart
- colRowStart
));
4041 rectText
.x
= m_rectText
.x
+ ofsStart
;
4042 rectText
.width
= GetTextWidth(text
);
4045 renderer
->DrawTextLine(dc
, text
, rectText
, selStart
, selEnd
,
4047 wxLogTrace(_T("text"), _T("Line %ld: positions %ld-%ld redrawn."),
4048 line
, colStart
, colEnd
);
4052 void wxTextCtrl::DoDrawLineWrapMarks(wxDC
& dc
, const wxRect
& rectUpdate
)
4054 wxASSERT_MSG( WrapLines() && WData().m_widthMark
,
4055 _T("shouldn't be called at all") );
4057 wxRenderer
*renderer
= GetRenderer();
4060 rectMark
.x
= rectUpdate
.x
;
4061 rectMark
.width
= rectUpdate
.width
;
4062 wxCoord yTop
= GetClientAreaOrigin().y
;
4063 CalcUnscrolledPosition(0, rectUpdate
.y
- yTop
, NULL
, &rectMark
.y
);
4064 wxCoord hLine
= GetLineHeight();
4065 rectMark
.height
= hLine
;
4067 wxTextCoord line
, rowInLine
;
4070 CalcUnscrolledPosition(0, rectUpdate
.GetBottom() - yTop
, NULL
, &yBottom
);
4071 for ( ; rectMark
.y
< yBottom
; rectMark
.y
+= hLine
)
4073 if ( !GetLineAndRow(rectMark
.y
/ hLine
, &line
, &rowInLine
) )
4075 // we went beyond the end of text
4079 // is this row continued on the next one?
4080 if ( !WData().m_linesData
[line
].IsLastRow(rowInLine
) )
4082 renderer
->DrawLineWrapMark(dc
, rectMark
);
4087 void wxTextCtrl::DoDraw(wxControlRenderer
*renderer
)
4089 // hide the caret while we're redrawing the window and show it after we are
4091 wxCaretSuspend
cs(this);
4094 wxDC
& dc
= renderer
->GetDC();
4095 dc
.SetFont(GetFont());
4096 dc
.SetTextForeground(GetForegroundColour());
4098 // get the intersection of the update region with the text area: note that
4099 // the update region is in window coords and text area is in the client
4100 // ones, so it must be shifted before computing intersection
4101 wxRegion rgnUpdate
= GetUpdateRegion();
4102 wxRect rectTextArea
= GetRealTextArea();
4103 wxPoint pt
= GetClientAreaOrigin();
4104 wxRect rectTextAreaAdjusted
= rectTextArea
;
4105 rectTextAreaAdjusted
.x
+= pt
.x
;
4106 rectTextAreaAdjusted
.y
+= pt
.y
;
4107 rgnUpdate
.Intersect(rectTextAreaAdjusted
);
4109 // even though the drawing is already clipped to the update region, we must
4110 // explicitly clip it to the rect we will use as otherwise parts of letters
4111 // might be drawn outside of it (if even a small part of a charater is
4112 // inside, HitTest() will return its column and DrawText() can't draw only
4113 // the part of the character, of course)
4115 // FIXME: is this really a bug in wxMSW?
4116 rectTextArea
.width
--;
4118 dc
.SetClippingRegion(rectTextArea
);
4120 // adjust for scrolling
4123 // and now refresh the invalidated parts of the window
4124 wxRegionIterator
iter(rgnUpdate
);
4125 for ( ; iter
.HaveRects(); iter
++ )
4127 wxRect r
= iter
.GetRect();
4129 // this is a workaround for wxGTK::wxRegion bug
4131 if ( !r
.width
|| !r
.height
)
4133 // ignore invalid rect
4138 DoDrawTextInRect(dc
, r
);
4141 // now redraw the line wrap marks (if we draw them)
4142 if ( WrapLines() && WData().m_widthMark
)
4144 // this is the rect inside which line wrap marks are drawn
4146 rectMarks
.x
= rectTextAreaAdjusted
.GetRight() + 1;
4147 rectMarks
.y
= rectTextAreaAdjusted
.y
;
4148 rectMarks
.width
= WData().m_widthMark
;
4149 rectMarks
.height
= rectTextAreaAdjusted
.height
;
4151 rgnUpdate
= GetUpdateRegion();
4152 rgnUpdate
.Intersect(rectMarks
);
4154 wxRect rectUpdate
= rgnUpdate
.GetBox();
4155 if ( rectUpdate
.width
&& rectUpdate
.height
)
4157 // the marks are outside previously set clipping region
4158 dc
.DestroyClippingRegion();
4160 DoDrawLineWrapMarks(dc
, rectUpdate
);
4164 // show caret first time only: we must show it after drawing the text or
4165 // the display can be corrupted when it's hidden
4166 if ( !m_hasCaret
&& GetCaret() )
4174 // ----------------------------------------------------------------------------
4176 // ----------------------------------------------------------------------------
4178 bool wxTextCtrl::SetFont(const wxFont
& font
)
4180 if ( !wxControl::SetFont(font
) )
4183 // and refresh everything, of course
4184 InitInsertionPoint();
4187 // update geometry parameters
4189 RecalcFontMetrics();
4190 if ( !IsSingleLine() )
4196 // recreate it, in fact
4204 bool wxTextCtrl::Enable(bool enable
)
4206 if ( !wxTextCtrlBase::Enable(enable
) )
4214 void wxTextCtrl::CreateCaret()
4220 // FIXME use renderer
4221 caret
= new wxCaret(this, 1, GetLineHeight());
4223 caret
->SetBlinkTime(0);
4228 // read only controls don't have the caret
4229 caret
= (wxCaret
*)NULL
;
4232 // SetCaret() will delete the old caret if any
4236 void wxTextCtrl::ShowCaret(bool show
)
4238 wxCaret
*caret
= GetCaret();
4241 // (re)position caret correctly
4242 caret
->Move(GetCaretPosition());
4244 // and show it there
4249 // ----------------------------------------------------------------------------
4250 // vertical scrolling (multiline only)
4251 // ----------------------------------------------------------------------------
4253 size_t wxTextCtrl::GetLinesPerPage() const
4255 if ( IsSingleLine() )
4258 return GetRealTextArea().height
/ GetLineHeight();
4261 wxTextPos
wxTextCtrl::GetPositionAbove()
4263 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE
,
4264 _T("can't move cursor vertically in a single line control") );
4266 // move the cursor up by one ROW not by one LINE: this means that
4267 // we should really use HitTest() and not just go to the same
4268 // position in the previous line
4269 wxPoint pt
= GetCaretPosition() - m_rectText
.GetPosition();
4270 if ( MData().m_xCaret
== -1 )
4272 // remember the initial cursor abscissa
4273 MData().m_xCaret
= pt
.x
;
4277 // use the remembered abscissa
4278 pt
.x
= MData().m_xCaret
;
4281 CalcUnscrolledPosition(pt
.x
, pt
.y
, &pt
.x
, &pt
.y
);
4282 pt
.y
-= GetLineHeight();
4284 wxTextCoord col
, row
;
4285 if ( HitTestLogical(pt
, &col
, &row
) == wxTE_HT_BEFORE
)
4287 // can't move further
4288 return INVALID_POS_VALUE
;
4291 return XYToPosition(col
, row
);
4294 wxTextPos
wxTextCtrl::GetPositionBelow()
4296 wxCHECK_MSG( !IsSingleLine(), INVALID_POS_VALUE
,
4297 _T("can't move cursor vertically in a single line control") );
4299 // see comments for wxACTION_TEXT_UP
4300 wxPoint pt
= GetCaretPosition() - m_rectText
.GetPosition();
4301 if ( MData().m_xCaret
== -1 )
4303 // remember the initial cursor abscissa
4304 MData().m_xCaret
= pt
.x
;
4308 // use the remembered abscissa
4309 pt
.x
= MData().m_xCaret
;
4312 CalcUnscrolledPosition(pt
.x
, pt
.y
, &pt
.x
, &pt
.y
);
4313 pt
.y
+= GetLineHeight();
4315 wxTextCoord col
, row
;
4316 if ( HitTestLogical(pt
, &col
, &row
) == wxTE_HT_BELOW
)
4318 // can't go further down
4319 return INVALID_POS_VALUE
;
4322 // note that wxTE_HT_BEYOND is ok: it happens when we go down
4323 // from a longer line to a shorter one, for example (OTOH
4324 // wxTE_HT_BEFORE can never happen)
4325 return XYToPosition(col
, row
);
4328 // ----------------------------------------------------------------------------
4330 // ----------------------------------------------------------------------------
4332 bool wxTextCtrl::PerformAction(const wxControlAction
& actionOrig
,
4334 const wxString
& strArg
)
4336 // has the text changed as result of this action?
4337 bool textChanged
= FALSE
;
4339 // the remembered cursor abscissa for multiline text controls is usually
4340 // reset after each user action but for ones which do use it (UP and DOWN
4341 // for example) we shouldn't do it - as indicated by this flag
4342 bool rememberAbscissa
= FALSE
;
4344 // the command this action corresponds to or NULL if this action doesn't
4345 // change text at all or can't be undone
4346 wxTextCtrlCommand
*command
= (wxTextCtrlCommand
*)NULL
;
4351 if ( actionOrig
.StartsWith(wxACTION_TEXT_PREFIX_DEL
, &action
) )
4356 else if ( actionOrig
.StartsWith(wxACTION_TEXT_PREFIX_SEL
, &action
) )
4360 else // not selection nor delete action
4362 action
= actionOrig
;
4365 // set newPos to -2 as it can't become equal to it in the assignments below
4366 // (but it can become -1)
4367 wxTextPos newPos
= INVALID_POS_VALUE
;
4369 if ( action
== wxACTION_TEXT_HOME
)
4371 newPos
= m_curPos
- m_curCol
;
4373 else if ( action
== wxACTION_TEXT_END
)
4375 newPos
= m_curPos
+ GetLineLength(m_curRow
) - m_curCol
;
4377 else if ( (action
== wxACTION_TEXT_GOTO
) ||
4378 (action
== wxACTION_TEXT_FIRST
) ||
4379 (action
== wxACTION_TEXT_LAST
) )
4381 if ( action
== wxACTION_TEXT_FIRST
)
4383 else if ( action
== wxACTION_TEXT_LAST
)
4384 numArg
= GetLastPosition();
4385 //else: numArg already contains the position
4389 else if ( action
== wxACTION_TEXT_UP
)
4391 if ( !IsSingleLine() )
4393 newPos
= GetPositionAbove();
4395 if ( newPos
!= INVALID_POS_VALUE
)
4397 // remember where the cursor original had been
4398 rememberAbscissa
= TRUE
;
4402 else if ( action
== wxACTION_TEXT_DOWN
)
4404 if ( !IsSingleLine() )
4406 newPos
= GetPositionBelow();
4408 if ( newPos
!= INVALID_POS_VALUE
)
4410 // remember where the cursor original had been
4411 rememberAbscissa
= TRUE
;
4415 else if ( action
== wxACTION_TEXT_LEFT
)
4417 newPos
= m_curPos
- 1;
4419 else if ( action
== wxACTION_TEXT_WORD_LEFT
)
4421 newPos
= GetWordStart();
4423 else if ( action
== wxACTION_TEXT_RIGHT
)
4425 newPos
= m_curPos
+ 1;
4427 else if ( action
== wxACTION_TEXT_WORD_RIGHT
)
4429 newPos
= GetWordEnd();
4431 else if ( action
== wxACTION_TEXT_INSERT
)
4433 if ( IsEditable() && !strArg
.empty() )
4435 // inserting text can be undone
4436 command
= new wxTextCtrlInsertCommand(strArg
);
4441 else if ( (action
== wxACTION_TEXT_PAGE_UP
) ||
4442 (action
== wxACTION_TEXT_PAGE_DOWN
) )
4444 if ( !IsSingleLine() )
4446 size_t count
= GetLinesPerPage();
4447 if ( count
> PAGE_OVERLAP_IN_LINES
)
4449 // pages should overlap slightly to allow the reader to keep
4450 // orientation in the text
4451 count
-= PAGE_OVERLAP_IN_LINES
;
4454 // remember where the cursor original had been
4455 rememberAbscissa
= TRUE
;
4457 bool goUp
= action
== wxACTION_TEXT_PAGE_UP
;
4458 for ( size_t line
= 0; line
< count
; line
++ )
4460 wxTextPos pos
= goUp
? GetPositionAbove() : GetPositionBelow();
4461 if ( pos
== INVALID_POS_VALUE
)
4463 // can't move further
4467 MoveInsertionPoint(pos
);
4471 // we implement the Unix scrolling model here: cursor will always
4472 // be on the first line after Page Down and on the last one after
4475 // Windows programs usually keep the cursor line offset constant
4476 // but do we really need it?
4480 // find the line such that when it is the first one, the
4481 // current position is in the last line
4483 for ( size_t line
= 0; line
< count
; line
++ )
4485 pos
= GetPositionAbove();
4486 if ( pos
== INVALID_POS_VALUE
)
4489 MoveInsertionPoint(pos
);
4492 MoveInsertionPoint(newPos
);
4494 PositionToLogicalXY(pos
, NULL
, &y
);
4496 else // scrolled down
4498 PositionToLogicalXY(newPos
, NULL
, &y
);
4501 // scroll vertically only
4505 else if ( action
== wxACTION_TEXT_SEL_WORD
)
4507 SetSelection(GetWordStart(), GetWordEnd());
4509 else if ( action
== wxACTION_TEXT_ANCHOR_SEL
)
4513 else if ( action
== wxACTION_TEXT_EXTEND_SEL
)
4515 SetSelection(m_selAnchor
, numArg
);
4517 else if ( action
== wxACTION_TEXT_COPY
)
4521 else if ( action
== wxACTION_TEXT_CUT
)
4526 else if ( action
== wxACTION_TEXT_PASTE
)
4531 else if ( action
== wxACTION_TEXT_UNDO
)
4536 else if ( action
== wxACTION_TEXT_REDO
)
4543 return wxControl::PerformAction(action
, numArg
, strArg
);
4546 if ( newPos
!= INVALID_POS_VALUE
)
4548 // bring the new position into the range
4552 wxTextPos posLast
= GetLastPosition();
4553 if ( newPos
> posLast
)
4558 // if we have the selection, remove just it
4560 if ( HasSelection() )
4567 // otherwise delete everything between current position and
4569 if ( m_curPos
!= newPos
)
4574 else // nothing to delete
4576 // prevent test below from working
4577 from
= INVALID_POS_VALUE
;
4579 // and this is just to silent the compiler warning
4584 if ( from
!= INVALID_POS_VALUE
)
4586 command
= new wxTextCtrlRemoveCommand(from
, to
);
4589 else // cursor movement command
4592 DoSetInsertionPoint(newPos
);
4596 SetSelection(m_selAnchor
, m_curPos
);
4598 else // simple movement
4600 // clear the existing selection
4605 if ( !rememberAbscissa
&& !IsSingleLine() )
4607 MData().m_xCaret
= -1;
4613 // execute and remember it to be able to undo it later
4614 m_cmdProcessor
->Submit(command
);
4616 // undoable commands always change text
4619 else // no undoable command
4621 // m_cmdProcessor->StopCompressing()
4626 wxASSERT_MSG( IsEditable(), _T("non editable control changed?") );
4628 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, GetId());
4629 InitCommandEvent(event
);
4630 event
.SetString(GetValue());
4631 GetEventHandler()->ProcessEvent(event
);
4633 // as the text changed...
4634 m_isModified
= TRUE
;
4640 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
4642 // only process the key events from "simple keys" here
4643 if ( !event
.HasModifiers() )
4645 int keycode
= event
.GetKeyCode();
4646 if ( keycode
== WXK_RETURN
)
4648 if ( IsSingleLine() || (GetWindowStyle() & wxTE_PROCESS_ENTER
) )
4650 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, GetId());
4651 InitCommandEvent(event
);
4652 event
.SetString(GetValue());
4653 GetEventHandler()->ProcessEvent(event
);
4655 else // interpret <Enter> normally: insert new line
4657 PerformAction(wxACTION_TEXT_INSERT
, -1, _T('\n'));
4660 else if ( keycode
< 255 && isprint(keycode
) )
4662 PerformAction(wxACTION_TEXT_INSERT
, -1, (wxChar
)keycode
);
4664 // skip event.Skip() below
4669 // Ctrl-R refreshes the control in debug mode
4670 else if ( event
.ControlDown() && event
.GetKeyCode() == 'r' )
4672 #endif // __WXDEBUG__
4677 // ----------------------------------------------------------------------------
4678 // wxStdTextCtrlInputHandler
4679 // ----------------------------------------------------------------------------
4681 wxStdTextCtrlInputHandler::wxStdTextCtrlInputHandler(wxInputHandler
*inphand
)
4682 : wxStdInputHandler(inphand
)
4684 m_winCapture
= (wxTextCtrl
*)NULL
;
4688 wxTextPos
wxStdTextCtrlInputHandler::HitTest(const wxTextCtrl
*text
,
4691 wxTextCoord col
, row
;
4692 wxTextCtrlHitTestResult ht
= text
->HitTest(pt
, &col
, &row
);
4694 wxTextPos pos
= text
->XYToPosition(col
, row
);
4696 // if the point is after the last column we must adjust the position to be
4697 // the last position in the line (unless it is already the last)
4698 if ( (ht
== wxTE_HT_BEYOND
) && (pos
< text
->GetLastPosition()) )
4706 bool wxStdTextCtrlInputHandler::HandleKey(wxControl
*control
,
4707 const wxKeyEvent
& event
,
4710 // we're only interested in key presses
4714 int keycode
= event
.GetKeyCode();
4716 wxControlAction action
;
4718 bool ctrlDown
= event
.ControlDown(),
4719 shiftDown
= event
.ShiftDown();
4722 action
= wxACTION_TEXT_PREFIX_SEL
;
4725 // the only key combination with Alt we recognize is Alt-Bksp for undo, so
4726 // treat it first separately
4727 if ( event
.AltDown() )
4729 if ( keycode
== WXK_BACK
&& !ctrlDown
&& !shiftDown
)
4730 action
= wxACTION_TEXT_UNDO
;
4732 else switch ( keycode
)
4736 action
<< (ctrlDown
? wxACTION_TEXT_FIRST
4737 : wxACTION_TEXT_HOME
);
4741 action
<< (ctrlDown
? wxACTION_TEXT_LAST
4742 : wxACTION_TEXT_END
);
4747 action
<< wxACTION_TEXT_UP
;
4752 action
<< wxACTION_TEXT_DOWN
;
4756 action
<< (ctrlDown
? wxACTION_TEXT_WORD_LEFT
4757 : wxACTION_TEXT_LEFT
);
4761 action
<< (ctrlDown
? wxACTION_TEXT_WORD_RIGHT
4762 : wxACTION_TEXT_RIGHT
);
4767 // we don't map Ctrl-PgUp/Dn to anything special - what should it
4768 // to? for now, it's the same as without control
4769 action
<< wxACTION_TEXT_PAGE_DOWN
;
4774 action
<< wxACTION_TEXT_PAGE_UP
;
4780 action
<< wxACTION_TEXT_PREFIX_DEL
<< wxACTION_TEXT_RIGHT
;
4785 action
<< wxACTION_TEXT_PREFIX_DEL
<< wxACTION_TEXT_LEFT
;
4790 // reset the action as it could be already set to one of the
4792 action
= wxACTION_NONE
;
4799 action
= wxACTION_TEXT_REDO
;
4803 action
= wxACTION_TEXT_COPY
;
4807 action
= wxACTION_TEXT_PASTE
;
4811 action
= wxACTION_TEXT_CUT
;
4815 action
= wxACTION_TEXT_UNDO
;
4821 if ( (action
!= wxACTION_NONE
) && (action
!= wxACTION_TEXT_PREFIX_SEL
) )
4823 control
->PerformAction(action
, -1, str
);
4828 return wxStdInputHandler::HandleKey(control
, event
, pressed
);
4831 bool wxStdTextCtrlInputHandler::HandleMouse(wxControl
*control
,
4832 const wxMouseEvent
& event
)
4834 if ( event
.LeftDown() )
4836 wxASSERT_MSG( !m_winCapture
, _T("left button going down twice?") );
4838 wxTextCtrl
*text
= wxStaticCast(control
, wxTextCtrl
);
4840 m_winCapture
= text
;
4841 m_winCapture
->CaptureMouse();
4845 wxTextPos pos
= HitTest(text
, event
.GetPosition());
4848 text
->PerformAction(wxACTION_TEXT_ANCHOR_SEL
, pos
);
4851 else if ( event
.LeftDClick() )
4853 // select the word the cursor is on
4854 control
->PerformAction(wxACTION_TEXT_SEL_WORD
);
4856 else if ( event
.LeftUp() )
4860 m_winCapture
->ShowCaret();
4862 m_winCapture
->ReleaseMouse();
4863 m_winCapture
= (wxTextCtrl
*)NULL
;
4867 return wxStdInputHandler::HandleMouse(control
, event
);
4870 bool wxStdTextCtrlInputHandler::HandleMouseMove(wxControl
*control
,
4871 const wxMouseEvent
& event
)
4876 wxTextCtrl
*text
= wxStaticCast(m_winCapture
, wxTextCtrl
);
4877 wxTextPos pos
= HitTest(text
, event
.GetPosition());
4880 text
->PerformAction(wxACTION_TEXT_EXTEND_SEL
, pos
);
4884 return wxStdInputHandler::HandleMouseMove(control
, event
);
4887 bool wxStdTextCtrlInputHandler::HandleFocus(wxControl
*control
,
4888 const wxFocusEvent
& event
)
4890 wxTextCtrl
*text
= wxStaticCast(control
, wxTextCtrl
);
4892 // the selection appearance changes depending on whether we have the focus
4893 text
->RefreshSelection();
4895 // never refresh entirely
4899 #endif // wxUSE_TEXTCTRL