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