]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: msw/textctrl.cpp | |
3 | // Purpose: wxTextCtrl | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) | |
17 | #pragma implementation "textctrl.h" | |
18 | #endif | |
19 | ||
20 | // ---------------------------------------------------------------------------- | |
21 | // headers | |
22 | // ---------------------------------------------------------------------------- | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #if wxUSE_TEXTCTRL && !(defined(__SMARTPHONE__) && defined(__WXWINCE__)) | |
32 | ||
33 | #ifndef WX_PRECOMP | |
34 | #include "wx/textctrl.h" | |
35 | #include "wx/settings.h" | |
36 | #include "wx/brush.h" | |
37 | #include "wx/utils.h" | |
38 | #include "wx/intl.h" | |
39 | #include "wx/log.h" | |
40 | #include "wx/app.h" | |
41 | #include "wx/menu.h" | |
42 | #include "wx/math.h" | |
43 | #endif | |
44 | ||
45 | #include "wx/module.h" | |
46 | ||
47 | #if wxUSE_CLIPBOARD | |
48 | #include "wx/clipbrd.h" | |
49 | #endif | |
50 | ||
51 | #include "wx/textfile.h" | |
52 | ||
53 | #include <windowsx.h> | |
54 | ||
55 | #include "wx/msw/private.h" | |
56 | #include "wx/msw/winundef.h" | |
57 | ||
58 | #include <string.h> | |
59 | #include <stdlib.h> | |
60 | ||
61 | #ifndef __WXWINCE__ | |
62 | #include <sys/types.h> | |
63 | #endif | |
64 | ||
65 | #if wxUSE_RICHEDIT | |
66 | ||
67 | // old mingw32 has richedit stuff directly in windows.h and doesn't have | |
68 | // richedit.h at all | |
69 | #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__) | |
70 | #include <richedit.h> | |
71 | #endif | |
72 | ||
73 | #include "wx/msw/missing.h" | |
74 | ||
75 | #endif // wxUSE_RICHEDIT | |
76 | ||
77 | // ---------------------------------------------------------------------------- | |
78 | // private classes | |
79 | // ---------------------------------------------------------------------------- | |
80 | ||
81 | #if wxUSE_RICHEDIT | |
82 | ||
83 | // this module initializes RichEdit DLL(s) if needed | |
84 | class wxRichEditModule : public wxModule | |
85 | { | |
86 | public: | |
87 | virtual bool OnInit(); | |
88 | virtual void OnExit(); | |
89 | ||
90 | // load the richedit DLL of at least of required version | |
91 | static bool Load(int version = 1); | |
92 | ||
93 | private: | |
94 | // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs | |
95 | static HINSTANCE ms_hRichEdit[2]; | |
96 | ||
97 | DECLARE_DYNAMIC_CLASS(wxRichEditModule) | |
98 | }; | |
99 | ||
100 | HINSTANCE wxRichEditModule::ms_hRichEdit[2] = { NULL, NULL }; | |
101 | ||
102 | IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule) | |
103 | ||
104 | #endif // wxUSE_RICHEDIT | |
105 | ||
106 | // a small class used to set m_updatesCount to 0 (to filter duplicate events if | |
107 | // necessary) and to reset it back to -1 afterwards | |
108 | class UpdatesCountFilter | |
109 | { | |
110 | public: | |
111 | UpdatesCountFilter(int& count) | |
112 | : m_count(count) | |
113 | { | |
114 | wxASSERT_MSG( m_count == -1, _T("wrong initial m_updatesCount value") ); | |
115 | ||
116 | m_count = 0; | |
117 | } | |
118 | ||
119 | ~UpdatesCountFilter() | |
120 | { | |
121 | m_count = -1; | |
122 | } | |
123 | ||
124 | // return true if an event has been received | |
125 | bool GotUpdate() const | |
126 | { | |
127 | return m_count == 1; | |
128 | } | |
129 | ||
130 | private: | |
131 | int& m_count; | |
132 | ||
133 | DECLARE_NO_COPY_CLASS(UpdatesCountFilter) | |
134 | }; | |
135 | ||
136 | // ---------------------------------------------------------------------------- | |
137 | // event tables and other macros | |
138 | // ---------------------------------------------------------------------------- | |
139 | ||
140 | #if wxUSE_EXTENDED_RTTI | |
141 | WX_DEFINE_FLAGS( wxTextCtrlStyle ) | |
142 | ||
143 | wxBEGIN_FLAGS( wxTextCtrlStyle ) | |
144 | // new style border flags, we put them first to | |
145 | // use them for streaming out | |
146 | wxFLAGS_MEMBER(wxBORDER_SIMPLE) | |
147 | wxFLAGS_MEMBER(wxBORDER_SUNKEN) | |
148 | wxFLAGS_MEMBER(wxBORDER_DOUBLE) | |
149 | wxFLAGS_MEMBER(wxBORDER_RAISED) | |
150 | wxFLAGS_MEMBER(wxBORDER_STATIC) | |
151 | wxFLAGS_MEMBER(wxBORDER_NONE) | |
152 | ||
153 | // old style border flags | |
154 | wxFLAGS_MEMBER(wxSIMPLE_BORDER) | |
155 | wxFLAGS_MEMBER(wxSUNKEN_BORDER) | |
156 | wxFLAGS_MEMBER(wxDOUBLE_BORDER) | |
157 | wxFLAGS_MEMBER(wxRAISED_BORDER) | |
158 | wxFLAGS_MEMBER(wxSTATIC_BORDER) | |
159 | wxFLAGS_MEMBER(wxBORDER) | |
160 | ||
161 | // standard window styles | |
162 | wxFLAGS_MEMBER(wxTAB_TRAVERSAL) | |
163 | wxFLAGS_MEMBER(wxCLIP_CHILDREN) | |
164 | wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) | |
165 | wxFLAGS_MEMBER(wxWANTS_CHARS) | |
166 | wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) | |
167 | wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) | |
168 | wxFLAGS_MEMBER(wxVSCROLL) | |
169 | wxFLAGS_MEMBER(wxHSCROLL) | |
170 | ||
171 | wxFLAGS_MEMBER(wxTE_PROCESS_ENTER) | |
172 | wxFLAGS_MEMBER(wxTE_PROCESS_TAB) | |
173 | wxFLAGS_MEMBER(wxTE_MULTILINE) | |
174 | wxFLAGS_MEMBER(wxTE_PASSWORD) | |
175 | wxFLAGS_MEMBER(wxTE_READONLY) | |
176 | wxFLAGS_MEMBER(wxHSCROLL) | |
177 | wxFLAGS_MEMBER(wxTE_RICH) | |
178 | wxFLAGS_MEMBER(wxTE_RICH2) | |
179 | wxFLAGS_MEMBER(wxTE_AUTO_URL) | |
180 | wxFLAGS_MEMBER(wxTE_NOHIDESEL) | |
181 | wxFLAGS_MEMBER(wxTE_LEFT) | |
182 | wxFLAGS_MEMBER(wxTE_CENTRE) | |
183 | wxFLAGS_MEMBER(wxTE_RIGHT) | |
184 | wxFLAGS_MEMBER(wxTE_DONTWRAP) | |
185 | wxFLAGS_MEMBER(wxTE_LINEWRAP) | |
186 | wxFLAGS_MEMBER(wxTE_WORDWRAP) | |
187 | ||
188 | wxEND_FLAGS( wxTextCtrlStyle ) | |
189 | ||
190 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxTextCtrl, wxControl,"wx/textctrl.h") | |
191 | ||
192 | wxBEGIN_PROPERTIES_TABLE(wxTextCtrl) | |
193 | wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent ) | |
194 | wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent ) | |
195 | ||
196 | wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) | |
197 | wxPROPERTY( Value , wxString , SetValue, GetValue, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
198 | wxPROPERTY_FLAGS( WindowStyle , wxTextCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style | |
199 | wxEND_PROPERTIES_TABLE() | |
200 | ||
201 | wxBEGIN_HANDLERS_TABLE(wxTextCtrl) | |
202 | wxEND_HANDLERS_TABLE() | |
203 | ||
204 | wxCONSTRUCTOR_6( wxTextCtrl , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size , long , WindowStyle) | |
205 | #else | |
206 | IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) | |
207 | #endif | |
208 | ||
209 | ||
210 | BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) | |
211 | EVT_CHAR(wxTextCtrl::OnChar) | |
212 | EVT_DROP_FILES(wxTextCtrl::OnDropFiles) | |
213 | ||
214 | #if wxUSE_RICHEDIT | |
215 | EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu) | |
216 | #endif | |
217 | ||
218 | EVT_MENU(wxID_CUT, wxTextCtrl::OnCut) | |
219 | EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy) | |
220 | EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste) | |
221 | EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo) | |
222 | EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo) | |
223 | EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete) | |
224 | EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll) | |
225 | ||
226 | EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut) | |
227 | EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy) | |
228 | EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste) | |
229 | EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo) | |
230 | EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo) | |
231 | EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete) | |
232 | EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll) | |
233 | ||
234 | EVT_SET_FOCUS(wxTextCtrl::OnSetFocus) | |
235 | END_EVENT_TABLE() | |
236 | ||
237 | // ============================================================================ | |
238 | // implementation | |
239 | // ============================================================================ | |
240 | ||
241 | // ---------------------------------------------------------------------------- | |
242 | // creation | |
243 | // ---------------------------------------------------------------------------- | |
244 | ||
245 | void wxTextCtrl::Init() | |
246 | { | |
247 | #if wxUSE_RICHEDIT | |
248 | m_verRichEdit = 0; | |
249 | #endif // wxUSE_RICHEDIT | |
250 | ||
251 | m_privateContextMenu = NULL; | |
252 | m_updatesCount = -1; | |
253 | m_isNativeCaretShown = true; | |
254 | } | |
255 | ||
256 | wxTextCtrl::~wxTextCtrl() | |
257 | { | |
258 | delete m_privateContextMenu; | |
259 | } | |
260 | ||
261 | bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, | |
262 | const wxString& value, | |
263 | const wxPoint& pos, | |
264 | const wxSize& size, | |
265 | long style, | |
266 | const wxValidator& validator, | |
267 | const wxString& name) | |
268 | { | |
269 | #ifdef __WXWINCE__ | |
270 | if ((style & wxBORDER_MASK) == 0) | |
271 | style |= wxBORDER_SIMPLE; | |
272 | #endif | |
273 | ||
274 | // base initialization | |
275 | if ( !CreateControl(parent, id, pos, size, style, validator, name) ) | |
276 | return false; | |
277 | ||
278 | // translate wxWin style flags to MSW ones | |
279 | WXDWORD msStyle = MSWGetCreateWindowFlags(); | |
280 | ||
281 | // do create the control - either an EDIT or RICHEDIT | |
282 | wxString windowClass = wxT("EDIT"); | |
283 | ||
284 | #if wxUSE_RICHEDIT | |
285 | if ( m_windowStyle & wxTE_AUTO_URL ) | |
286 | { | |
287 | // automatic URL detection only works in RichEdit 2.0+ | |
288 | m_windowStyle |= wxTE_RICH2; | |
289 | } | |
290 | ||
291 | if ( m_windowStyle & wxTE_RICH2 ) | |
292 | { | |
293 | // using richedit 2.0 implies using wxTE_RICH | |
294 | m_windowStyle |= wxTE_RICH; | |
295 | } | |
296 | ||
297 | // we need to load the richedit DLL before creating the rich edit control | |
298 | if ( m_windowStyle & wxTE_RICH ) | |
299 | { | |
300 | static bool s_errorGiven = false;// MT-FIXME | |
301 | ||
302 | // Which version do we need? Use 1.0 by default because it is much more | |
303 | // like the the standard EDIT or 2.0 if explicitly requested, but use | |
304 | // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all | |
305 | // | |
306 | // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0 | |
307 | // (and thus EDIT) much better than RichEdit 2.0 so we probably | |
308 | // should use 3.0 if available as it is the best of both worlds - | |
309 | // but as I can't test it right now I don't do it (VZ) | |
310 | #if wxUSE_UNICODE | |
311 | const int verRichEdit = 2; | |
312 | #else // !wxUSE_UNICODE | |
313 | int verRichEdit = m_windowStyle & wxTE_RICH2 ? 2 : 1; | |
314 | #endif // wxUSE_UNICODE/!wxUSE_UNICODE | |
315 | ||
316 | // only give the error msg once if the DLL can't be loaded | |
317 | if ( !s_errorGiven ) | |
318 | { | |
319 | // try to load the RichEdit DLL (will do nothing if already done) | |
320 | if ( !wxRichEditModule::Load(verRichEdit) ) | |
321 | { | |
322 | #if !wxUSE_UNICODE | |
323 | // try another version? | |
324 | verRichEdit = 3 - verRichEdit; // 1 <-> 2 | |
325 | ||
326 | if ( !wxRichEditModule::Load(verRichEdit) ) | |
327 | #endif // wxUSE_UNICODE | |
328 | { | |
329 | wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll")); | |
330 | ||
331 | s_errorGiven = true; | |
332 | } | |
333 | } | |
334 | } | |
335 | ||
336 | // have we managed to load any richedit version? | |
337 | if ( !s_errorGiven ) | |
338 | { | |
339 | m_verRichEdit = verRichEdit; | |
340 | if ( m_verRichEdit == 1 ) | |
341 | { | |
342 | windowClass = wxT("RICHEDIT"); | |
343 | } | |
344 | else | |
345 | { | |
346 | #ifndef RICHEDIT_CLASS | |
347 | wxString RICHEDIT_CLASS; | |
348 | RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), m_verRichEdit); | |
349 | #if wxUSE_UNICODE | |
350 | RICHEDIT_CLASS += _T('W'); | |
351 | #else // ANSI | |
352 | RICHEDIT_CLASS += _T('A'); | |
353 | #endif // Unicode/ANSI | |
354 | #endif // !RICHEDIT_CLASS | |
355 | ||
356 | windowClass = RICHEDIT_CLASS; | |
357 | } | |
358 | } | |
359 | } | |
360 | #endif // wxUSE_RICHEDIT | |
361 | ||
362 | // we need to turn '\n's into "\r\n"s for the multiline controls | |
363 | wxString valueWin; | |
364 | if ( m_windowStyle & wxTE_MULTILINE ) | |
365 | { | |
366 | valueWin = wxTextFile::Translate(value, wxTextFileType_Dos); | |
367 | } | |
368 | else // single line | |
369 | { | |
370 | valueWin = value; | |
371 | } | |
372 | ||
373 | if ( !MSWCreateControl(windowClass, msStyle, pos, size, valueWin) ) | |
374 | return false; | |
375 | ||
376 | #if wxUSE_RICHEDIT | |
377 | if ( IsRich() ) | |
378 | { | |
379 | // enable the events we're interested in: we want to get EN_CHANGE as | |
380 | // for the normal controls | |
381 | LPARAM mask = ENM_CHANGE; | |
382 | ||
383 | if ( GetRichVersion() == 1 ) | |
384 | { | |
385 | // we also need EN_MSGFILTER for richedit 1.0 for the reasons | |
386 | // explained in its handler | |
387 | mask |= ENM_MOUSEEVENTS; | |
388 | } | |
389 | else if ( m_windowStyle & wxTE_AUTO_URL ) | |
390 | { | |
391 | mask |= ENM_LINK; | |
392 | ||
393 | ::SendMessage(GetHwnd(), EM_AUTOURLDETECT, TRUE, 0); | |
394 | } | |
395 | ||
396 | ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0, mask); | |
397 | } | |
398 | #endif // wxUSE_RICHEDIT | |
399 | ||
400 | return true; | |
401 | } | |
402 | ||
403 | // Make sure the window style (etc.) reflects the HWND style (roughly) | |
404 | void wxTextCtrl::AdoptAttributesFromHWND() | |
405 | { | |
406 | wxWindow::AdoptAttributesFromHWND(); | |
407 | ||
408 | HWND hWnd = GetHwnd(); | |
409 | long style = ::GetWindowLong(hWnd, GWL_STYLE); | |
410 | ||
411 | // retrieve the style to see whether this is an edit or richedit ctrl | |
412 | #if wxUSE_RICHEDIT | |
413 | wxString classname = wxGetWindowClass(GetHWND()); | |
414 | ||
415 | if ( classname.IsSameAs(_T("EDIT"), false /* no case */) ) | |
416 | { | |
417 | m_verRichEdit = 0; | |
418 | } | |
419 | else // rich edit? | |
420 | { | |
421 | wxChar c; | |
422 | if ( wxSscanf(classname, _T("RichEdit%d0%c"), &m_verRichEdit, &c) != 2 ) | |
423 | { | |
424 | wxLogDebug(_T("Unknown edit control '%s'."), classname.c_str()); | |
425 | ||
426 | m_verRichEdit = 0; | |
427 | } | |
428 | } | |
429 | #endif // wxUSE_RICHEDIT | |
430 | ||
431 | if (style & ES_MULTILINE) | |
432 | m_windowStyle |= wxTE_MULTILINE; | |
433 | if (style & ES_PASSWORD) | |
434 | m_windowStyle |= wxTE_PASSWORD; | |
435 | if (style & ES_READONLY) | |
436 | m_windowStyle |= wxTE_READONLY; | |
437 | if (style & ES_WANTRETURN) | |
438 | m_windowStyle |= wxTE_PROCESS_ENTER; | |
439 | if (style & ES_CENTER) | |
440 | m_windowStyle |= wxTE_CENTRE; | |
441 | if (style & ES_RIGHT) | |
442 | m_windowStyle |= wxTE_RIGHT; | |
443 | } | |
444 | ||
445 | WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const | |
446 | { | |
447 | long msStyle = wxControl::MSWGetStyle(style, exstyle); | |
448 | ||
449 | // styles which we alaways add by default | |
450 | if ( style & wxTE_MULTILINE ) | |
451 | { | |
452 | wxASSERT_MSG( !(style & wxTE_PROCESS_ENTER), | |
453 | wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") ); | |
454 | ||
455 | msStyle |= ES_MULTILINE | ES_WANTRETURN; | |
456 | if ( !(style & wxTE_NO_VSCROLL) ) | |
457 | { | |
458 | // always adjust the vertical scrollbar automatically if we have it | |
459 | msStyle |= WS_VSCROLL | ES_AUTOVSCROLL; | |
460 | ||
461 | #if wxUSE_RICHEDIT | |
462 | // we have to use this style for the rich edit controls because | |
463 | // without it the vertical scrollbar never appears at all in | |
464 | // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it) | |
465 | if ( style & wxTE_RICH2 ) | |
466 | { | |
467 | msStyle |= ES_DISABLENOSCROLL; | |
468 | } | |
469 | #endif // wxUSE_RICHEDIT | |
470 | } | |
471 | ||
472 | style |= wxTE_PROCESS_ENTER; | |
473 | } | |
474 | else // !multiline | |
475 | { | |
476 | // there is really no reason to not have this style for single line | |
477 | // text controls | |
478 | msStyle |= ES_AUTOHSCROLL; | |
479 | } | |
480 | ||
481 | // note that wxTE_DONTWRAP is the same as wxHSCROLL so if we have a horz | |
482 | // scrollbar, there is no wrapping -- which makes sense | |
483 | if ( style & wxTE_DONTWRAP ) | |
484 | { | |
485 | // automatically scroll the control horizontally as necessary | |
486 | // | |
487 | // NB: ES_AUTOHSCROLL is needed for richedit controls or they don't | |
488 | // show horz scrollbar at all, even in spite of WS_HSCROLL, and as | |
489 | // it doesn't seem to do any harm for plain edit controls, add it | |
490 | // always | |
491 | msStyle |= WS_HSCROLL | ES_AUTOHSCROLL; | |
492 | } | |
493 | ||
494 | if ( style & wxTE_READONLY ) | |
495 | msStyle |= ES_READONLY; | |
496 | ||
497 | if ( style & wxTE_PASSWORD ) | |
498 | msStyle |= ES_PASSWORD; | |
499 | ||
500 | if ( style & wxTE_NOHIDESEL ) | |
501 | msStyle |= ES_NOHIDESEL; | |
502 | ||
503 | // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0 | |
504 | if ( style & wxTE_CENTRE ) | |
505 | msStyle |= ES_CENTER; | |
506 | else if ( style & wxTE_RIGHT ) | |
507 | msStyle |= ES_RIGHT; | |
508 | else | |
509 | msStyle |= ES_LEFT; // ES_LEFT is 0 as well but for consistency... | |
510 | ||
511 | return msStyle; | |
512 | } | |
513 | ||
514 | void wxTextCtrl::SetWindowStyleFlag(long style) | |
515 | { | |
516 | #if wxUSE_RICHEDIT | |
517 | // we have to deal with some styles separately because they can't be | |
518 | // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed | |
519 | // using richedit-specific EM_SETOPTIONS | |
520 | if ( IsRich() && | |
521 | ((style & wxTE_NOHIDESEL) != (GetWindowStyle() & wxTE_NOHIDESEL)) ) | |
522 | { | |
523 | bool set = (style & wxTE_NOHIDESEL) != 0; | |
524 | ||
525 | ::SendMessage(GetHwnd(), EM_SETOPTIONS, set ? ECOOP_OR : ECOOP_AND, | |
526 | set ? ECO_NOHIDESEL : ~ECO_NOHIDESEL); | |
527 | } | |
528 | #endif // wxUSE_RICHEDIT | |
529 | ||
530 | wxControl::SetWindowStyleFlag(style); | |
531 | } | |
532 | ||
533 | // ---------------------------------------------------------------------------- | |
534 | // set/get the controls text | |
535 | // ---------------------------------------------------------------------------- | |
536 | ||
537 | wxString wxTextCtrl::GetValue() const | |
538 | { | |
539 | // range 0..-1 is special for GetRange() and means to retrieve all text | |
540 | return GetRange(0, -1); | |
541 | } | |
542 | ||
543 | wxString wxTextCtrl::GetRange(long from, long to) const | |
544 | { | |
545 | wxString str; | |
546 | ||
547 | if ( from >= to && to != -1 ) | |
548 | { | |
549 | // nothing to retrieve | |
550 | return str; | |
551 | } | |
552 | ||
553 | #if wxUSE_RICHEDIT | |
554 | if ( IsRich() ) | |
555 | { | |
556 | int len = GetWindowTextLength(GetHwnd()); | |
557 | if ( len > from ) | |
558 | { | |
559 | if ( to == -1 ) | |
560 | to = len; | |
561 | ||
562 | #if !wxUSE_UNICODE | |
563 | // we must use EM_STREAMOUT if we don't want to lose all characters | |
564 | // not representable in the current character set (EM_GETTEXTRANGE | |
565 | // simply replaces them with question marks...) | |
566 | if ( GetRichVersion() > 1 ) | |
567 | { | |
568 | // we must have some encoding, otherwise any 8bit chars in the | |
569 | // control are simply *lost* (replaced by '?') | |
570 | wxFontEncoding encoding = wxFONTENCODING_SYSTEM; | |
571 | ||
572 | wxFont font = m_defaultStyle.GetFont(); | |
573 | if ( !font.Ok() ) | |
574 | font = GetFont(); | |
575 | ||
576 | if ( font.Ok() ) | |
577 | { | |
578 | encoding = font.GetEncoding(); | |
579 | } | |
580 | ||
581 | if ( encoding == wxFONTENCODING_SYSTEM ) | |
582 | { | |
583 | encoding = wxLocale::GetSystemEncoding(); | |
584 | } | |
585 | ||
586 | if ( encoding == wxFONTENCODING_SYSTEM ) | |
587 | { | |
588 | encoding = wxFONTENCODING_ISO8859_1; | |
589 | } | |
590 | ||
591 | str = StreamOut(encoding); | |
592 | ||
593 | if ( !str.empty() ) | |
594 | { | |
595 | // we have to manually extract the required part, luckily | |
596 | // this is easy in this case as EOL characters in str are | |
597 | // just LFs because we remove CRs in wxRichEditStreamOut | |
598 | str = str.Mid(from, to - from); | |
599 | } | |
600 | } | |
601 | ||
602 | // StreamOut() wasn't used or failed, try to do it in normal way | |
603 | if ( str.empty() ) | |
604 | #endif // !wxUSE_UNICODE | |
605 | { | |
606 | // alloc one extra WORD as needed by the control | |
607 | wxStringBuffer tmp(str, ++len); | |
608 | wxChar *p = tmp; | |
609 | ||
610 | TEXTRANGE textRange; | |
611 | textRange.chrg.cpMin = from; | |
612 | textRange.chrg.cpMax = to; | |
613 | textRange.lpstrText = p; | |
614 | ||
615 | (void)::SendMessage(GetHwnd(), EM_GETTEXTRANGE, | |
616 | 0, (LPARAM)&textRange); | |
617 | ||
618 | if ( m_verRichEdit > 1 ) | |
619 | { | |
620 | // RichEdit 2.0 uses just CR ('\r') for the | |
621 | // newlines which is neither Unix nor Windows | |
622 | // style - convert it to something reasonable | |
623 | for ( ; *p; p++ ) | |
624 | { | |
625 | if ( *p == _T('\r') ) | |
626 | *p = _T('\n'); | |
627 | } | |
628 | } | |
629 | } | |
630 | ||
631 | if ( m_verRichEdit == 1 ) | |
632 | { | |
633 | // convert to the canonical form - see comment below | |
634 | str = wxTextFile::Translate(str, wxTextFileType_Unix); | |
635 | } | |
636 | } | |
637 | //else: no text at all, leave the string empty | |
638 | } | |
639 | else | |
640 | #endif // wxUSE_RICHEDIT | |
641 | { | |
642 | // retrieve all text | |
643 | str = wxGetWindowText(GetHWND()); | |
644 | ||
645 | // need only a range? | |
646 | if ( from < to ) | |
647 | { | |
648 | str = str.Mid(from, to - from); | |
649 | } | |
650 | ||
651 | // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the | |
652 | // canonical one (same one as above) for consistency with the other kinds | |
653 | // of controls and, more importantly, with the other ports | |
654 | str = wxTextFile::Translate(str, wxTextFileType_Unix); | |
655 | } | |
656 | ||
657 | return str; | |
658 | } | |
659 | ||
660 | void wxTextCtrl::SetValue(const wxString& value) | |
661 | { | |
662 | // if the text is long enough, it's faster to just set it instead of first | |
663 | // comparing it with the old one (chances are that it will be different | |
664 | // anyhow, this comparison is there to avoid flicker for small single-line | |
665 | // edit controls mostly) | |
666 | if ( (value.length() > 0x400) || (value != GetValue()) ) | |
667 | { | |
668 | DoWriteText(value, false /* not selection only */); | |
669 | ||
670 | // for compatibility, don't move the cursor when doing SetValue() | |
671 | SetInsertionPoint(0); | |
672 | } | |
673 | else // same text | |
674 | { | |
675 | // still send an event for consistency | |
676 | SendUpdateEvent(); | |
677 | } | |
678 | ||
679 | // we should reset the modified flag even if the value didn't really change | |
680 | ||
681 | // mark the control as being not dirty - we changed its text, not the | |
682 | // user | |
683 | DiscardEdits(); | |
684 | } | |
685 | ||
686 | #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU) | |
687 | ||
688 | // TODO: using memcpy() would improve performance a lot for big amounts of text | |
689 | ||
690 | DWORD CALLBACK | |
691 | wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) | |
692 | { | |
693 | *pcb = 0; | |
694 | ||
695 | const wchar_t ** const ppws = (const wchar_t **)dwCookie; | |
696 | ||
697 | wchar_t *wbuf = (wchar_t *)buf; | |
698 | const wchar_t *wpc = *ppws; | |
699 | while ( cb && *wpc ) | |
700 | { | |
701 | *wbuf++ = *wpc++; | |
702 | ||
703 | cb -= sizeof(wchar_t); | |
704 | (*pcb) += sizeof(wchar_t); | |
705 | } | |
706 | ||
707 | *ppws = wpc; | |
708 | ||
709 | return 0; | |
710 | } | |
711 | ||
712 | // helper struct used to pass parameters from wxTextCtrl to wxRichEditStreamOut | |
713 | struct wxStreamOutData | |
714 | { | |
715 | wchar_t *wpc; | |
716 | size_t len; | |
717 | }; | |
718 | ||
719 | DWORD CALLBACK | |
720 | wxRichEditStreamOut(DWORD_PTR dwCookie, BYTE *buf, LONG cb, LONG *pcb) | |
721 | { | |
722 | *pcb = 0; | |
723 | ||
724 | wxStreamOutData *data = (wxStreamOutData *)dwCookie; | |
725 | ||
726 | const wchar_t *wbuf = (const wchar_t *)buf; | |
727 | wchar_t *wpc = data->wpc; | |
728 | while ( cb ) | |
729 | { | |
730 | wchar_t wch = *wbuf++; | |
731 | ||
732 | // turn "\r\n" into "\n" on the fly | |
733 | if ( wch != L'\r' ) | |
734 | *wpc++ = wch; | |
735 | else | |
736 | data->len--; | |
737 | ||
738 | cb -= sizeof(wchar_t); | |
739 | (*pcb) += sizeof(wchar_t); | |
740 | } | |
741 | ||
742 | data->wpc = wpc; | |
743 | ||
744 | return 0; | |
745 | } | |
746 | ||
747 | ||
748 | #if wxUSE_UNICODE_MSLU | |
749 | #define UNUSED_IF_MSLU(param) | |
750 | #else | |
751 | #define UNUSED_IF_MSLU(param) param | |
752 | #endif | |
753 | ||
754 | bool | |
755 | wxTextCtrl::StreamIn(const wxString& value, | |
756 | wxFontEncoding UNUSED_IF_MSLU(encoding), | |
757 | bool selectionOnly) | |
758 | { | |
759 | #if wxUSE_UNICODE_MSLU | |
760 | const wchar_t *wpc = value.c_str(); | |
761 | #else // !wxUSE_UNICODE_MSLU | |
762 | wxCSConv conv(encoding); | |
763 | ||
764 | const size_t len = conv.MB2WC(NULL, value, value.length()); | |
765 | ||
766 | #if wxUSE_WCHAR_T | |
767 | wxWCharBuffer wchBuf(len); | |
768 | wchar_t *wpc = wchBuf.data(); | |
769 | #else | |
770 | wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t)); | |
771 | wchar_t *wpc = wchBuf; | |
772 | #endif | |
773 | ||
774 | conv.MB2WC(wpc, value, value.length()); | |
775 | #endif // wxUSE_UNICODE_MSLU | |
776 | ||
777 | // finally, stream it in the control | |
778 | EDITSTREAM eds; | |
779 | wxZeroMemory(eds); | |
780 | eds.dwCookie = (DWORD)&wpc; | |
781 | // the cast below is needed for broken (very) old mingw32 headers | |
782 | eds.pfnCallback = (EDITSTREAMCALLBACK)wxRichEditStreamIn; | |
783 | ||
784 | // same problem as in DoWriteText(): we can get multiple events here | |
785 | UpdatesCountFilter ucf(m_updatesCount); | |
786 | ||
787 | ::SendMessage(GetHwnd(), EM_STREAMIN, | |
788 | SF_TEXT | | |
789 | SF_UNICODE | | |
790 | (selectionOnly ? SFF_SELECTION : 0), | |
791 | (LPARAM)&eds); | |
792 | ||
793 | wxASSERT_MSG( ucf.GotUpdate(), _T("EM_STREAMIN didn't send EN_UPDATE?") ); | |
794 | ||
795 | if ( eds.dwError ) | |
796 | { | |
797 | wxLogLastError(_T("EM_STREAMIN")); | |
798 | } | |
799 | ||
800 | #if !wxUSE_WCHAR_T | |
801 | free(wchBuf); | |
802 | #endif // !wxUSE_WCHAR_T | |
803 | ||
804 | return true; | |
805 | } | |
806 | ||
807 | #if !wxUSE_UNICODE_MSLU | |
808 | ||
809 | wxString | |
810 | wxTextCtrl::StreamOut(wxFontEncoding encoding, bool selectionOnly) const | |
811 | { | |
812 | wxString out; | |
813 | ||
814 | const int len = GetWindowTextLength(GetHwnd()); | |
815 | ||
816 | #if wxUSE_WCHAR_T | |
817 | wxWCharBuffer wchBuf(len); | |
818 | wchar_t *wpc = wchBuf.data(); | |
819 | #else | |
820 | wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t)); | |
821 | wchar_t *wpc = wchBuf; | |
822 | #endif | |
823 | ||
824 | wxStreamOutData data; | |
825 | data.wpc = wpc; | |
826 | data.len = len; | |
827 | ||
828 | EDITSTREAM eds; | |
829 | wxZeroMemory(eds); | |
830 | eds.dwCookie = (DWORD)&data; | |
831 | eds.pfnCallback = wxRichEditStreamOut; | |
832 | ||
833 | ::SendMessage | |
834 | ( | |
835 | GetHwnd(), | |
836 | EM_STREAMOUT, | |
837 | SF_TEXT | SF_UNICODE | (selectionOnly ? SFF_SELECTION : 0), | |
838 | (LPARAM)&eds | |
839 | ); | |
840 | ||
841 | if ( eds.dwError ) | |
842 | { | |
843 | wxLogLastError(_T("EM_STREAMOUT")); | |
844 | } | |
845 | else // streamed out ok | |
846 | { | |
847 | // NUL-terminate the string because its length could have been | |
848 | // decreased by wxRichEditStreamOut | |
849 | *(wchBuf.data() + data.len) = L'\0'; | |
850 | ||
851 | // now convert to the given encoding (this is a possibly lossful | |
852 | // conversion but what else can we do) | |
853 | wxCSConv conv(encoding); | |
854 | size_t lenNeeded = conv.WC2MB(NULL, wchBuf, 0); | |
855 | if ( lenNeeded++ ) | |
856 | { | |
857 | conv.WC2MB(wxStringBuffer(out, lenNeeded), wchBuf, lenNeeded); | |
858 | } | |
859 | } | |
860 | ||
861 | #if !wxUSE_WCHAR_T | |
862 | free(wchBuf); | |
863 | #endif // !wxUSE_WCHAR_T | |
864 | ||
865 | return out; | |
866 | } | |
867 | ||
868 | #endif // !wxUSE_UNICODE_MSLU | |
869 | ||
870 | #endif // wxUSE_RICHEDIT | |
871 | ||
872 | void wxTextCtrl::WriteText(const wxString& value) | |
873 | { | |
874 | DoWriteText(value); | |
875 | } | |
876 | ||
877 | void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) | |
878 | { | |
879 | wxString valueDos; | |
880 | if ( m_windowStyle & wxTE_MULTILINE ) | |
881 | valueDos = wxTextFile::Translate(value, wxTextFileType_Dos); | |
882 | else | |
883 | valueDos = value; | |
884 | ||
885 | #if wxUSE_RICHEDIT | |
886 | // there are several complications with the rich edit controls here | |
887 | bool done = false; | |
888 | if ( IsRich() ) | |
889 | { | |
890 | // first, ensure that the new text will be in the default style | |
891 | if ( !m_defaultStyle.IsDefault() ) | |
892 | { | |
893 | long start, end; | |
894 | GetSelection(&start, &end); | |
895 | SetStyle(start, end, m_defaultStyle); | |
896 | } | |
897 | ||
898 | #if wxUSE_UNICODE_MSLU | |
899 | // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x, | |
900 | // but EM_STREAMIN works | |
901 | if ( wxUsingUnicowsDll() && GetRichVersion() > 1 ) | |
902 | { | |
903 | done = StreamIn(valueDos, wxFONTENCODING_SYSTEM, selectionOnly); | |
904 | } | |
905 | #endif // wxUSE_UNICODE_MSLU | |
906 | ||
907 | #if !wxUSE_UNICODE | |
908 | // next check if the text we're inserting must be shown in a non | |
909 | // default charset -- this only works for RichEdit > 1.0 | |
910 | if ( GetRichVersion() > 1 ) | |
911 | { | |
912 | wxFont font = m_defaultStyle.GetFont(); | |
913 | if ( !font.Ok() ) | |
914 | font = GetFont(); | |
915 | ||
916 | if ( font.Ok() ) | |
917 | { | |
918 | wxFontEncoding encoding = font.GetEncoding(); | |
919 | if ( encoding != wxFONTENCODING_SYSTEM ) | |
920 | { | |
921 | // we have to use EM_STREAMIN to force richedit control 2.0+ | |
922 | // to show any text in the non default charset -- otherwise | |
923 | // it thinks it knows better than we do and always shows it | |
924 | // in the default one | |
925 | done = StreamIn(valueDos, encoding, selectionOnly); | |
926 | } | |
927 | } | |
928 | } | |
929 | #endif // !wxUSE_UNICODE | |
930 | } | |
931 | ||
932 | if ( !done ) | |
933 | #endif // wxUSE_RICHEDIT | |
934 | { | |
935 | // in some cases we get 2 EN_CHANGE notifications after the SendMessage | |
936 | // call (this happens for plain EDITs with EM_REPLACESEL and under some | |
937 | // -- undetermined -- conditions with rich edit) and sometimes we don't | |
938 | // get any events at all (plain EDIT with WM_SETTEXT), so ensure that | |
939 | // we generate exactly one of them by ignoring all but the first one in | |
940 | // SendUpdateEvent() and generating one ourselves if we hadn't got any | |
941 | // notifications from Windows | |
942 | UpdatesCountFilter ucf(m_updatesCount); | |
943 | ||
944 | ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL : WM_SETTEXT, | |
945 | 0, (LPARAM)valueDos.c_str()); | |
946 | ||
947 | if ( !ucf.GotUpdate() ) | |
948 | { | |
949 | SendUpdateEvent(); | |
950 | } | |
951 | } | |
952 | } | |
953 | ||
954 | void wxTextCtrl::AppendText(const wxString& text) | |
955 | { | |
956 | SetInsertionPointEnd(); | |
957 | ||
958 | WriteText(text); | |
959 | ||
960 | #if wxUSE_RICHEDIT | |
961 | // don't do this if we're frozen, saves some time | |
962 | if ( !IsFrozen() && IsMultiLine() && GetRichVersion() > 1 ) | |
963 | { | |
964 | // setting the caret to the end and showing it simply doesn't work for | |
965 | // RichEdit 2.0 -- force it to still do what we want | |
966 | ::SendMessage(GetHwnd(), EM_LINESCROLL, 0, GetNumberOfLines()); | |
967 | } | |
968 | #endif // wxUSE_RICHEDIT | |
969 | } | |
970 | ||
971 | void wxTextCtrl::Clear() | |
972 | { | |
973 | ::SetWindowText(GetHwnd(), wxEmptyString); | |
974 | ||
975 | #if wxUSE_RICHEDIT | |
976 | if ( !IsRich() ) | |
977 | #endif // wxUSE_RICHEDIT | |
978 | { | |
979 | // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves | |
980 | // but the normal ones don't -- make Clear() behaviour consistent by | |
981 | // always sending this event | |
982 | ||
983 | // Windows already sends an update event for single-line | |
984 | // controls. | |
985 | if ( m_windowStyle & wxTE_MULTILINE ) | |
986 | SendUpdateEvent(); | |
987 | } | |
988 | } | |
989 | ||
990 | #ifdef __WIN32__ | |
991 | ||
992 | bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent& event) | |
993 | { | |
994 | SetFocus(); | |
995 | ||
996 | size_t lenOld = GetValue().length(); | |
997 | ||
998 | wxUint32 code = event.GetRawKeyCode(); | |
999 | ::keybd_event((BYTE)code, 0, 0 /* key press */, 0); | |
1000 | ::keybd_event((BYTE)code, 0, KEYEVENTF_KEYUP, 0); | |
1001 | ||
1002 | // assume that any alphanumeric key changes the total number of characters | |
1003 | // in the control - this should work in 99% of cases | |
1004 | return GetValue().length() != lenOld; | |
1005 | } | |
1006 | ||
1007 | #endif // __WIN32__ | |
1008 | ||
1009 | // ---------------------------------------------------------------------------- | |
1010 | // Clipboard operations | |
1011 | // ---------------------------------------------------------------------------- | |
1012 | ||
1013 | void wxTextCtrl::Copy() | |
1014 | { | |
1015 | if (CanCopy()) | |
1016 | { | |
1017 | ::SendMessage(GetHwnd(), WM_COPY, 0, 0L); | |
1018 | } | |
1019 | } | |
1020 | ||
1021 | void wxTextCtrl::Cut() | |
1022 | { | |
1023 | if (CanCut()) | |
1024 | { | |
1025 | ::SendMessage(GetHwnd(), WM_CUT, 0, 0L); | |
1026 | } | |
1027 | } | |
1028 | ||
1029 | void wxTextCtrl::Paste() | |
1030 | { | |
1031 | if (CanPaste()) | |
1032 | { | |
1033 | ::SendMessage(GetHwnd(), WM_PASTE, 0, 0L); | |
1034 | } | |
1035 | } | |
1036 | ||
1037 | bool wxTextCtrl::HasSelection() const | |
1038 | { | |
1039 | long from, to; | |
1040 | GetSelection(&from, &to); | |
1041 | return from != to; | |
1042 | } | |
1043 | ||
1044 | bool wxTextCtrl::CanCopy() const | |
1045 | { | |
1046 | // Can copy if there's a selection | |
1047 | return HasSelection(); | |
1048 | } | |
1049 | ||
1050 | bool wxTextCtrl::CanCut() const | |
1051 | { | |
1052 | return CanCopy() && IsEditable(); | |
1053 | } | |
1054 | ||
1055 | bool wxTextCtrl::CanPaste() const | |
1056 | { | |
1057 | if ( !IsEditable() ) | |
1058 | return false; | |
1059 | ||
1060 | #if wxUSE_RICHEDIT | |
1061 | if ( IsRich() ) | |
1062 | { | |
1063 | UINT cf = 0; // 0 == any format | |
1064 | ||
1065 | return ::SendMessage(GetHwnd(), EM_CANPASTE, cf, 0) != 0; | |
1066 | } | |
1067 | #endif // wxUSE_RICHEDIT | |
1068 | ||
1069 | // Standard edit control: check for straight text on clipboard | |
1070 | if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) ) | |
1071 | return false; | |
1072 | ||
1073 | bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0; | |
1074 | ::CloseClipboard(); | |
1075 | ||
1076 | return isTextAvailable; | |
1077 | } | |
1078 | ||
1079 | // ---------------------------------------------------------------------------- | |
1080 | // Accessors | |
1081 | // ---------------------------------------------------------------------------- | |
1082 | ||
1083 | void wxTextCtrl::SetEditable(bool editable) | |
1084 | { | |
1085 | HWND hWnd = GetHwnd(); | |
1086 | ::SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L); | |
1087 | } | |
1088 | ||
1089 | void wxTextCtrl::SetInsertionPoint(long pos) | |
1090 | { | |
1091 | DoSetSelection(pos, pos); | |
1092 | } | |
1093 | ||
1094 | void wxTextCtrl::SetInsertionPointEnd() | |
1095 | { | |
1096 | // we must not do anything if the caret is already there because calling | |
1097 | // SetInsertionPoint() thaws the controls if Freeze() had been called even | |
1098 | // if it doesn't actually move the caret anywhere and so the simple fact of | |
1099 | // doing it results in horrible flicker when appending big amounts of text | |
1100 | // to the control in a few chunks (see DoAddText() test in the text sample) | |
1101 | if ( GetInsertionPoint() == GetLastPosition() ) | |
1102 | { | |
1103 | return; | |
1104 | } | |
1105 | ||
1106 | long pos; | |
1107 | ||
1108 | #if wxUSE_RICHEDIT | |
1109 | if ( m_verRichEdit == 1 ) | |
1110 | { | |
1111 | // we don't have to waste time calling GetLastPosition() in this case | |
1112 | pos = -1; | |
1113 | } | |
1114 | else // !RichEdit 1.0 | |
1115 | #endif // wxUSE_RICHEDIT | |
1116 | { | |
1117 | pos = GetLastPosition(); | |
1118 | } | |
1119 | ||
1120 | SetInsertionPoint(pos); | |
1121 | } | |
1122 | ||
1123 | long wxTextCtrl::GetInsertionPoint() const | |
1124 | { | |
1125 | #if wxUSE_RICHEDIT | |
1126 | if ( IsRich() ) | |
1127 | { | |
1128 | CHARRANGE range; | |
1129 | range.cpMin = 0; | |
1130 | range.cpMax = 0; | |
1131 | ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range); | |
1132 | return range.cpMin; | |
1133 | } | |
1134 | #endif // wxUSE_RICHEDIT | |
1135 | ||
1136 | DWORD Pos = (DWORD)::SendMessage(GetHwnd(), EM_GETSEL, 0, 0L); | |
1137 | return Pos & 0xFFFF; | |
1138 | } | |
1139 | ||
1140 | wxTextPos wxTextCtrl::GetLastPosition() const | |
1141 | { | |
1142 | int numLines = GetNumberOfLines(); | |
1143 | long posStartLastLine = XYToPosition(0, numLines - 1); | |
1144 | ||
1145 | long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine); | |
1146 | ||
1147 | return posStartLastLine + lenLastLine; | |
1148 | } | |
1149 | ||
1150 | // If the return values from and to are the same, there is no | |
1151 | // selection. | |
1152 | void wxTextCtrl::GetSelection(long* from, long* to) const | |
1153 | { | |
1154 | #if wxUSE_RICHEDIT | |
1155 | if ( IsRich() ) | |
1156 | { | |
1157 | CHARRANGE charRange; | |
1158 | ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &charRange); | |
1159 | ||
1160 | *from = charRange.cpMin; | |
1161 | *to = charRange.cpMax; | |
1162 | } | |
1163 | else | |
1164 | #endif // !wxUSE_RICHEDIT | |
1165 | { | |
1166 | DWORD dwStart, dwEnd; | |
1167 | ::SendMessage(GetHwnd(), EM_GETSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd); | |
1168 | ||
1169 | *from = dwStart; | |
1170 | *to = dwEnd; | |
1171 | } | |
1172 | } | |
1173 | ||
1174 | bool wxTextCtrl::IsEditable() const | |
1175 | { | |
1176 | // strangely enough, we may be called before the control is created: our | |
1177 | // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls | |
1178 | // us | |
1179 | if ( !m_hWnd ) | |
1180 | return true; | |
1181 | ||
1182 | long style = ::GetWindowLong(GetHwnd(), GWL_STYLE); | |
1183 | ||
1184 | return (style & ES_READONLY) == 0; | |
1185 | } | |
1186 | ||
1187 | // ---------------------------------------------------------------------------- | |
1188 | // selection | |
1189 | // ---------------------------------------------------------------------------- | |
1190 | ||
1191 | void wxTextCtrl::SetSelection(long from, long to) | |
1192 | { | |
1193 | // if from and to are both -1, it means (in wxWidgets) that all text should | |
1194 | // be selected - translate into Windows convention | |
1195 | if ( (from == -1) && (to == -1) ) | |
1196 | { | |
1197 | from = 0; | |
1198 | to = -1; | |
1199 | } | |
1200 | ||
1201 | DoSetSelection(from, to); | |
1202 | } | |
1203 | ||
1204 | void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) | |
1205 | { | |
1206 | HWND hWnd = GetHwnd(); | |
1207 | ||
1208 | #if wxUSE_RICHEDIT | |
1209 | if ( IsRich() ) | |
1210 | { | |
1211 | CHARRANGE range; | |
1212 | range.cpMin = from; | |
1213 | range.cpMax = to; | |
1214 | ::SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range); | |
1215 | } | |
1216 | else | |
1217 | #endif // wxUSE_RICHEDIT | |
1218 | { | |
1219 | ::SendMessage(hWnd, EM_SETSEL, (WPARAM)from, (LPARAM)to); | |
1220 | } | |
1221 | ||
1222 | if ( scrollCaret && !IsFrozen() ) | |
1223 | { | |
1224 | #if wxUSE_RICHEDIT | |
1225 | // richedit 3.0 (i.e. the version living in riched20.dll distributed | |
1226 | // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when | |
1227 | // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL | |
1228 | // option is set (but it does work ok in richedit 1.0 mode...) | |
1229 | // | |
1230 | // so to make it work we either need to give focus to it here which | |
1231 | // will probably create many problems (dummy focus events; window | |
1232 | // containing the text control being brought to foreground | |
1233 | // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may | |
1234 | // create other problems too -- and in fact it does because if we turn | |
1235 | // on/off this style while appending the text to the control, the | |
1236 | // vertical scrollbar never appears in it even if we append tons of | |
1237 | // text and to work around this the only solution I found was to use | |
1238 | // ES_DISABLENOSCROLL | |
1239 | // | |
1240 | // this is very ugly but I don't see any other way to make this work | |
1241 | if ( GetRichVersion() > 1 ) | |
1242 | { | |
1243 | if ( !HasFlag(wxTE_NOHIDESEL) ) | |
1244 | { | |
1245 | ::SendMessage(GetHwnd(), EM_SETOPTIONS, | |
1246 | ECOOP_OR, ECO_NOHIDESEL); | |
1247 | } | |
1248 | //else: everything is already ok | |
1249 | } | |
1250 | #endif // wxUSE_RICHEDIT | |
1251 | ||
1252 | ::SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); | |
1253 | ||
1254 | #if wxUSE_RICHEDIT | |
1255 | // restore ECO_NOHIDESEL if we changed it | |
1256 | if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL) ) | |
1257 | { | |
1258 | ::SendMessage(GetHwnd(), EM_SETOPTIONS, | |
1259 | ECOOP_AND, ~ECO_NOHIDESEL); | |
1260 | } | |
1261 | #endif // wxUSE_RICHEDIT | |
1262 | } | |
1263 | } | |
1264 | ||
1265 | // ---------------------------------------------------------------------------- | |
1266 | // Working with files | |
1267 | // ---------------------------------------------------------------------------- | |
1268 | ||
1269 | bool wxTextCtrl::LoadFile(const wxString& file) | |
1270 | { | |
1271 | if ( wxTextCtrlBase::LoadFile(file) ) | |
1272 | { | |
1273 | // update the size limit if needed | |
1274 | AdjustSpaceLimit(); | |
1275 | ||
1276 | return true; | |
1277 | } | |
1278 | ||
1279 | return false; | |
1280 | } | |
1281 | ||
1282 | // ---------------------------------------------------------------------------- | |
1283 | // Editing | |
1284 | // ---------------------------------------------------------------------------- | |
1285 | ||
1286 | void wxTextCtrl::Replace(long from, long to, const wxString& value) | |
1287 | { | |
1288 | // Set selection and remove it | |
1289 | DoSetSelection(from, to, false /* don't scroll caret into view */); | |
1290 | ||
1291 | DoWriteText(value, true /* selection only */); | |
1292 | } | |
1293 | ||
1294 | void wxTextCtrl::Remove(long from, long to) | |
1295 | { | |
1296 | Replace(from, to, wxEmptyString); | |
1297 | } | |
1298 | ||
1299 | bool wxTextCtrl::IsModified() const | |
1300 | { | |
1301 | return ::SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0; | |
1302 | } | |
1303 | ||
1304 | void wxTextCtrl::MarkDirty() | |
1305 | { | |
1306 | ::SendMessage(GetHwnd(), EM_SETMODIFY, TRUE, 0L); | |
1307 | } | |
1308 | ||
1309 | void wxTextCtrl::DiscardEdits() | |
1310 | { | |
1311 | ::SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0L); | |
1312 | } | |
1313 | ||
1314 | int wxTextCtrl::GetNumberOfLines() const | |
1315 | { | |
1316 | return (int)::SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0); | |
1317 | } | |
1318 | ||
1319 | // ---------------------------------------------------------------------------- | |
1320 | // Positions <-> coords | |
1321 | // ---------------------------------------------------------------------------- | |
1322 | ||
1323 | long wxTextCtrl::XYToPosition(long x, long y) const | |
1324 | { | |
1325 | // This gets the char index for the _beginning_ of this line | |
1326 | long charIndex = ::SendMessage(GetHwnd(), EM_LINEINDEX, (WPARAM)y, (LPARAM)0); | |
1327 | ||
1328 | return charIndex + x; | |
1329 | } | |
1330 | ||
1331 | bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const | |
1332 | { | |
1333 | HWND hWnd = GetHwnd(); | |
1334 | ||
1335 | // This gets the line number containing the character | |
1336 | long lineNo; | |
1337 | #if wxUSE_RICHEDIT | |
1338 | if ( IsRich() ) | |
1339 | { | |
1340 | lineNo = ::SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos); | |
1341 | } | |
1342 | else | |
1343 | #endif // wxUSE_RICHEDIT | |
1344 | { | |
1345 | lineNo = ::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0); | |
1346 | } | |
1347 | ||
1348 | if ( lineNo == -1 ) | |
1349 | { | |
1350 | // no such line | |
1351 | return false; | |
1352 | } | |
1353 | ||
1354 | // This gets the char index for the _beginning_ of this line | |
1355 | long charIndex = ::SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0); | |
1356 | if ( charIndex == -1 ) | |
1357 | { | |
1358 | return false; | |
1359 | } | |
1360 | ||
1361 | // The X position must therefore be the different between pos and charIndex | |
1362 | if ( x ) | |
1363 | *x = pos - charIndex; | |
1364 | if ( y ) | |
1365 | *y = lineNo; | |
1366 | ||
1367 | return true; | |
1368 | } | |
1369 | ||
1370 | wxTextCtrlHitTestResult | |
1371 | wxTextCtrl::HitTest(const wxPoint& pt, long *posOut) const | |
1372 | { | |
1373 | // first get the position from Windows | |
1374 | LPARAM lParam; | |
1375 | ||
1376 | #if wxUSE_RICHEDIT | |
1377 | POINTL ptl; | |
1378 | if ( IsRich() ) | |
1379 | { | |
1380 | // for rich edit controls the position is passed iva the struct fields | |
1381 | ptl.x = pt.x; | |
1382 | ptl.y = pt.y; | |
1383 | lParam = (LPARAM)&ptl; | |
1384 | } | |
1385 | else | |
1386 | #endif // wxUSE_RICHEDIT | |
1387 | { | |
1388 | // for the plain ones, we are limited to 16 bit positions which are | |
1389 | // combined in a single 32 bit value | |
1390 | lParam = MAKELPARAM(pt.x, pt.y); | |
1391 | } | |
1392 | ||
1393 | LRESULT pos = ::SendMessage(GetHwnd(), EM_CHARFROMPOS, 0, lParam); | |
1394 | ||
1395 | if ( pos == -1 ) | |
1396 | { | |
1397 | // this seems to indicate an error... | |
1398 | return wxTE_HT_UNKNOWN; | |
1399 | } | |
1400 | ||
1401 | #if wxUSE_RICHEDIT | |
1402 | if ( !IsRich() ) | |
1403 | #endif // wxUSE_RICHEDIT | |
1404 | { | |
1405 | // for plain EDIT controls the higher word contains something else | |
1406 | pos = LOWORD(pos); | |
1407 | } | |
1408 | ||
1409 | ||
1410 | // next determine where it is relatively to our point: EM_CHARFROMPOS | |
1411 | // always returns the closest character but we need to be more precise, so | |
1412 | // double check that we really are where it pretends | |
1413 | POINTL ptReal; | |
1414 | ||
1415 | #if wxUSE_RICHEDIT | |
1416 | // FIXME: we need to distinguish between richedit 2 and 3 here somehow but | |
1417 | // we don't know how to do it | |
1418 | if ( IsRich() ) | |
1419 | { | |
1420 | ::SendMessage(GetHwnd(), EM_POSFROMCHAR, (WPARAM)&ptReal, pos); | |
1421 | } | |
1422 | else | |
1423 | #endif // wxUSE_RICHEDIT | |
1424 | { | |
1425 | LRESULT lRc = ::SendMessage(GetHwnd(), EM_POSFROMCHAR, pos, 0); | |
1426 | ||
1427 | if ( lRc == -1 ) | |
1428 | { | |
1429 | // this is apparently returned when pos corresponds to the last | |
1430 | // position | |
1431 | ptReal.x = | |
1432 | ptReal.y = 0; | |
1433 | } | |
1434 | else | |
1435 | { | |
1436 | ptReal.x = LOWORD(lRc); | |
1437 | ptReal.y = HIWORD(lRc); | |
1438 | } | |
1439 | } | |
1440 | ||
1441 | wxTextCtrlHitTestResult rc; | |
1442 | ||
1443 | if ( pt.y > ptReal.y + GetCharHeight() ) | |
1444 | rc = wxTE_HT_BELOW; | |
1445 | else if ( pt.x > ptReal.x + GetCharWidth() ) | |
1446 | rc = wxTE_HT_BEYOND; | |
1447 | else | |
1448 | rc = wxTE_HT_ON_TEXT; | |
1449 | ||
1450 | if ( posOut ) | |
1451 | *posOut = pos; | |
1452 | ||
1453 | return rc; | |
1454 | } | |
1455 | ||
1456 | // ---------------------------------------------------------------------------- | |
1457 | // | |
1458 | // ---------------------------------------------------------------------------- | |
1459 | ||
1460 | void wxTextCtrl::ShowPosition(long pos) | |
1461 | { | |
1462 | HWND hWnd = GetHwnd(); | |
1463 | ||
1464 | // To scroll to a position, we pass the number of lines and characters | |
1465 | // to scroll *by*. This means that we need to: | |
1466 | // (1) Find the line position of the current line. | |
1467 | // (2) Find the line position of pos. | |
1468 | // (3) Scroll by (pos - current). | |
1469 | // For now, ignore the horizontal scrolling. | |
1470 | ||
1471 | // Is this where scrolling is relative to - the line containing the caret? | |
1472 | // Or is the first visible line??? Try first visible line. | |
1473 | // int currentLineLineNo1 = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L); | |
1474 | ||
1475 | int currentLineLineNo = (int)::SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L); | |
1476 | ||
1477 | int specifiedLineLineNo = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L); | |
1478 | ||
1479 | int linesToScroll = specifiedLineLineNo - currentLineLineNo; | |
1480 | ||
1481 | if (linesToScroll != 0) | |
1482 | (void)::SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll); | |
1483 | } | |
1484 | ||
1485 | long wxTextCtrl::GetLengthOfLineContainingPos(long pos) const | |
1486 | { | |
1487 | return ::SendMessage(GetHwnd(), EM_LINELENGTH, (WPARAM)pos, 0); | |
1488 | } | |
1489 | ||
1490 | int wxTextCtrl::GetLineLength(long lineNo) const | |
1491 | { | |
1492 | long pos = XYToPosition(0, lineNo); | |
1493 | ||
1494 | return GetLengthOfLineContainingPos(pos); | |
1495 | } | |
1496 | ||
1497 | wxString wxTextCtrl::GetLineText(long lineNo) const | |
1498 | { | |
1499 | size_t len = (size_t)GetLineLength(lineNo) + 1; | |
1500 | ||
1501 | // there must be at least enough place for the length WORD in the | |
1502 | // buffer | |
1503 | len += sizeof(WORD); | |
1504 | ||
1505 | wxString str; | |
1506 | { | |
1507 | wxStringBufferLength tmp(str, len); | |
1508 | wxChar *buf = tmp; | |
1509 | ||
1510 | *(WORD *)buf = (WORD)len; | |
1511 | len = (size_t)::SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf); | |
1512 | ||
1513 | #if wxUSE_RICHEDIT | |
1514 | if ( IsRich() ) | |
1515 | { | |
1516 | // remove the '\r' returned by the rich edit control, the user code | |
1517 | // should never see it | |
1518 | if ( buf[len - 2] == _T('\r') && buf[len - 1] == _T('\n') ) | |
1519 | { | |
1520 | buf[len - 2] = _T('\n'); | |
1521 | len--; | |
1522 | } | |
1523 | } | |
1524 | #endif // wxUSE_RICHEDIT | |
1525 | ||
1526 | // remove the '\n' at the end, if any (this is how this function is | |
1527 | // supposed to work according to the docs) | |
1528 | if ( buf[len - 1] == _T('\n') ) | |
1529 | { | |
1530 | len--; | |
1531 | } | |
1532 | ||
1533 | buf[len] = 0; | |
1534 | tmp.SetLength(len); | |
1535 | } | |
1536 | ||
1537 | return str; | |
1538 | } | |
1539 | ||
1540 | void wxTextCtrl::SetMaxLength(unsigned long len) | |
1541 | { | |
1542 | #if wxUSE_RICHEDIT | |
1543 | if (IsRich()) | |
1544 | ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, (LPARAM) (DWORD) len); | |
1545 | else | |
1546 | #endif | |
1547 | ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0); | |
1548 | } | |
1549 | ||
1550 | // ---------------------------------------------------------------------------- | |
1551 | // Undo/redo | |
1552 | // ---------------------------------------------------------------------------- | |
1553 | ||
1554 | void wxTextCtrl::Undo() | |
1555 | { | |
1556 | if (CanUndo()) | |
1557 | { | |
1558 | ::SendMessage(GetHwnd(), EM_UNDO, 0, 0); | |
1559 | } | |
1560 | } | |
1561 | ||
1562 | void wxTextCtrl::Redo() | |
1563 | { | |
1564 | if (CanRedo()) | |
1565 | { | |
1566 | #if wxUSE_RICHEDIT | |
1567 | if (GetRichVersion() > 1) | |
1568 | ::SendMessage(GetHwnd(), EM_REDO, 0, 0); | |
1569 | else | |
1570 | #endif | |
1571 | // Same as Undo, since Undo undoes the undo, i.e. a redo. | |
1572 | ::SendMessage(GetHwnd(), EM_UNDO, 0, 0); | |
1573 | } | |
1574 | } | |
1575 | ||
1576 | bool wxTextCtrl::CanUndo() const | |
1577 | { | |
1578 | return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; | |
1579 | } | |
1580 | ||
1581 | bool wxTextCtrl::CanRedo() const | |
1582 | { | |
1583 | #if wxUSE_RICHEDIT | |
1584 | if (GetRichVersion() > 1) | |
1585 | return ::SendMessage(GetHwnd(), EM_CANREDO, 0, 0) != 0; | |
1586 | else | |
1587 | #endif | |
1588 | return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; | |
1589 | } | |
1590 | ||
1591 | // ---------------------------------------------------------------------------- | |
1592 | // caret handling (Windows only) | |
1593 | // ---------------------------------------------------------------------------- | |
1594 | ||
1595 | bool wxTextCtrl::ShowNativeCaret(bool show) | |
1596 | { | |
1597 | if ( show != m_isNativeCaretShown ) | |
1598 | { | |
1599 | if ( !(show ? ::ShowCaret(GetHwnd()) : ::HideCaret(GetHwnd())) ) | |
1600 | { | |
1601 | // not an error, may simply indicate that it's not shown/hidden | |
1602 | // yet (i.e. it had been hidden/showh 2 times before) | |
1603 | return false; | |
1604 | } | |
1605 | ||
1606 | m_isNativeCaretShown = show; | |
1607 | } | |
1608 | ||
1609 | return true; | |
1610 | } | |
1611 | ||
1612 | // ---------------------------------------------------------------------------- | |
1613 | // implemenation details | |
1614 | // ---------------------------------------------------------------------------- | |
1615 | ||
1616 | void wxTextCtrl::Command(wxCommandEvent & event) | |
1617 | { | |
1618 | SetValue(event.GetString()); | |
1619 | ProcessCommand (event); | |
1620 | } | |
1621 | ||
1622 | void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event) | |
1623 | { | |
1624 | // By default, load the first file into the text window. | |
1625 | if (event.GetNumberOfFiles() > 0) | |
1626 | { | |
1627 | LoadFile(event.GetFiles()[0]); | |
1628 | } | |
1629 | } | |
1630 | ||
1631 | // ---------------------------------------------------------------------------- | |
1632 | // kbd input processing | |
1633 | // ---------------------------------------------------------------------------- | |
1634 | ||
1635 | bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) | |
1636 | { | |
1637 | MSG *msg = (MSG *)pMsg; | |
1638 | ||
1639 | // check for our special keys here: if we don't do it and the parent frame | |
1640 | // uses them as accelerators, they wouldn't work at all, so we disable | |
1641 | // usual preprocessing for them | |
1642 | if ( msg->message == WM_KEYDOWN ) | |
1643 | { | |
1644 | WORD vkey = (WORD) msg->wParam; | |
1645 | if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN ) | |
1646 | { | |
1647 | if ( vkey == VK_BACK ) | |
1648 | return false; | |
1649 | } | |
1650 | else // no Alt | |
1651 | { | |
1652 | // we want to process some Ctrl-foo and Shift-bar but no key | |
1653 | // combinations without either Ctrl or Shift nor with both of them | |
1654 | // pressed | |
1655 | const int ctrl = wxIsCtrlDown(), | |
1656 | shift = wxIsShiftDown(); | |
1657 | switch ( ctrl + shift ) | |
1658 | { | |
1659 | default: | |
1660 | wxFAIL_MSG( _T("how many modifiers have we got?") ); | |
1661 | // fall through | |
1662 | ||
1663 | case 0: | |
1664 | case 2: | |
1665 | break; | |
1666 | ||
1667 | case 1: | |
1668 | // either Ctrl or Shift pressed | |
1669 | if ( ctrl ) | |
1670 | { | |
1671 | switch ( vkey ) | |
1672 | { | |
1673 | case 'C': | |
1674 | case 'V': | |
1675 | case 'X': | |
1676 | case VK_INSERT: | |
1677 | case VK_DELETE: | |
1678 | case VK_HOME: | |
1679 | case VK_END: | |
1680 | return false; | |
1681 | } | |
1682 | } | |
1683 | else // Shift is pressed | |
1684 | { | |
1685 | if ( vkey == VK_INSERT || vkey == VK_DELETE ) | |
1686 | return false; | |
1687 | } | |
1688 | } | |
1689 | } | |
1690 | } | |
1691 | ||
1692 | return wxControl::MSWShouldPreProcessMessage(pMsg); | |
1693 | } | |
1694 | ||
1695 | void wxTextCtrl::OnChar(wxKeyEvent& event) | |
1696 | { | |
1697 | switch ( event.GetKeyCode() ) | |
1698 | { | |
1699 | case WXK_RETURN: | |
1700 | if ( !HasFlag(wxTE_MULTILINE) ) | |
1701 | { | |
1702 | wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId); | |
1703 | InitCommandEvent(event); | |
1704 | event.SetString(GetValue()); | |
1705 | if ( GetEventHandler()->ProcessEvent(event) ) | |
1706 | return; | |
1707 | } | |
1708 | //else: multiline controls need Enter for themselves | |
1709 | ||
1710 | break; | |
1711 | ||
1712 | case WXK_TAB: | |
1713 | // ok, so this is getting absolutely ridiculous but I don't see | |
1714 | // any other way to fix this bug: when a multiline text control is | |
1715 | // inside a wxFrame, we need to generate the navigation event as | |
1716 | // otherwise nothing happens at all, but when the same control is | |
1717 | // created inside a dialog, IsDialogMessage() *does* switch focus | |
1718 | // all by itself and so if we do it here as well, it is advanced | |
1719 | // twice and goes to the next control... to prevent this from | |
1720 | // happening we're doing this ugly check, the logic being that if | |
1721 | // we don't have focus then it had been already changed to the next | |
1722 | // control | |
1723 | // | |
1724 | // the right thing to do would, of course, be to understand what | |
1725 | // the hell is IsDialogMessage() doing but this is beyond my feeble | |
1726 | // forces at the moment unfortunately | |
1727 | if ( !(m_windowStyle & wxTE_PROCESS_TAB)) | |
1728 | { | |
1729 | if ( FindFocus() == this ) | |
1730 | { | |
1731 | int flags = 0; | |
1732 | if (!event.ShiftDown()) | |
1733 | flags |= wxNavigationKeyEvent::IsForward ; | |
1734 | if (event.ControlDown()) | |
1735 | flags |= wxNavigationKeyEvent::WinChange ; | |
1736 | if (Navigate(flags)) | |
1737 | return; | |
1738 | } | |
1739 | } | |
1740 | else | |
1741 | { | |
1742 | // Insert tab since calling the default Windows handler | |
1743 | // doesn't seem to do it | |
1744 | WriteText(wxT("\t")); | |
1745 | } | |
1746 | break; | |
1747 | } | |
1748 | ||
1749 | // no, we didn't process it | |
1750 | event.Skip(); | |
1751 | } | |
1752 | ||
1753 | WXLRESULT wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) | |
1754 | { | |
1755 | WXLRESULT lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam); | |
1756 | ||
1757 | if ( nMsg == WM_GETDLGCODE ) | |
1758 | { | |
1759 | // we always want the chars and the arrows: the arrows for navigation | |
1760 | // and the chars because we want Ctrl-C to work even in a read only | |
1761 | // control | |
1762 | long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS; | |
1763 | ||
1764 | if ( IsEditable() ) | |
1765 | { | |
1766 | // we may have several different cases: | |
1767 | // 1. normal case: both TAB and ENTER are used for dlg navigation | |
1768 | // 2. ctrl which wants TAB for itself: ENTER is used to pass to the | |
1769 | // next control in the dialog | |
1770 | // 3. ctrl which wants ENTER for itself: TAB is used for dialog | |
1771 | // navigation | |
1772 | // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go | |
1773 | // to the next control | |
1774 | ||
1775 | // the multiline edit control should always get <Return> for itself | |
1776 | if ( HasFlag(wxTE_PROCESS_ENTER) || HasFlag(wxTE_MULTILINE) ) | |
1777 | lDlgCode |= DLGC_WANTMESSAGE; | |
1778 | ||
1779 | if ( HasFlag(wxTE_PROCESS_TAB) ) | |
1780 | lDlgCode |= DLGC_WANTTAB; | |
1781 | ||
1782 | lRc |= lDlgCode; | |
1783 | } | |
1784 | else // !editable | |
1785 | { | |
1786 | // NB: use "=", not "|=" as the base class version returns the | |
1787 | // same flags is this state as usual (i.e. including | |
1788 | // DLGC_WANTMESSAGE). This is strange (how does it work in the | |
1789 | // native Win32 apps?) but for now live with it. | |
1790 | lRc = lDlgCode; | |
1791 | } | |
1792 | } | |
1793 | ||
1794 | return lRc; | |
1795 | } | |
1796 | ||
1797 | // ---------------------------------------------------------------------------- | |
1798 | // text control event processing | |
1799 | // ---------------------------------------------------------------------------- | |
1800 | ||
1801 | bool wxTextCtrl::SendUpdateEvent() | |
1802 | { | |
1803 | switch ( m_updatesCount ) | |
1804 | { | |
1805 | case 0: | |
1806 | // remember that we've got an update | |
1807 | m_updatesCount++; | |
1808 | break; | |
1809 | ||
1810 | case 1: | |
1811 | // we had already sent one event since the last control modification | |
1812 | return false; | |
1813 | ||
1814 | default: | |
1815 | wxFAIL_MSG( _T("unexpected wxTextCtrl::m_updatesCount value") ); | |
1816 | // fall through | |
1817 | ||
1818 | case -1: | |
1819 | // we hadn't updated the control ourselves, this event comes from | |
1820 | // the user, don't need to ignore it nor update the count | |
1821 | break; | |
1822 | } | |
1823 | ||
1824 | wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId()); | |
1825 | InitCommandEvent(event); | |
1826 | ||
1827 | return ProcessCommand(event); | |
1828 | } | |
1829 | ||
1830 | bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) | |
1831 | { | |
1832 | switch ( param ) | |
1833 | { | |
1834 | case EN_SETFOCUS: | |
1835 | case EN_KILLFOCUS: | |
1836 | { | |
1837 | wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS | |
1838 | : wxEVT_SET_FOCUS, | |
1839 | m_windowId); | |
1840 | event.SetEventObject(this); | |
1841 | GetEventHandler()->ProcessEvent(event); | |
1842 | } | |
1843 | break; | |
1844 | ||
1845 | case EN_CHANGE: | |
1846 | SendUpdateEvent(); | |
1847 | break; | |
1848 | ||
1849 | case EN_MAXTEXT: | |
1850 | // the text size limit has been hit -- try to increase it | |
1851 | if ( !AdjustSpaceLimit() ) | |
1852 | { | |
1853 | wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId); | |
1854 | InitCommandEvent(event); | |
1855 | event.SetString(GetValue()); | |
1856 | ProcessCommand(event); | |
1857 | } | |
1858 | break; | |
1859 | ||
1860 | // the other edit notification messages are not processed | |
1861 | default: | |
1862 | return false; | |
1863 | } | |
1864 | ||
1865 | // processed | |
1866 | return true; | |
1867 | } | |
1868 | ||
1869 | WXHBRUSH wxTextCtrl::MSWControlColor(WXHDC hDC) | |
1870 | { | |
1871 | if ( !IsEnabled() && !HasFlag(wxTE_MULTILINE) ) | |
1872 | return MSWControlColorDisabled(hDC); | |
1873 | ||
1874 | return wxTextCtrlBase::MSWControlColorSolid(hDC); | |
1875 | } | |
1876 | ||
1877 | bool wxTextCtrl::AdjustSpaceLimit() | |
1878 | { | |
1879 | unsigned int limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0); | |
1880 | ||
1881 | // HACK: we try to automatically extend the limit for the amount of text | |
1882 | // to allow (interactively) entering more than 64Kb of text under | |
1883 | // Win9x but we shouldn't reset the text limit which was previously | |
1884 | // set explicitly with SetMaxLength() | |
1885 | // | |
1886 | // we could solve this by storing the limit we set in wxTextCtrl but | |
1887 | // to save space we prefer to simply test here the actual limit | |
1888 | // value: we consider that SetMaxLength() can only be called for | |
1889 | // values < 32Kb | |
1890 | if ( limit < 0x8000 ) | |
1891 | { | |
1892 | // we've got more text than limit set by SetMaxLength() | |
1893 | return false; | |
1894 | } | |
1895 | ||
1896 | unsigned int len = ::GetWindowTextLength(GetHwnd()); | |
1897 | if ( len >= limit ) | |
1898 | { | |
1899 | limit = len + 0x8000; // 32Kb | |
1900 | ||
1901 | #if wxUSE_RICHEDIT | |
1902 | if ( IsRich() ) | |
1903 | { | |
1904 | // as a nice side effect, this also allows passing limit > 64Kb | |
1905 | ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit); | |
1906 | } | |
1907 | else | |
1908 | #endif // wxUSE_RICHEDIT | |
1909 | { | |
1910 | if ( limit > 0xffff ) | |
1911 | { | |
1912 | // this will set it to a platform-dependent maximum (much more | |
1913 | // than 64Kb under NT) | |
1914 | limit = 0; | |
1915 | } | |
1916 | ||
1917 | ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0); | |
1918 | } | |
1919 | } | |
1920 | ||
1921 | // we changed the limit | |
1922 | return true; | |
1923 | } | |
1924 | ||
1925 | bool wxTextCtrl::AcceptsFocus() const | |
1926 | { | |
1927 | // we don't want focus if we can't be edited unless we're a multiline | |
1928 | // control because then it might be still nice to get focus from keyboard | |
1929 | // to be able to scroll it without mouse | |
1930 | return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus(); | |
1931 | } | |
1932 | ||
1933 | wxSize wxTextCtrl::DoGetBestSize() const | |
1934 | { | |
1935 | int cx, cy; | |
1936 | wxGetCharSize(GetHWND(), &cx, &cy, GetFont()); | |
1937 | ||
1938 | int wText = DEFAULT_ITEM_WIDTH; | |
1939 | ||
1940 | int hText = cy; | |
1941 | if ( m_windowStyle & wxTE_MULTILINE ) | |
1942 | { | |
1943 | hText *= wxMax(GetNumberOfLines(), 5); | |
1944 | } | |
1945 | //else: for single line control everything is ok | |
1946 | ||
1947 | // we have to add the adjustments for the control height only once, not | |
1948 | // once per line, so do it after multiplication above | |
1949 | hText += EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) - cy; | |
1950 | ||
1951 | return wxSize(wText, hText); | |
1952 | } | |
1953 | ||
1954 | // ---------------------------------------------------------------------------- | |
1955 | // standard handlers for standard edit menu events | |
1956 | // ---------------------------------------------------------------------------- | |
1957 | ||
1958 | void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event)) | |
1959 | { | |
1960 | Cut(); | |
1961 | } | |
1962 | ||
1963 | void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event)) | |
1964 | { | |
1965 | Copy(); | |
1966 | } | |
1967 | ||
1968 | void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event)) | |
1969 | { | |
1970 | Paste(); | |
1971 | } | |
1972 | ||
1973 | void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event)) | |
1974 | { | |
1975 | Undo(); | |
1976 | } | |
1977 | ||
1978 | void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event)) | |
1979 | { | |
1980 | Redo(); | |
1981 | } | |
1982 | ||
1983 | void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event)) | |
1984 | { | |
1985 | long from, to; | |
1986 | GetSelection(& from, & to); | |
1987 | if (from != -1 && to != -1) | |
1988 | Remove(from, to); | |
1989 | } | |
1990 | ||
1991 | void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event)) | |
1992 | { | |
1993 | SetSelection(-1, -1); | |
1994 | } | |
1995 | ||
1996 | void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event) | |
1997 | { | |
1998 | event.Enable( CanCut() ); | |
1999 | } | |
2000 | ||
2001 | void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event) | |
2002 | { | |
2003 | event.Enable( CanCopy() ); | |
2004 | } | |
2005 | ||
2006 | void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event) | |
2007 | { | |
2008 | event.Enable( CanPaste() ); | |
2009 | } | |
2010 | ||
2011 | void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event) | |
2012 | { | |
2013 | event.Enable( CanUndo() ); | |
2014 | } | |
2015 | ||
2016 | void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) | |
2017 | { | |
2018 | event.Enable( CanRedo() ); | |
2019 | } | |
2020 | ||
2021 | void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event) | |
2022 | { | |
2023 | long from, to; | |
2024 | GetSelection(& from, & to); | |
2025 | event.Enable(from != -1 && to != -1 && from != to && IsEditable()) ; | |
2026 | } | |
2027 | ||
2028 | void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event) | |
2029 | { | |
2030 | event.Enable(GetLastPosition() > 0); | |
2031 | } | |
2032 | ||
2033 | void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event) | |
2034 | { | |
2035 | #if wxUSE_RICHEDIT | |
2036 | if (IsRich()) | |
2037 | { | |
2038 | if (!m_privateContextMenu) | |
2039 | { | |
2040 | m_privateContextMenu = new wxMenu; | |
2041 | m_privateContextMenu->Append(wxID_UNDO, _("&Undo")); | |
2042 | m_privateContextMenu->Append(wxID_REDO, _("&Redo")); | |
2043 | m_privateContextMenu->AppendSeparator(); | |
2044 | m_privateContextMenu->Append(wxID_CUT, _("Cu&t")); | |
2045 | m_privateContextMenu->Append(wxID_COPY, _("&Copy")); | |
2046 | m_privateContextMenu->Append(wxID_PASTE, _("&Paste")); | |
2047 | m_privateContextMenu->Append(wxID_CLEAR, _("&Delete")); | |
2048 | m_privateContextMenu->AppendSeparator(); | |
2049 | m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All")); | |
2050 | } | |
2051 | PopupMenu(m_privateContextMenu); | |
2052 | return; | |
2053 | } | |
2054 | else | |
2055 | #endif | |
2056 | event.Skip(); | |
2057 | } | |
2058 | ||
2059 | void wxTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event)) | |
2060 | { | |
2061 | // be sure the caret remains invisible if the user had hidden it | |
2062 | if ( !m_isNativeCaretShown ) | |
2063 | { | |
2064 | ::HideCaret(GetHwnd()); | |
2065 | } | |
2066 | } | |
2067 | ||
2068 | // ---------------------------------------------------------------------------- | |
2069 | // Default colors for MSW text control | |
2070 | // | |
2071 | // Set default background color to the native white instead of | |
2072 | // the default wxSYS_COLOUR_BTNFACE (is triggered with wxNullColour). | |
2073 | // ---------------------------------------------------------------------------- | |
2074 | ||
2075 | wxVisualAttributes wxTextCtrl::GetDefaultAttributes() const | |
2076 | { | |
2077 | wxVisualAttributes attrs; | |
2078 | attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); | |
2079 | attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); | |
2080 | attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); //white | |
2081 | ||
2082 | return attrs; | |
2083 | } | |
2084 | ||
2085 | // the rest of the file only deals with the rich edit controls | |
2086 | #if wxUSE_RICHEDIT | |
2087 | ||
2088 | // ---------------------------------------------------------------------------- | |
2089 | // EN_LINK processing | |
2090 | // ---------------------------------------------------------------------------- | |
2091 | ||
2092 | bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) | |
2093 | { | |
2094 | NMHDR *hdr = (NMHDR* )lParam; | |
2095 | switch ( hdr->code ) | |
2096 | { | |
2097 | case EN_MSGFILTER: | |
2098 | { | |
2099 | const MSGFILTER *msgf = (MSGFILTER *)lParam; | |
2100 | UINT msg = msgf->msg; | |
2101 | ||
2102 | // this is a bit crazy but richedit 1.0 sends us all mouse | |
2103 | // events _except_ WM_LBUTTONUP (don't ask me why) so we have | |
2104 | // generate the wxWin events for this message manually | |
2105 | // | |
2106 | // NB: in fact, this is still not totally correct as it does | |
2107 | // send us WM_LBUTTONUP if the selection was cleared by the | |
2108 | // last click -- so currently we get 2 events in this case, | |
2109 | // but as I don't see any obvious way to check for this I | |
2110 | // leave this code in place because it's still better than | |
2111 | // not getting left up events at all | |
2112 | if ( msg == WM_LBUTTONUP ) | |
2113 | { | |
2114 | WXUINT flags = msgf->wParam; | |
2115 | int x = GET_X_LPARAM(msgf->lParam), | |
2116 | y = GET_Y_LPARAM(msgf->lParam); | |
2117 | ||
2118 | HandleMouseEvent(msg, x, y, flags); | |
2119 | } | |
2120 | } | |
2121 | ||
2122 | // return true to process the event (and false to ignore it) | |
2123 | return true; | |
2124 | ||
2125 | case EN_LINK: | |
2126 | { | |
2127 | const ENLINK *enlink = (ENLINK *)hdr; | |
2128 | ||
2129 | switch ( enlink->msg ) | |
2130 | { | |
2131 | case WM_SETCURSOR: | |
2132 | // ok, so it is hardcoded - do we really nee to | |
2133 | // customize it? | |
2134 | { | |
2135 | wxCursor cur(wxCURSOR_HAND); | |
2136 | ::SetCursor(GetHcursorOf(cur)); | |
2137 | *result = TRUE; | |
2138 | break; | |
2139 | } | |
2140 | ||
2141 | case WM_MOUSEMOVE: | |
2142 | case WM_LBUTTONDOWN: | |
2143 | case WM_LBUTTONUP: | |
2144 | case WM_LBUTTONDBLCLK: | |
2145 | case WM_RBUTTONDOWN: | |
2146 | case WM_RBUTTONUP: | |
2147 | case WM_RBUTTONDBLCLK: | |
2148 | // send a mouse event | |
2149 | { | |
2150 | static const wxEventType eventsMouse[] = | |
2151 | { | |
2152 | wxEVT_MOTION, | |
2153 | wxEVT_LEFT_DOWN, | |
2154 | wxEVT_LEFT_UP, | |
2155 | wxEVT_LEFT_DCLICK, | |
2156 | wxEVT_RIGHT_DOWN, | |
2157 | wxEVT_RIGHT_UP, | |
2158 | wxEVT_RIGHT_DCLICK, | |
2159 | }; | |
2160 | ||
2161 | // the event ids are consecutive | |
2162 | wxMouseEvent | |
2163 | evtMouse(eventsMouse[enlink->msg - WM_MOUSEMOVE]); | |
2164 | ||
2165 | InitMouseEvent(evtMouse, | |
2166 | GET_X_LPARAM(enlink->lParam), | |
2167 | GET_Y_LPARAM(enlink->lParam), | |
2168 | enlink->wParam); | |
2169 | ||
2170 | wxTextUrlEvent event(m_windowId, evtMouse, | |
2171 | enlink->chrg.cpMin, | |
2172 | enlink->chrg.cpMax); | |
2173 | ||
2174 | InitCommandEvent(event); | |
2175 | ||
2176 | *result = ProcessCommand(event); | |
2177 | } | |
2178 | break; | |
2179 | } | |
2180 | } | |
2181 | return true; | |
2182 | } | |
2183 | ||
2184 | // not processed, leave it to the base class | |
2185 | return wxTextCtrlBase::MSWOnNotify(idCtrl, lParam, result); | |
2186 | } | |
2187 | ||
2188 | // ---------------------------------------------------------------------------- | |
2189 | // colour setting for the rich edit controls | |
2190 | // ---------------------------------------------------------------------------- | |
2191 | ||
2192 | bool wxTextCtrl::SetBackgroundColour(const wxColour& colour) | |
2193 | { | |
2194 | if ( !wxTextCtrlBase::SetBackgroundColour(colour) ) | |
2195 | { | |
2196 | // colour didn't really change | |
2197 | return false; | |
2198 | } | |
2199 | ||
2200 | if ( IsRich() ) | |
2201 | { | |
2202 | // rich edit doesn't use WM_CTLCOLOR, hence we need to send | |
2203 | // EM_SETBKGNDCOLOR additionally | |
2204 | ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR, 0, wxColourToRGB(colour)); | |
2205 | } | |
2206 | ||
2207 | return true; | |
2208 | } | |
2209 | ||
2210 | bool wxTextCtrl::SetForegroundColour(const wxColour& colour) | |
2211 | { | |
2212 | if ( !wxTextCtrlBase::SetForegroundColour(colour) ) | |
2213 | { | |
2214 | // colour didn't really change | |
2215 | return false; | |
2216 | } | |
2217 | ||
2218 | if ( IsRich() ) | |
2219 | { | |
2220 | // change the colour of everything | |
2221 | CHARFORMAT cf; | |
2222 | wxZeroMemory(cf); | |
2223 | cf.cbSize = sizeof(cf); | |
2224 | cf.dwMask = CFM_COLOR; | |
2225 | cf.crTextColor = wxColourToRGB(colour); | |
2226 | ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf); | |
2227 | } | |
2228 | ||
2229 | return true; | |
2230 | } | |
2231 | ||
2232 | // ---------------------------------------------------------------------------- | |
2233 | // styling support for rich edit controls | |
2234 | // ---------------------------------------------------------------------------- | |
2235 | ||
2236 | #if wxUSE_RICHEDIT | |
2237 | ||
2238 | bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) | |
2239 | { | |
2240 | if ( !IsRich() ) | |
2241 | { | |
2242 | // can't do it with normal text control | |
2243 | return false; | |
2244 | } | |
2245 | ||
2246 | // the richedit 1.0 doesn't handle setting background colour, so don't | |
2247 | // even try to do anything if it's the only thing we want to change | |
2248 | if ( m_verRichEdit == 1 && !style.HasFont() && !style.HasTextColour() && | |
2249 | !style.HasLeftIndent() && !style.HasRightIndent() && !style.HasAlignment() && | |
2250 | !style.HasTabs() ) | |
2251 | { | |
2252 | // nothing to do: return true if there was really nothing to do and | |
2253 | // false if we failed to set bg colour | |
2254 | return !style.HasBackgroundColour(); | |
2255 | } | |
2256 | ||
2257 | // order the range if needed | |
2258 | if ( start > end ) | |
2259 | { | |
2260 | long tmp = start; | |
2261 | start = end; | |
2262 | end = tmp; | |
2263 | } | |
2264 | ||
2265 | // we can only change the format of the selection, so select the range we | |
2266 | // want and restore the old selection later | |
2267 | long startOld, endOld; | |
2268 | GetSelection(&startOld, &endOld); | |
2269 | ||
2270 | // but do we really have to change the selection? | |
2271 | bool changeSel = start != startOld || end != endOld; | |
2272 | ||
2273 | if ( changeSel ) | |
2274 | { | |
2275 | DoSetSelection(start, end, false /* don't scroll caret into view */); | |
2276 | } | |
2277 | ||
2278 | // initialize CHARFORMAT struct | |
2279 | #if wxUSE_RICHEDIT2 | |
2280 | CHARFORMAT2 cf; | |
2281 | #else | |
2282 | CHARFORMAT cf; | |
2283 | #endif | |
2284 | ||
2285 | wxZeroMemory(cf); | |
2286 | ||
2287 | // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple | |
2288 | // CHARFORMAT in that case | |
2289 | #if wxUSE_RICHEDIT2 | |
2290 | if ( m_verRichEdit == 1 ) | |
2291 | { | |
2292 | // this is the only thing the control is going to grok | |
2293 | cf.cbSize = sizeof(CHARFORMAT); | |
2294 | } | |
2295 | else | |
2296 | #endif | |
2297 | { | |
2298 | // CHARFORMAT or CHARFORMAT2 | |
2299 | cf.cbSize = sizeof(cf); | |
2300 | } | |
2301 | ||
2302 | if ( style.HasFont() ) | |
2303 | { | |
2304 | // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0 | |
2305 | // but using it doesn't seem to hurt neither so leaving it for now | |
2306 | ||
2307 | cf.dwMask |= CFM_FACE | CFM_SIZE | CFM_CHARSET | | |
2308 | CFM_ITALIC | CFM_BOLD | CFM_UNDERLINE; | |
2309 | ||
2310 | // fill in data from LOGFONT but recalculate lfHeight because we need | |
2311 | // the real height in twips and not the negative number which | |
2312 | // wxFillLogFont() returns (this is correct in general and works with | |
2313 | // the Windows font mapper, but not here) | |
2314 | LOGFONT lf; | |
2315 | wxFillLogFont(&lf, &style.GetFont()); | |
2316 | cf.yHeight = 20*style.GetFont().GetPointSize(); // 1 pt = 20 twips | |
2317 | cf.bCharSet = lf.lfCharSet; | |
2318 | cf.bPitchAndFamily = lf.lfPitchAndFamily; | |
2319 | wxStrncpy( cf.szFaceName, lf.lfFaceName, WXSIZEOF(cf.szFaceName) ); | |
2320 | ||
2321 | // also deal with underline/italic/bold attributes: note that we must | |
2322 | // always set CFM_ITALIC &c bits in dwMask, even if we don't set the | |
2323 | // style to allow clearing it | |
2324 | if ( lf.lfItalic ) | |
2325 | { | |
2326 | cf.dwEffects |= CFE_ITALIC; | |
2327 | } | |
2328 | ||
2329 | if ( lf.lfWeight == FW_BOLD ) | |
2330 | { | |
2331 | cf.dwEffects |= CFE_BOLD; | |
2332 | } | |
2333 | ||
2334 | if ( lf.lfUnderline ) | |
2335 | { | |
2336 | cf.dwEffects |= CFE_UNDERLINE; | |
2337 | } | |
2338 | ||
2339 | // strikeout fonts are not supported by wxWidgets | |
2340 | } | |
2341 | ||
2342 | if ( style.HasTextColour() ) | |
2343 | { | |
2344 | cf.dwMask |= CFM_COLOR; | |
2345 | cf.crTextColor = wxColourToRGB(style.GetTextColour()); | |
2346 | } | |
2347 | ||
2348 | #if wxUSE_RICHEDIT2 | |
2349 | if ( m_verRichEdit != 1 && style.HasBackgroundColour() ) | |
2350 | { | |
2351 | cf.dwMask |= CFM_BACKCOLOR; | |
2352 | cf.crBackColor = wxColourToRGB(style.GetBackgroundColour()); | |
2353 | } | |
2354 | #endif // wxUSE_RICHEDIT2 | |
2355 | ||
2356 | // do format the selection | |
2357 | bool ok = ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, | |
2358 | SCF_SELECTION, (LPARAM)&cf) != 0; | |
2359 | if ( !ok ) | |
2360 | { | |
2361 | wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed")); | |
2362 | } | |
2363 | ||
2364 | // now do the paragraph formatting | |
2365 | PARAFORMAT2 pf; | |
2366 | wxZeroMemory(pf); | |
2367 | // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple | |
2368 | // PARAFORMAT in that case | |
2369 | #if wxUSE_RICHEDIT2 | |
2370 | if ( m_verRichEdit == 1 ) | |
2371 | { | |
2372 | // this is the only thing the control is going to grok | |
2373 | pf.cbSize = sizeof(PARAFORMAT); | |
2374 | } | |
2375 | else | |
2376 | #endif | |
2377 | { | |
2378 | // PARAFORMAT or PARAFORMAT2 | |
2379 | pf.cbSize = sizeof(pf); | |
2380 | } | |
2381 | ||
2382 | if (style.HasAlignment()) | |
2383 | { | |
2384 | pf.dwMask |= PFM_ALIGNMENT; | |
2385 | if (style.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT) | |
2386 | pf.wAlignment = PFA_RIGHT; | |
2387 | else if (style.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE) | |
2388 | pf.wAlignment = PFA_CENTER; | |
2389 | else if (style.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED) | |
2390 | pf.wAlignment = PFA_JUSTIFY; | |
2391 | else | |
2392 | pf.wAlignment = PFA_LEFT; | |
2393 | } | |
2394 | ||
2395 | if (style.HasLeftIndent()) | |
2396 | { | |
2397 | pf.dwMask |= PFM_STARTINDENT | PFM_OFFSET; | |
2398 | ||
2399 | // Convert from 1/10 mm to TWIPS | |
2400 | pf.dxStartIndent = (int) (((double) style.GetLeftIndent()) * mm2twips / 10.0) ; | |
2401 | pf.dxOffset = (int) (((double) style.GetLeftSubIndent()) * mm2twips / 10.0) ; | |
2402 | } | |
2403 | ||
2404 | if (style.HasRightIndent()) | |
2405 | { | |
2406 | pf.dwMask |= PFM_RIGHTINDENT; | |
2407 | ||
2408 | // Convert from 1/10 mm to TWIPS | |
2409 | pf.dxRightIndent = (int) (((double) style.GetRightIndent()) * mm2twips / 10.0) ; | |
2410 | } | |
2411 | ||
2412 | if (style.HasTabs()) | |
2413 | { | |
2414 | pf.dwMask |= PFM_TABSTOPS; | |
2415 | ||
2416 | const wxArrayInt& tabs = style.GetTabs(); | |
2417 | ||
2418 | pf.cTabCount = (SHORT)wxMin(tabs.GetCount(), MAX_TAB_STOPS); | |
2419 | size_t i; | |
2420 | for (i = 0; i < (size_t) pf.cTabCount; i++) | |
2421 | { | |
2422 | // Convert from 1/10 mm to TWIPS | |
2423 | pf.rgxTabs[i] = (int) (((double) tabs[i]) * mm2twips / 10.0) ; | |
2424 | } | |
2425 | } | |
2426 | ||
2427 | if (pf.dwMask != 0) | |
2428 | { | |
2429 | // do format the selection | |
2430 | bool ok = ::SendMessage(GetHwnd(), EM_SETPARAFORMAT, | |
2431 | 0, (LPARAM) &pf) != 0; | |
2432 | if ( !ok ) | |
2433 | { | |
2434 | wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed")); | |
2435 | } | |
2436 | } | |
2437 | ||
2438 | if ( changeSel ) | |
2439 | { | |
2440 | // restore the original selection | |
2441 | DoSetSelection(startOld, endOld, false); | |
2442 | } | |
2443 | ||
2444 | return ok; | |
2445 | } | |
2446 | ||
2447 | bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style) | |
2448 | { | |
2449 | if ( !wxTextCtrlBase::SetDefaultStyle(style) ) | |
2450 | return false; | |
2451 | ||
2452 | if ( IsEditable() ) | |
2453 | { | |
2454 | // we have to do this or the style wouldn't apply for the text typed by | |
2455 | // the user | |
2456 | wxTextPos posLast = GetLastPosition(); | |
2457 | SetStyle(posLast, posLast, m_defaultStyle); | |
2458 | } | |
2459 | ||
2460 | return true; | |
2461 | } | |
2462 | ||
2463 | bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) | |
2464 | { | |
2465 | if ( !IsRich() ) | |
2466 | { | |
2467 | // can't do it with normal text control | |
2468 | return false; | |
2469 | } | |
2470 | ||
2471 | // initialize CHARFORMAT struct | |
2472 | #if wxUSE_RICHEDIT2 | |
2473 | CHARFORMAT2 cf; | |
2474 | #else | |
2475 | CHARFORMAT cf; | |
2476 | #endif | |
2477 | ||
2478 | wxZeroMemory(cf); | |
2479 | ||
2480 | // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple | |
2481 | // CHARFORMAT in that case | |
2482 | #if wxUSE_RICHEDIT2 | |
2483 | if ( m_verRichEdit == 1 ) | |
2484 | { | |
2485 | // this is the only thing the control is going to grok | |
2486 | cf.cbSize = sizeof(CHARFORMAT); | |
2487 | } | |
2488 | else | |
2489 | #endif | |
2490 | { | |
2491 | // CHARFORMAT or CHARFORMAT2 | |
2492 | cf.cbSize = sizeof(cf); | |
2493 | } | |
2494 | // we can only change the format of the selection, so select the range we | |
2495 | // want and restore the old selection later | |
2496 | long startOld, endOld; | |
2497 | GetSelection(&startOld, &endOld); | |
2498 | ||
2499 | // but do we really have to change the selection? | |
2500 | bool changeSel = position != startOld || position != endOld; | |
2501 | ||
2502 | if ( changeSel ) | |
2503 | { | |
2504 | DoSetSelection(position, position, false /* don't scroll caret into view */); | |
2505 | } | |
2506 | ||
2507 | // get the selection formatting | |
2508 | (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT, | |
2509 | SCF_SELECTION, (LPARAM)&cf) ; | |
2510 | ||
2511 | ||
2512 | LOGFONT lf; | |
2513 | lf.lfHeight = cf.yHeight; | |
2514 | lf.lfWidth = 0; | |
2515 | lf.lfCharSet = ANSI_CHARSET; // FIXME: how to get correct charset? | |
2516 | lf.lfClipPrecision = 0; | |
2517 | lf.lfEscapement = 0; | |
2518 | wxStrcpy(lf.lfFaceName, cf.szFaceName); | |
2519 | ||
2520 | //NOTE: we _MUST_ set each of these values to _something_ since we | |
2521 | //do not call wxZeroMemory on the LOGFONT lf | |
2522 | if (cf.dwEffects & CFE_ITALIC) | |
2523 | lf.lfItalic = TRUE; | |
2524 | else | |
2525 | lf.lfItalic = FALSE; | |
2526 | ||
2527 | lf.lfOrientation = 0; | |
2528 | lf.lfPitchAndFamily = cf.bPitchAndFamily; | |
2529 | lf.lfQuality = 0; | |
2530 | ||
2531 | if (cf.dwEffects & CFE_STRIKEOUT) | |
2532 | lf.lfStrikeOut = TRUE; | |
2533 | else | |
2534 | lf.lfStrikeOut = FALSE; | |
2535 | ||
2536 | if (cf.dwEffects & CFE_UNDERLINE) | |
2537 | lf.lfUnderline = TRUE; | |
2538 | else | |
2539 | lf.lfUnderline = FALSE; | |
2540 | ||
2541 | if (cf.dwEffects & CFE_BOLD) | |
2542 | lf.lfWeight = FW_BOLD; | |
2543 | else | |
2544 | lf.lfWeight = FW_NORMAL; | |
2545 | ||
2546 | wxFont font = wxCreateFontFromLogFont(& lf); | |
2547 | if (font.Ok()) | |
2548 | { | |
2549 | style.SetFont(font); | |
2550 | } | |
2551 | style.SetTextColour(wxColour(cf.crTextColor)); | |
2552 | ||
2553 | #if wxUSE_RICHEDIT2 | |
2554 | if ( m_verRichEdit != 1 ) | |
2555 | { | |
2556 | // cf.dwMask |= CFM_BACKCOLOR; | |
2557 | style.SetBackgroundColour(wxColour(cf.crBackColor)); | |
2558 | } | |
2559 | #endif // wxUSE_RICHEDIT2 | |
2560 | ||
2561 | // now get the paragraph formatting | |
2562 | PARAFORMAT2 pf; | |
2563 | wxZeroMemory(pf); | |
2564 | // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple | |
2565 | // PARAFORMAT in that case | |
2566 | #if wxUSE_RICHEDIT2 | |
2567 | if ( m_verRichEdit == 1 ) | |
2568 | { | |
2569 | // this is the only thing the control is going to grok | |
2570 | pf.cbSize = sizeof(PARAFORMAT); | |
2571 | } | |
2572 | else | |
2573 | #endif | |
2574 | { | |
2575 | // PARAFORMAT or PARAFORMAT2 | |
2576 | pf.cbSize = sizeof(pf); | |
2577 | } | |
2578 | ||
2579 | // do format the selection | |
2580 | (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT, 0, (LPARAM) &pf) ; | |
2581 | ||
2582 | style.SetLeftIndent( (int) ((double) pf.dxStartIndent * twips2mm * 10.0), (int) ((double) pf.dxOffset * twips2mm * 10.0) ); | |
2583 | style.SetRightIndent( (int) ((double) pf.dxRightIndent * twips2mm * 10.0) ); | |
2584 | ||
2585 | if (pf.wAlignment == PFA_CENTER) | |
2586 | style.SetAlignment(wxTEXT_ALIGNMENT_CENTRE); | |
2587 | else if (pf.wAlignment == PFA_RIGHT) | |
2588 | style.SetAlignment(wxTEXT_ALIGNMENT_RIGHT); | |
2589 | else if (pf.wAlignment == PFA_JUSTIFY) | |
2590 | style.SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED); | |
2591 | else | |
2592 | style.SetAlignment(wxTEXT_ALIGNMENT_LEFT); | |
2593 | ||
2594 | wxArrayInt tabStops; | |
2595 | size_t i; | |
2596 | for (i = 0; i < (size_t) pf.cTabCount; i++) | |
2597 | { | |
2598 | tabStops.Add( (int) ((double) (pf.rgxTabs[i] & 0xFFFF) * twips2mm * 10.0) ); | |
2599 | } | |
2600 | ||
2601 | if ( changeSel ) | |
2602 | { | |
2603 | // restore the original selection | |
2604 | DoSetSelection(startOld, endOld, false); | |
2605 | } | |
2606 | ||
2607 | return true; | |
2608 | } | |
2609 | ||
2610 | #endif | |
2611 | ||
2612 | // ---------------------------------------------------------------------------- | |
2613 | // wxRichEditModule | |
2614 | // ---------------------------------------------------------------------------- | |
2615 | ||
2616 | bool wxRichEditModule::OnInit() | |
2617 | { | |
2618 | // don't do anything - we will load it when needed | |
2619 | return true; | |
2620 | } | |
2621 | ||
2622 | void wxRichEditModule::OnExit() | |
2623 | { | |
2624 | for ( size_t i = 0; i < WXSIZEOF(ms_hRichEdit); i++ ) | |
2625 | { | |
2626 | if ( ms_hRichEdit[i] ) | |
2627 | { | |
2628 | ::FreeLibrary(ms_hRichEdit[i]); | |
2629 | ms_hRichEdit[i] = NULL; | |
2630 | } | |
2631 | } | |
2632 | } | |
2633 | ||
2634 | /* static */ | |
2635 | bool wxRichEditModule::Load(int version) | |
2636 | { | |
2637 | // we don't support loading richedit 3.0 as I don't know how to distinguish | |
2638 | // it from 2.0 anyhow | |
2639 | wxCHECK_MSG( version == 1 || version == 2, false, | |
2640 | _T("incorrect richedit control version requested") ); | |
2641 | ||
2642 | // make it the index in the array | |
2643 | version--; | |
2644 | ||
2645 | if ( ms_hRichEdit[version] == (HINSTANCE)-1 ) | |
2646 | { | |
2647 | // we had already tried to load it and failed | |
2648 | return false; | |
2649 | } | |
2650 | ||
2651 | if ( ms_hRichEdit[version] ) | |
2652 | { | |
2653 | // we've already got this one | |
2654 | return true; | |
2655 | } | |
2656 | ||
2657 | wxString dllname = version ? _T("riched20") : _T("riched32"); | |
2658 | dllname += _T(".dll"); | |
2659 | ||
2660 | ms_hRichEdit[version] = ::LoadLibrary(dllname); | |
2661 | ||
2662 | if ( !ms_hRichEdit[version] ) | |
2663 | { | |
2664 | wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str()); | |
2665 | ||
2666 | ms_hRichEdit[version] = (HINSTANCE)-1; | |
2667 | ||
2668 | return false; | |
2669 | } | |
2670 | ||
2671 | return true; | |
2672 | } | |
2673 | ||
2674 | #endif // wxUSE_RICHEDIT | |
2675 | ||
2676 | #endif // wxUSE_TEXTCTRL && !(__SMARTPHONE__ && __WXWINCE__) |