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