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