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