]> git.saurik.com Git - wxWidgets.git/blob - src/msw/textctrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Some doc tweaks
[wxWidgets.git] / src / msw / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 #ifdef __GNUG__
17 #pragma implementation "textctrl.h"
18 #endif
19
20 // ----------------------------------------------------------------------------
21 // headers
22 // ----------------------------------------------------------------------------
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #if wxUSE_TEXTCTRL
32
33 #ifndef WX_PRECOMP
34 #include "wx/textctrl.h"
35 #include "wx/settings.h"
36 #include "wx/brush.h"
37 #include "wx/utils.h"
38 #include "wx/intl.h"
39 #include "wx/log.h"
40 #include "wx/app.h"
41 #endif
42
43 #include "wx/module.h"
44
45 #if wxUSE_CLIPBOARD
46 #include "wx/clipbrd.h"
47 #endif
48
49 #include "wx/textfile.h"
50
51 #include <windowsx.h>
52
53 #include "wx/msw/private.h"
54
55 #include <string.h>
56 #include <stdlib.h>
57 #include <sys/types.h>
58
59 #if wxUSE_RICHEDIT && (!defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__))
60 #include <richedit.h>
61 #endif
62
63 // old mingw32 doesn't define this
64 #ifndef CFM_CHARSET
65 #define CFM_CHARSET 0x08000000
66 #endif // CFM_CHARSET
67
68 #ifndef CFM_BACKCOLOR
69 #define CFM_BACKCOLOR 0x04000000
70 #endif
71
72 // cygwin does not have these defined for richedit
73 #ifndef ENM_LINK
74 #define ENM_LINK 0x04000000
75 #endif
76
77 #ifndef EM_AUTOURLDETECT
78 #define EM_AUTOURLDETECT (WM_USER + 91)
79 #endif
80
81 #ifndef EN_LINK
82 #define EN_LINK 0x070b
83
84 typedef struct _enlink
85 {
86 NMHDR nmhdr;
87 UINT msg;
88 WPARAM wParam;
89 LPARAM lParam;
90 CHARRANGE chrg;
91 } ENLINK;
92 #endif // ENLINK
93
94 #ifndef SF_UNICODE
95 #define SF_UNICODE 0x0010
96 #endif
97
98 // Watcom C++ doesn't define this
99 #ifndef SCF_ALL
100 #define SCF_ALL 0x0004
101 #endif
102
103 // ----------------------------------------------------------------------------
104 // private functions
105 // ----------------------------------------------------------------------------
106
107 #if wxUSE_RICHEDIT
108
109 DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb);
110
111 #endif // wxUSE_RICHEDIT
112
113 // ----------------------------------------------------------------------------
114 // private classes
115 // ----------------------------------------------------------------------------
116
117 #if wxUSE_RICHEDIT
118
119 // this module initializes RichEdit DLL(s) if needed
120 class wxRichEditModule : public wxModule
121 {
122 public:
123 virtual bool OnInit();
124 virtual void OnExit();
125
126 // load the richedit DLL of at least of required version
127 static bool Load(int version = 1);
128
129 private:
130 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
131 static HINSTANCE ms_hRichEdit[2];
132
133 DECLARE_DYNAMIC_CLASS(wxRichEditModule)
134 };
135
136 HINSTANCE wxRichEditModule::ms_hRichEdit[2] = { NULL, NULL };
137
138 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule)
139
140 #endif // wxUSE_RICHEDIT
141
142 // ----------------------------------------------------------------------------
143 // event tables and other macros
144 // ----------------------------------------------------------------------------
145
146 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
147
148 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
149 EVT_CHAR(wxTextCtrl::OnChar)
150 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
151
152 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
153 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
154 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
155 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
156 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
157
158 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
159 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
160 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
161 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
162 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
163 #ifdef __WIN16__
164 EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
165 #endif
166 END_EVENT_TABLE()
167
168 // ============================================================================
169 // implementation
170 // ============================================================================
171
172 // ----------------------------------------------------------------------------
173 // creation
174 // ----------------------------------------------------------------------------
175
176 void wxTextCtrl::Init()
177 {
178 #if wxUSE_RICHEDIT
179 m_verRichEdit = 0;
180 #endif
181 }
182
183 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
184 const wxString& value,
185 const wxPoint& pos,
186 const wxSize& size,
187 long style,
188 const wxValidator& validator,
189 const wxString& name)
190 {
191 // base initialization
192 if ( !CreateBase(parent, id, pos, size, style, validator, name) )
193 return FALSE;
194
195 if ( parent )
196 parent->AddChild(this);
197
198 // translate wxWin style flags to MSW ones, checking for consistency while
199 // doing it
200 long msStyle = ES_LEFT | WS_TABSTOP;
201
202 if ( m_windowStyle & wxCLIP_SIBLINGS )
203 msStyle |= WS_CLIPSIBLINGS;
204
205 if ( m_windowStyle & wxTE_MULTILINE )
206 {
207 wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
208 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
209
210 msStyle |= ES_MULTILINE | ES_WANTRETURN;
211 if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
212 msStyle |= WS_VSCROLL;
213 m_windowStyle |= wxTE_PROCESS_ENTER;
214 }
215 else // !multiline
216 {
217 // there is really no reason to not have this style for single line
218 // text controls
219 msStyle |= ES_AUTOHSCROLL;
220 }
221
222 if ( m_windowStyle & wxHSCROLL )
223 msStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
224
225 if ( m_windowStyle & wxTE_READONLY )
226 msStyle |= ES_READONLY;
227
228 if ( m_windowStyle & wxTE_PASSWORD )
229 msStyle |= ES_PASSWORD;
230
231 if ( m_windowStyle & wxTE_AUTO_SCROLL )
232 msStyle |= ES_AUTOHSCROLL;
233
234 if ( m_windowStyle & wxTE_NOHIDESEL )
235 msStyle |= ES_NOHIDESEL;
236
237 // we always want the characters and the arrows
238 m_lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
239
240 // we may have several different cases:
241 // 1. normal case: both TAB and ENTER are used for dialog navigation
242 // 2. ctrl which wants TAB for itself: ENTER is used to pass to the next
243 // control in the dialog
244 // 3. ctrl which wants ENTER for itself: TAB is used for dialog navigation
245 // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to pass to
246 // the next control
247 if ( m_windowStyle & wxTE_PROCESS_ENTER )
248 m_lDlgCode |= DLGC_WANTMESSAGE;
249 if ( m_windowStyle & wxTE_PROCESS_TAB )
250 m_lDlgCode |= DLGC_WANTTAB;
251
252 // do create the control - either an EDIT or RICHEDIT
253 wxString windowClass = wxT("EDIT");
254
255 #if wxUSE_RICHEDIT
256 if ( m_windowStyle & wxTE_AUTO_URL )
257 {
258 // automatic URL detection only works in RichEdit 2.0+
259 m_windowStyle |= wxTE_RICH2;
260 }
261
262 if ( m_windowStyle & wxTE_RICH2 )
263 {
264 // using richedit 2.0 implies using wxTE_RICH
265 m_windowStyle |= wxTE_RICH;
266 }
267
268 // we need to load the richedit DLL before creating the rich edit control
269 if ( m_windowStyle & wxTE_RICH )
270 {
271 static bool s_errorGiven = FALSE;// MT-FIXME
272
273 // Which version do we need? Use 1.0 by default because it is much more
274 // like the the standard EDIT or 2.0 if explicitly requested, but use
275 // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
276 //
277 // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
278 // (and thus EDIT) much better than RichEdit 2.0 so we probably
279 // should use 3.0 if available as it is the best of both worlds -
280 // but as I can't test it right now I don't do it (VZ)
281 #if wxUSE_UNICODE
282 const int verRichEdit = 2;
283 #else // !wxUSE_UNICODE
284 int verRichEdit = m_windowStyle & wxTE_RICH2 ? 2 : 1;
285 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
286
287 // only give the error msg once if the DLL can't be loaded
288 if ( !s_errorGiven )
289 {
290 // try to load the RichEdit DLL (will do nothing if already done)
291 if ( !wxRichEditModule::Load(verRichEdit) )
292 {
293 #if !wxUSE_UNICODE
294 // try another version?
295 verRichEdit = 3 - verRichEdit; // 1 <-> 2
296
297 if ( !wxRichEditModule::Load(verRichEdit) )
298 #endif // wxUSE_UNICODE
299 {
300 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
301
302 s_errorGiven = TRUE;
303 }
304 }
305 }
306
307 // have we managed to load any richedit version?
308 if ( !s_errorGiven )
309 {
310 msStyle |= ES_AUTOVSCROLL;
311
312 m_verRichEdit = verRichEdit;
313 if ( m_verRichEdit == 1 )
314 {
315 windowClass = wxT("RICHEDIT");
316 }
317 else
318 {
319 #ifndef RICHEDIT_CLASS
320 wxString RICHEDIT_CLASS;
321 RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), m_verRichEdit);
322 #if wxUSE_UNICODE
323 RICHEDIT_CLASS += _T('W');
324 #else // ANSI
325 RICHEDIT_CLASS += _T('A');
326 #endif // Unicode/ANSI
327 #endif // !RICHEDIT_CLASS
328
329 windowClass = RICHEDIT_CLASS;
330 }
331 }
332 }
333 #endif // wxUSE_RICHEDIT
334
335 // we need to turn '\n's into "\r\n"s for the multiline controls
336 wxString valueWin;
337 if ( m_windowStyle & wxTE_MULTILINE )
338 {
339 valueWin = wxTextFile::Translate(value, wxTextFileType_Dos);
340 }
341 else // single line
342 {
343 valueWin = value;
344 }
345
346 if ( !MSWCreateControl(windowClass, msStyle, pos, size, valueWin) )
347 return FALSE;
348
349 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
350
351 #if wxUSE_RICHEDIT
352 if ( IsRich() )
353 {
354 // have to enable events manually
355 LPARAM mask = ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE;
356
357 if ( m_windowStyle & wxTE_AUTO_URL )
358 {
359 mask |= ENM_LINK;
360
361 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT, TRUE, 0);
362 }
363
364 ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0, mask);
365 }
366 #endif // wxUSE_RICHEDIT
367
368 return TRUE;
369 }
370
371 // Make sure the window style (etc.) reflects the HWND style (roughly)
372 void wxTextCtrl::AdoptAttributesFromHWND()
373 {
374 wxWindow::AdoptAttributesFromHWND();
375
376 HWND hWnd = GetHwnd();
377 long style = ::GetWindowLong(hWnd, GWL_STYLE);
378
379 // retrieve the style to see whether this is an edit or richedit ctrl
380 #if wxUSE_RICHEDIT
381 wxString classname = wxGetWindowClass(GetHWND());
382
383 if ( classname.IsSameAs(_T("EDIT"), FALSE /* no case */) )
384 {
385 m_verRichEdit = 0;
386 }
387 else // rich edit?
388 {
389 wxChar c;
390 if ( wxSscanf(classname, _T("RichEdit%d0%c"), &m_verRichEdit, &c) != 2 )
391 {
392 wxLogDebug(_T("Unknown edit control '%s'."), classname.c_str());
393
394 m_verRichEdit = 0;
395 }
396 }
397 #endif // wxUSE_RICHEDIT
398
399 if (style & ES_MULTILINE)
400 m_windowStyle |= wxTE_MULTILINE;
401 if (style & ES_PASSWORD)
402 m_windowStyle |= wxTE_PASSWORD;
403 if (style & ES_READONLY)
404 m_windowStyle |= wxTE_READONLY;
405 if (style & ES_WANTRETURN)
406 m_windowStyle |= wxTE_PROCESS_ENTER;
407 }
408
409 // ----------------------------------------------------------------------------
410 // set/get the controls text
411 // ----------------------------------------------------------------------------
412
413 wxString wxTextCtrl::GetValue() const
414 {
415 // range 0..-1 is special for GetRange() and means to retrieve all text
416 return GetRange(0, -1);
417 }
418
419 wxString wxTextCtrl::GetRange(long from, long to) const
420 {
421 wxString str;
422
423 if ( from >= to && to != -1 )
424 {
425 // nothing to retrieve
426 return str;
427 }
428
429 #if wxUSE_RICHEDIT
430 if ( IsRich() )
431 {
432 int len = GetWindowTextLength(GetHwnd());
433 if ( len > from )
434 {
435 // alloc one extra WORD as needed by the control
436 wxChar *p = str.GetWriteBuf(++len);
437
438 TEXTRANGE textRange;
439 textRange.chrg.cpMin = from;
440 textRange.chrg.cpMax = to == -1 ? len : to;
441 textRange.lpstrText = p;
442
443 (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE, 0, (LPARAM)&textRange);
444
445 if ( m_verRichEdit > 1 )
446 {
447 // RichEdit 2.0 uses just CR ('\r') for the newlines which is
448 // neither Unix nor Windows style - convert it to something
449 // reasonable
450 for ( ; *p; p++ )
451 {
452 if ( *p == _T('\r') )
453 *p = _T('\n');
454 }
455 }
456
457 str.UngetWriteBuf();
458
459 if ( m_verRichEdit == 1 )
460 {
461 // convert to the canonical form - see comment below
462 str = wxTextFile::Translate(str, wxTextFileType_Unix);
463 }
464 }
465 //else: no text at all, leave the string empty
466 }
467 else
468 #endif // wxUSE_RICHEDIT
469 {
470 // retrieve all text
471 str = wxGetWindowText(GetHWND());
472
473 // need only a range?
474 if ( from < to )
475 {
476 str = str.Mid(from, to - from);
477 }
478
479 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
480 // canonical one (same one as above) for consistency with the other kinds
481 // of controls and, more importantly, with the other ports
482 str = wxTextFile::Translate(str, wxTextFileType_Unix);
483 }
484
485 return str;
486 }
487
488 void wxTextCtrl::SetValue(const wxString& value)
489 {
490 // if the text is long enough, it's faster to just set it instead of first
491 // comparing it with the old one (chances are that it will be different
492 // anyhow, this comparison is there to avoid flicker for small single-line
493 // edit controls mostly)
494 if ( (value.length() > 0x400) || (value != GetValue()) )
495 {
496 DoWriteText(value, FALSE /* not selection only */);
497
498 // mark the control as being not dirty - we changed its text, not the
499 // user
500 DiscardEdits();
501
502 // for compatibility, don't move the cursor when doing SetValue()
503 SetInsertionPoint(0);
504 }
505 }
506
507 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
508
509 DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb)
510 {
511 *pcb = 0;
512
513 wchar_t *wbuf = (wchar_t *)buf;
514 const wchar_t *wpc = *(const wchar_t **)dwCookie;
515 while ( cb && *wpc )
516 {
517 *wbuf++ = *wpc++;
518
519 cb -= sizeof(wchar_t);
520 (*pcb) += sizeof(wchar_t);
521 }
522
523 *(const wchar_t **)dwCookie = wpc;
524
525 return 0;
526 }
527
528 extern long wxEncodingToCodepage(wxFontEncoding encoding); // from strconv.cpp
529
530 #if wxUSE_UNICODE_MSLU
531 bool wxTextCtrl::StreamIn(const wxString& value,
532 wxFontEncoding WXUNUSED(encoding),
533 bool selectionOnly)
534 {
535 const wchar_t *wpc = value.c_str();
536 #else // !wxUSE_UNICODE_MSLU
537 bool wxTextCtrl::StreamIn(const wxString& value,
538 wxFontEncoding encoding,
539 bool selectionOnly)
540 {
541 // we have to use EM_STREAMIN to force richedit control 2.0+ to show any
542 // text in the non default charset - otherwise it thinks it knows better
543 // than we do and always shows it in the default one
544
545 // first get the Windows code page for this encoding
546 long codepage = wxEncodingToCodepage(encoding);
547 if ( codepage == -1 )
548 {
549 // unknown encoding
550 return FALSE;
551 }
552
553 // next translate to Unicode using this code page
554 int len = ::MultiByteToWideChar(codepage, 0, value, -1, NULL, 0);
555
556 #if wxUSE_WCHAR_T
557 wxWCharBuffer wchBuf(len);
558 #else
559 wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t));
560 #endif
561
562 if ( !::MultiByteToWideChar(codepage, 0, value, -1,
563 (wchar_t *)(const wchar_t *)wchBuf, len) )
564 {
565 wxLogLastError(_T("MultiByteToWideChar"));
566 }
567
568 // finally, stream it in the control
569 const wchar_t *wpc = wchBuf;
570 #endif // wxUSE_UNICODE_MSLU
571
572 EDITSTREAM eds;
573 wxZeroMemory(eds);
574 eds.dwCookie = (DWORD)&wpc;
575 // the cast below is needed for broken (very) old mingw32 headers
576 eds.pfnCallback = (EDITSTREAMCALLBACK)wxRichEditStreamIn;
577
578 if ( !::SendMessage(GetHwnd(), EM_STREAMIN,
579 SF_TEXT |
580 SF_UNICODE |
581 (selectionOnly ? SFF_SELECTION : 0),
582 (LPARAM)&eds) || eds.dwError )
583 {
584 wxLogLastError(_T("EM_STREAMIN"));
585 }
586
587 #if !wxUSE_WCHAR_T
588 free(wchBuf);
589 #endif // !wxUSE_WCHAR_T
590
591 return TRUE;
592 }
593
594 #endif // wxUSE_RICHEDIT
595
596 void wxTextCtrl::WriteText(const wxString& value)
597 {
598 DoWriteText(value);
599 }
600
601 void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly)
602 {
603 wxString valueDos;
604 if ( m_windowStyle & wxTE_MULTILINE )
605 valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
606 else
607 valueDos = value;
608
609 #if wxUSE_RICHEDIT
610 // there are several complications with the rich edit controls here
611 bool done = FALSE;
612 if ( IsRich() )
613 {
614 // first, ensure that the new text will be in the default style
615 if ( !m_defaultStyle.IsDefault() )
616 {
617 long start, end;
618 GetSelection(&start, &end);
619 SetStyle(start, end, m_defaultStyle);
620 }
621
622 #if wxUSE_UNICODE_MSLU
623 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
624 // but EM_STREAMIN works
625 if ( wxGetOsVersion() == wxWIN95 && GetRichVersion() > 1 )
626 {
627 done = StreamIn(valueDos, wxFONTENCODING_SYSTEM, selectionOnly);
628 }
629 #endif // wxUSE_UNICODE_MSLU
630
631 #if !wxUSE_UNICODE
632 // next check if the text we're inserting must be shown in a non
633 // default charset -- this only works for RichEdit > 1.0
634 if ( GetRichVersion() > 1 )
635 {
636 wxFont font = m_defaultStyle.GetFont();
637 if ( !font.Ok() )
638 font = GetFont();
639
640 if ( font.Ok() )
641 {
642 wxFontEncoding encoding = font.GetEncoding();
643 if ( encoding != wxFONTENCODING_SYSTEM )
644 {
645 done = StreamIn(valueDos, encoding, selectionOnly);
646 }
647 }
648 }
649 #endif // !wxUSE_UNICODE
650 }
651
652 if ( !done )
653 #endif // wxUSE_RICHEDIT
654 {
655 if ( !selectionOnly )
656 {
657 SetSelection(-1, -1);
658 }
659
660 ::SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
661 }
662
663 AdjustSpaceLimit();
664 }
665
666 void wxTextCtrl::AppendText(const wxString& text)
667 {
668 SetInsertionPointEnd();
669
670 WriteText(text);
671 }
672
673 void wxTextCtrl::Clear()
674 {
675 ::SetWindowText(GetHwnd(), wxT(""));
676 }
677
678 // ----------------------------------------------------------------------------
679 // Clipboard operations
680 // ----------------------------------------------------------------------------
681
682 void wxTextCtrl::Copy()
683 {
684 if (CanCopy())
685 {
686 ::SendMessage(GetHwnd(), WM_COPY, 0, 0L);
687 }
688 }
689
690 void wxTextCtrl::Cut()
691 {
692 if (CanCut())
693 {
694 ::SendMessage(GetHwnd(), WM_CUT, 0, 0L);
695 }
696 }
697
698 void wxTextCtrl::Paste()
699 {
700 if (CanPaste())
701 {
702 ::SendMessage(GetHwnd(), WM_PASTE, 0, 0L);
703 }
704 }
705
706 bool wxTextCtrl::CanCopy() const
707 {
708 // Can copy if there's a selection
709 long from, to;
710 GetSelection(&from, &to);
711 return from != to;
712 }
713
714 bool wxTextCtrl::CanCut() const
715 {
716 return CanCopy() && IsEditable();
717 }
718
719 bool wxTextCtrl::CanPaste() const
720 {
721 if ( !IsEditable() )
722 return FALSE;
723
724 #if wxUSE_RICHEDIT
725 if ( IsRich() )
726 {
727 UINT cf = 0; // 0 == any format
728
729 return ::SendMessage(GetHwnd(), EM_CANPASTE, cf, 0) != 0;
730 }
731 #endif // wxUSE_RICHEDIT
732
733 // Standard edit control: check for straight text on clipboard
734 if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
735 return FALSE;
736
737 bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0;
738 ::CloseClipboard();
739
740 return isTextAvailable;
741 }
742
743 // ----------------------------------------------------------------------------
744 // Accessors
745 // ----------------------------------------------------------------------------
746
747 void wxTextCtrl::SetEditable(bool editable)
748 {
749 HWND hWnd = GetHwnd();
750 SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
751 }
752
753 void wxTextCtrl::SetInsertionPoint(long pos)
754 {
755 DoSetSelection(pos, pos);
756 }
757
758 void wxTextCtrl::SetInsertionPointEnd()
759 {
760 long pos;
761
762 #if wxUSE_RICHEDIT
763 if ( m_verRichEdit == 1 )
764 {
765 // we don't have to waste time calling GetLastPosition() in this case
766 pos = -1;
767 }
768 else // !RichEdit 1.0
769 #endif // wxUSE_RICHEDIT
770 {
771 pos = GetLastPosition();
772 }
773
774 SetInsertionPoint(pos);
775 }
776
777 long wxTextCtrl::GetInsertionPoint() const
778 {
779 #if wxUSE_RICHEDIT
780 if ( IsRich() )
781 {
782 CHARRANGE range;
783 range.cpMin = 0;
784 range.cpMax = 0;
785 SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range);
786 return range.cpMin;
787 }
788 #endif // wxUSE_RICHEDIT
789
790 DWORD Pos = (DWORD)SendMessage(GetHwnd(), EM_GETSEL, 0, 0L);
791 return Pos & 0xFFFF;
792 }
793
794 long wxTextCtrl::GetLastPosition() const
795 {
796 int numLines = GetNumberOfLines();
797 long posStartLastLine = XYToPosition(0, numLines - 1);
798
799 long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine);
800
801 return posStartLastLine + lenLastLine;
802 }
803
804 // If the return values from and to are the same, there is no
805 // selection.
806 void wxTextCtrl::GetSelection(long* from, long* to) const
807 {
808 #if wxUSE_RICHEDIT
809 if ( IsRich() )
810 {
811 CHARRANGE charRange;
812 ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &charRange);
813
814 *from = charRange.cpMin;
815 *to = charRange.cpMax;
816 }
817 else
818 #endif // !wxUSE_RICHEDIT
819 {
820 DWORD dwStart, dwEnd;
821 ::SendMessage(GetHwnd(), EM_GETSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd);
822
823 *from = dwStart;
824 *to = dwEnd;
825 }
826 }
827
828 bool wxTextCtrl::IsEditable() const
829 {
830 long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
831
832 return (style & ES_READONLY) == 0;
833 }
834
835 // ----------------------------------------------------------------------------
836 // selection
837 // ----------------------------------------------------------------------------
838
839 void wxTextCtrl::SetSelection(long from, long to)
840 {
841 // if from and to are both -1, it means (in wxWindows) that all text should
842 // be selected - translate into Windows convention
843 if ( (from == -1) && (to == -1) )
844 {
845 from = 0;
846 to = -1;
847 }
848
849 DoSetSelection(from, to);
850 }
851
852 void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret)
853 {
854 HWND hWnd = GetHwnd();
855
856 #ifdef __WIN32__
857 #if wxUSE_RICHEDIT
858 if ( IsRich() )
859 {
860 CHARRANGE range;
861 range.cpMin = from;
862 range.cpMax = to;
863 SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range);
864 }
865 else
866 #endif // wxUSE_RICHEDIT
867 {
868 SendMessage(hWnd, EM_SETSEL, (WPARAM)from, (LPARAM)to);
869 }
870
871 if ( scrollCaret )
872 {
873 SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
874 }
875 #else // Win16
876 // WPARAM is 0: selection is scrolled into view
877 SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(from, to));
878 #endif // Win32/16
879 }
880
881 // ----------------------------------------------------------------------------
882 // Editing
883 // ----------------------------------------------------------------------------
884
885 void wxTextCtrl::Replace(long from, long to, const wxString& value)
886 {
887 // Set selection and remove it
888 DoSetSelection(from, to, FALSE /* don't scroll caret into view */);
889
890 SendMessage(GetHwnd(), EM_REPLACESEL,
891 #ifdef __WIN32__
892 TRUE,
893 #else
894 FALSE,
895 #endif
896 (LPARAM)value.c_str());
897 }
898
899 void wxTextCtrl::Remove(long from, long to)
900 {
901 Replace(from, to, _T(""));
902 }
903
904 bool wxTextCtrl::LoadFile(const wxString& file)
905 {
906 if ( wxTextCtrlBase::LoadFile(file) )
907 {
908 // update the size limit if needed
909 AdjustSpaceLimit();
910
911 return TRUE;
912 }
913
914 return FALSE;
915 }
916
917 bool wxTextCtrl::IsModified() const
918 {
919 return SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0;
920 }
921
922 // Makes 'unmodified'
923 void wxTextCtrl::DiscardEdits()
924 {
925 SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0L);
926 }
927
928 int wxTextCtrl::GetNumberOfLines() const
929 {
930 return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0);
931 }
932
933 long wxTextCtrl::XYToPosition(long x, long y) const
934 {
935 // This gets the char index for the _beginning_ of this line
936 long charIndex = SendMessage(GetHwnd(), EM_LINEINDEX, (WPARAM)y, (LPARAM)0);
937
938 return charIndex + x;
939 }
940
941 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
942 {
943 HWND hWnd = GetHwnd();
944
945 // This gets the line number containing the character
946 long lineNo;
947 #if wxUSE_RICHEDIT
948 if ( IsRich() )
949 {
950 lineNo = SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos);
951 }
952 else
953 #endif // wxUSE_RICHEDIT
954 {
955 lineNo = SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0);
956 }
957
958 if ( lineNo == -1 )
959 {
960 // no such line
961 return FALSE;
962 }
963
964 // This gets the char index for the _beginning_ of this line
965 long charIndex = SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0);
966 if ( charIndex == -1 )
967 {
968 return FALSE;
969 }
970
971 // The X position must therefore be the different between pos and charIndex
972 if ( x )
973 *x = pos - charIndex;
974 if ( y )
975 *y = lineNo;
976
977 return TRUE;
978 }
979
980 void wxTextCtrl::ShowPosition(long pos)
981 {
982 HWND hWnd = GetHwnd();
983
984 // To scroll to a position, we pass the number of lines and characters
985 // to scroll *by*. This means that we need to:
986 // (1) Find the line position of the current line.
987 // (2) Find the line position of pos.
988 // (3) Scroll by (pos - current).
989 // For now, ignore the horizontal scrolling.
990
991 // Is this where scrolling is relative to - the line containing the caret?
992 // Or is the first visible line??? Try first visible line.
993 // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
994
995 int currentLineLineNo = (int)SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L);
996
997 int specifiedLineLineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L);
998
999 int linesToScroll = specifiedLineLineNo - currentLineLineNo;
1000
1001 if (linesToScroll != 0)
1002 (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll);
1003 }
1004
1005 long wxTextCtrl::GetLengthOfLineContainingPos(long pos) const
1006 {
1007 return ::SendMessage(GetHwnd(), EM_LINELENGTH, (WPARAM)pos, 0);
1008 }
1009
1010 int wxTextCtrl::GetLineLength(long lineNo) const
1011 {
1012 long pos = XYToPosition(0, lineNo);
1013
1014 return GetLengthOfLineContainingPos(pos);
1015 }
1016
1017 wxString wxTextCtrl::GetLineText(long lineNo) const
1018 {
1019 size_t len = (size_t)GetLineLength(lineNo) + 1;
1020
1021 // there must be at least enough place for the length WORD in the
1022 // buffer
1023 len += sizeof(WORD);
1024
1025 wxString str;
1026 wxChar *buf = str.GetWriteBuf(len);
1027
1028 *(WORD *)buf = (WORD)len;
1029 len = (size_t)::SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
1030 buf[len] = 0;
1031
1032 str.UngetWriteBuf(len);
1033
1034 return str;
1035 }
1036
1037 void wxTextCtrl::SetMaxLength(unsigned long len)
1038 {
1039 ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0);
1040 }
1041
1042 // ----------------------------------------------------------------------------
1043 // Undo/redo
1044 // ----------------------------------------------------------------------------
1045
1046 void wxTextCtrl::Undo()
1047 {
1048 if (CanUndo())
1049 {
1050 ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
1051 }
1052 }
1053
1054 void wxTextCtrl::Redo()
1055 {
1056 if (CanRedo())
1057 {
1058 // Same as Undo, since Undo undoes the undo, i.e. a redo.
1059 ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
1060 }
1061 }
1062
1063 bool wxTextCtrl::CanUndo() const
1064 {
1065 return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0;
1066 }
1067
1068 bool wxTextCtrl::CanRedo() const
1069 {
1070 return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0;
1071 }
1072
1073 // ----------------------------------------------------------------------------
1074 // implemenation details
1075 // ----------------------------------------------------------------------------
1076
1077 void wxTextCtrl::Command(wxCommandEvent & event)
1078 {
1079 SetValue(event.GetString());
1080 ProcessCommand (event);
1081 }
1082
1083 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1084 {
1085 // By default, load the first file into the text window.
1086 if (event.GetNumberOfFiles() > 0)
1087 {
1088 LoadFile(event.GetFiles()[0]);
1089 }
1090 }
1091
1092 // ----------------------------------------------------------------------------
1093 // kbd input processing
1094 // ----------------------------------------------------------------------------
1095
1096 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg)
1097 {
1098 MSG *msg = (MSG *)pMsg;
1099
1100 // check for our special keys here: if we don't do it and the parent frame
1101 // uses them as accelerators, they wouldn't work at all, so we disable
1102 // usual preprocessing for them
1103 if ( msg->message == WM_KEYDOWN )
1104 {
1105 WORD vkey = msg->wParam;
1106 if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN )
1107 {
1108 if ( vkey == VK_BACK )
1109 return FALSE;
1110 }
1111 else // no Alt
1112 {
1113 if ( wxIsCtrlDown() )
1114 {
1115 switch ( vkey )
1116 {
1117 case 'C':
1118 case 'V':
1119 case 'X':
1120 case VK_INSERT:
1121 case VK_DELETE:
1122 case VK_HOME:
1123 case VK_END:
1124 return FALSE;
1125 }
1126 }
1127 else if ( wxIsShiftDown() )
1128 {
1129 if ( vkey == VK_INSERT || vkey == VK_DELETE )
1130 return FALSE;
1131 }
1132 }
1133 }
1134
1135 return wxControl::MSWShouldPreProcessMessage(pMsg);
1136 }
1137
1138 void wxTextCtrl::OnChar(wxKeyEvent& event)
1139 {
1140 switch ( event.KeyCode() )
1141 {
1142 case WXK_RETURN:
1143 if ( !(m_windowStyle & wxTE_MULTILINE) )
1144 {
1145 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1146 InitCommandEvent(event);
1147 event.SetString(GetValue());
1148 if ( GetEventHandler()->ProcessEvent(event) )
1149 return;
1150 }
1151 //else: multiline controls need Enter for themselves
1152
1153 break;
1154
1155 case WXK_TAB:
1156 // always produce navigation event - even if we process TAB
1157 // ourselves the fact that we got here means that the user code
1158 // decided to skip processing of this TAB - probably to let it
1159 // do its default job.
1160 {
1161 wxNavigationKeyEvent eventNav;
1162 eventNav.SetDirection(!event.ShiftDown());
1163 eventNav.SetWindowChange(event.ControlDown());
1164 eventNav.SetEventObject(this);
1165
1166 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1167 return;
1168 }
1169 break;
1170 }
1171
1172 // no, we didn't process it
1173 event.Skip();
1174 }
1175
1176 bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
1177 {
1178 switch (param)
1179 {
1180 case EN_SETFOCUS:
1181 case EN_KILLFOCUS:
1182 {
1183 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
1184 : wxEVT_SET_FOCUS,
1185 m_windowId);
1186 event.SetEventObject( this );
1187 GetEventHandler()->ProcessEvent(event);
1188 }
1189 break;
1190
1191 case EN_CHANGE:
1192 {
1193 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1194 InitCommandEvent(event);
1195 event.SetString(GetValue());
1196 ProcessCommand(event);
1197 }
1198 break;
1199
1200 case EN_MAXTEXT:
1201 // the text size limit has been hit - increase it
1202 if ( !AdjustSpaceLimit() )
1203 {
1204 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId);
1205 InitCommandEvent(event);
1206 event.SetString(GetValue());
1207 ProcessCommand(event);
1208 }
1209 break;
1210
1211 // the other notification messages are not processed
1212 case EN_UPDATE:
1213 case EN_ERRSPACE:
1214 case EN_HSCROLL:
1215 case EN_VSCROLL:
1216 return FALSE;
1217 default:
1218 return FALSE;
1219 }
1220
1221 // processed
1222 return TRUE;
1223 }
1224
1225 WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSED(nCtlColor),
1226 #if wxUSE_CTL3D
1227 WXUINT message,
1228 WXWPARAM wParam,
1229 WXLPARAM lParam
1230 #else
1231 WXUINT WXUNUSED(message),
1232 WXWPARAM WXUNUSED(wParam),
1233 WXLPARAM WXUNUSED(lParam)
1234 #endif
1235 )
1236 {
1237 #if wxUSE_CTL3D
1238 if ( m_useCtl3D )
1239 {
1240 HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
1241 return (WXHBRUSH) hbrush;
1242 }
1243 #endif // wxUSE_CTL3D
1244
1245 HDC hdc = (HDC)pDC;
1246 if (GetParent()->GetTransparentBackground())
1247 SetBkMode(hdc, TRANSPARENT);
1248 else
1249 SetBkMode(hdc, OPAQUE);
1250
1251 wxColour colBack = GetBackgroundColour();
1252
1253 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
1254 colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1255
1256 ::SetBkColor(hdc, wxColourToRGB(colBack));
1257 ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
1258
1259 wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
1260
1261 return (WXHBRUSH)brush->GetResourceHandle();
1262 }
1263
1264 // In WIN16, need to override normal erasing because
1265 // Ctl3D doesn't use the wxWindows background colour.
1266 #ifdef __WIN16__
1267 void wxTextCtrl::OnEraseBackground(wxEraseEvent& event)
1268 {
1269 wxColour col(m_backgroundColour);
1270
1271 #if wxUSE_CTL3D
1272 if (m_useCtl3D)
1273 col = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1274 #endif
1275
1276 RECT rect;
1277 ::GetClientRect(GetHwnd(), &rect);
1278
1279 COLORREF ref = wxColourToRGB(col);
1280 HBRUSH hBrush = ::CreateSolidBrush(ref);
1281 if ( !hBrush )
1282 wxLogLastError(wxT("CreateSolidBrush"));
1283
1284 HDC hdc = (HDC)event.GetDC()->GetHDC();
1285
1286 int mode = ::SetMapMode(hdc, MM_TEXT);
1287
1288 ::FillRect(hdc, &rect, hBrush);
1289 ::DeleteObject(hBrush);
1290 ::SetMapMode(hdc, mode);
1291
1292 }
1293 #endif // Win16
1294
1295 bool wxTextCtrl::AdjustSpaceLimit()
1296 {
1297 #ifndef __WIN16__
1298 unsigned int limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0);
1299
1300 // HACK: we try to automatically extend the limit for the amount of text
1301 // to allow (interactively) entering more than 64Kb of text under
1302 // Win9x but we shouldn't reset the text limit which was previously
1303 // set explicitly with SetMaxLength()
1304 //
1305 // we could solve this by storing the limit we set in wxTextCtrl but
1306 // to save space we prefer to simply test here the actual limit
1307 // value: we consider that SetMaxLength() can only be called for
1308 // values < 32Kb
1309 if ( limit < 0x8000 )
1310 {
1311 // we've got more text than limit set by SetMaxLength()
1312 return FALSE;
1313 }
1314
1315 unsigned int len = ::GetWindowTextLength(GetHwnd());
1316 if ( len >= limit )
1317 {
1318 limit = len + 0x8000; // 32Kb
1319
1320 #if wxUSE_RICHEDIT
1321 if ( IsRich() )
1322 {
1323 // as a nice side effect, this also allows passing limit > 64Kb
1324 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit);
1325 }
1326 else
1327 #endif // wxUSE_RICHEDIT
1328 {
1329 if ( limit > 0xffff )
1330 {
1331 // this will set it to a platform-dependent maximum (much more
1332 // than 64Kb under NT)
1333 limit = 0;
1334 }
1335
1336 ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0);
1337 }
1338 }
1339 #endif // !Win16
1340
1341 // we changed the limit
1342 return TRUE;
1343 }
1344
1345 bool wxTextCtrl::AcceptsFocus() const
1346 {
1347 // we don't want focus if we can't be edited
1348 return IsEditable() && wxControl::AcceptsFocus();
1349 }
1350
1351 wxSize wxTextCtrl::DoGetBestSize() const
1352 {
1353 int cx, cy;
1354 wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1355
1356 int wText = DEFAULT_ITEM_WIDTH;
1357
1358 int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1359 if ( m_windowStyle & wxTE_MULTILINE )
1360 {
1361 hText *= wxMax(GetNumberOfLines(), 5);
1362 }
1363 //else: for single line control everything is ok
1364
1365 return wxSize(wText, hText);
1366 }
1367
1368 // ----------------------------------------------------------------------------
1369 // standard handlers for standard edit menu events
1370 // ----------------------------------------------------------------------------
1371
1372 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1373 {
1374 Cut();
1375 }
1376
1377 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1378 {
1379 Copy();
1380 }
1381
1382 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1383 {
1384 Paste();
1385 }
1386
1387 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1388 {
1389 Undo();
1390 }
1391
1392 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1393 {
1394 Redo();
1395 }
1396
1397 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1398 {
1399 event.Enable( CanCut() );
1400 }
1401
1402 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1403 {
1404 event.Enable( CanCopy() );
1405 }
1406
1407 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1408 {
1409 event.Enable( CanPaste() );
1410 }
1411
1412 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1413 {
1414 event.Enable( CanUndo() );
1415 }
1416
1417 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1418 {
1419 event.Enable( CanRedo() );
1420 }
1421
1422 // the rest of the file only deals with the rich edit controls
1423 #if wxUSE_RICHEDIT
1424
1425 // ----------------------------------------------------------------------------
1426 // EN_LINK processing
1427 // ----------------------------------------------------------------------------
1428
1429 bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
1430 {
1431 NMHDR *hdr = (NMHDR* )lParam;
1432 if ( hdr->code == EN_LINK )
1433 {
1434 ENLINK *enlink = (ENLINK *)hdr;
1435
1436 switch ( enlink->msg )
1437 {
1438 case WM_SETCURSOR:
1439 // ok, so it is hardcoded - do we really nee to customize it?
1440 ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND)));
1441 *result = TRUE;
1442 break;
1443
1444 case WM_MOUSEMOVE:
1445 case WM_LBUTTONDOWN:
1446 case WM_LBUTTONUP:
1447 case WM_LBUTTONDBLCLK:
1448 case WM_RBUTTONDOWN:
1449 case WM_RBUTTONUP:
1450 case WM_RBUTTONDBLCLK:
1451 // send a mouse event
1452 {
1453 static const wxEventType eventsMouse[] =
1454 {
1455 wxEVT_MOTION,
1456 wxEVT_LEFT_DOWN,
1457 wxEVT_LEFT_UP,
1458 wxEVT_LEFT_DCLICK,
1459 wxEVT_RIGHT_DOWN,
1460 wxEVT_RIGHT_UP,
1461 wxEVT_RIGHT_DCLICK,
1462 };
1463
1464 // the event ids are consecutive
1465 wxMouseEvent
1466 evtMouse(eventsMouse[enlink->msg - WM_MOUSEMOVE]);
1467
1468 InitMouseEvent(evtMouse,
1469 GET_X_LPARAM(enlink->lParam),
1470 GET_Y_LPARAM(enlink->lParam),
1471 enlink->wParam);
1472
1473 wxTextUrlEvent event(m_windowId, evtMouse,
1474 enlink->chrg.cpMin,
1475 enlink->chrg.cpMax);
1476
1477 InitCommandEvent(event);
1478
1479 *result = ProcessCommand(event);
1480 }
1481 break;
1482 }
1483
1484 return TRUE;
1485 }
1486
1487 // not processed
1488 return FALSE;
1489 }
1490
1491 // ----------------------------------------------------------------------------
1492 // colour setting for the rich edit controls
1493 // ----------------------------------------------------------------------------
1494
1495 bool wxTextCtrl::SetBackgroundColour(const wxColour& colour)
1496 {
1497 if ( !wxTextCtrlBase::SetBackgroundColour(colour) )
1498 {
1499 // colour didn't really change
1500 return FALSE;
1501 }
1502
1503 if ( IsRich() )
1504 {
1505 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
1506 // EM_SETBKGNDCOLOR additionally
1507 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR, 0, wxColourToRGB(colour));
1508 }
1509
1510 return TRUE;
1511 }
1512
1513 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1514 {
1515 if ( !wxTextCtrlBase::SetForegroundColour(colour) )
1516 {
1517 // colour didn't really change
1518 return FALSE;
1519 }
1520
1521 if ( IsRich() )
1522 {
1523 // change the colour of everything
1524 CHARFORMAT cf;
1525 wxZeroMemory(cf);
1526 cf.cbSize = sizeof(cf);
1527 cf.dwMask = CFM_COLOR;
1528 cf.crTextColor = wxColourToRGB(colour);
1529 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
1530 }
1531
1532 return TRUE;
1533 }
1534
1535 // ----------------------------------------------------------------------------
1536 // styling support for rich edit controls
1537 // ----------------------------------------------------------------------------
1538
1539 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
1540 {
1541 if ( !IsRich() )
1542 {
1543 // can't do it with normal text control
1544 return FALSE;
1545 }
1546
1547 // the richedit 1.0 doesn't handle setting background colour, so don't
1548 // even try to do anything if it's the only thing we want to change
1549 if ( m_verRichEdit == 1 && !style.HasFont() && !style.HasTextColour() )
1550 {
1551 // nothing to do: return TRUE if there was really nothing to do and
1552 // FALSE if we failed to set bg colour
1553 return !style.HasBackgroundColour();
1554 }
1555
1556 // order the range if needed
1557 if ( start > end )
1558 {
1559 long tmp = start;
1560 start = end;
1561 end = tmp;
1562 }
1563
1564 // we can only change the format of the selection, so select the range we
1565 // want and restore the old selection later
1566 long startOld, endOld;
1567 GetSelection(&startOld, &endOld);
1568
1569 // but do we really have to change the selection?
1570 bool changeSel = start != startOld || end != endOld;
1571
1572 if ( changeSel )
1573 {
1574 DoSetSelection(start, end, FALSE /* don't scroll caret into view */);
1575 }
1576
1577 // initialize CHARFORMAT struct
1578 #if wxUSE_RICHEDIT2
1579 CHARFORMAT2 cf;
1580 #else
1581 CHARFORMAT cf;
1582 #endif
1583
1584 wxZeroMemory(cf);
1585
1586 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
1587 // CHARFORMAT in that case
1588 #if wxUSE_RICHEDIT2
1589 if ( m_verRichEdit == 1 )
1590 {
1591 // this is the only thing the control is going to grok
1592 cf.cbSize = sizeof(CHARFORMAT);
1593 }
1594 else
1595 #endif
1596 {
1597 // CHARFORMAT or CHARFORMAT2
1598 cf.cbSize = sizeof(cf);
1599 }
1600
1601 if ( style.HasFont() )
1602 {
1603 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
1604 // but using it doesn't seem to hurt neither so leaving it for now
1605
1606 cf.dwMask |= CFM_FACE | CFM_SIZE | CFM_CHARSET |
1607 CFM_ITALIC | CFM_BOLD | CFM_UNDERLINE;
1608
1609 // fill in data from LOGFONT but recalculate lfHeight because we need
1610 // the real height in twips and not the negative number which
1611 // wxFillLogFont() returns (this is correct in general and works with
1612 // the Windows font mapper, but not here)
1613 LOGFONT lf;
1614 wxFillLogFont(&lf, &style.GetFont());
1615 cf.yHeight = 20*style.GetFont().GetPointSize(); // 1 pt = 20 twips
1616 cf.bCharSet = lf.lfCharSet;
1617 cf.bPitchAndFamily = lf.lfPitchAndFamily;
1618 wxStrncpy( cf.szFaceName, lf.lfFaceName, WXSIZEOF(cf.szFaceName) );
1619
1620 // also deal with underline/italic/bold attributes: note that we must
1621 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
1622 // style to allow clearing it
1623 if ( lf.lfItalic )
1624 {
1625 cf.dwEffects |= CFE_ITALIC;
1626 }
1627
1628 if ( lf.lfWeight == FW_BOLD )
1629 {
1630 cf.dwEffects |= CFE_BOLD;
1631 }
1632
1633 if ( lf.lfUnderline )
1634 {
1635 cf.dwEffects |= CFE_UNDERLINE;
1636 }
1637
1638 // strikeout fonts are not supported by wxWindows
1639 }
1640
1641 if ( style.HasTextColour() )
1642 {
1643 cf.dwMask |= CFM_COLOR;
1644 cf.crTextColor = wxColourToRGB(style.GetTextColour());
1645 }
1646
1647 #if wxUSE_RICHEDIT2
1648 if ( m_verRichEdit != 1 && style.HasBackgroundColour() )
1649 {
1650 cf.dwMask |= CFM_BACKCOLOR;
1651 cf.crBackColor = wxColourToRGB(style.GetBackgroundColour());
1652 }
1653 #endif // wxUSE_RICHEDIT2
1654
1655 // do format the selection
1656 bool ok = ::SendMessage(GetHwnd(), EM_SETCHARFORMAT,
1657 SCF_SELECTION, (LPARAM)&cf) != 0;
1658 if ( !ok )
1659 {
1660 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
1661 }
1662
1663 if ( changeSel )
1664 {
1665 // restore the original selection
1666 DoSetSelection(startOld, endOld, FALSE);
1667 }
1668
1669 return ok;
1670 }
1671
1672 // ----------------------------------------------------------------------------
1673 // wxRichEditModule
1674 // ----------------------------------------------------------------------------
1675
1676 bool wxRichEditModule::OnInit()
1677 {
1678 // don't do anything - we will load it when needed
1679 return TRUE;
1680 }
1681
1682 void wxRichEditModule::OnExit()
1683 {
1684 for ( int i = 0; i < WXSIZEOF(ms_hRichEdit); i++ )
1685 {
1686 if ( ms_hRichEdit[i] )
1687 {
1688 ::FreeLibrary(ms_hRichEdit[i]);
1689 }
1690 }
1691 }
1692
1693 /* static */
1694 bool wxRichEditModule::Load(int version)
1695 {
1696 // we don't support loading richedit 3.0 as I don't know how to distinguish
1697 // it from 2.0 anyhow
1698 wxCHECK_MSG( version == 1 || version == 2, FALSE,
1699 _T("incorrect richedit control version requested") );
1700
1701 // make it the index in the array
1702 version--;
1703
1704 if ( ms_hRichEdit[version] == (HINSTANCE)-1 )
1705 {
1706 // we had already tried to load it and failed
1707 return FALSE;
1708 }
1709
1710 if ( ms_hRichEdit[version] )
1711 {
1712 // we've already got this one
1713 return TRUE;
1714 }
1715
1716 wxString dllname = version ? _T("riched20") : _T("riched32");
1717 dllname += _T(".dll");
1718
1719 ms_hRichEdit[version] = ::LoadLibrary(dllname);
1720
1721 if ( !ms_hRichEdit[version] )
1722 {
1723 wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str());
1724
1725 ms_hRichEdit[version] = (HINSTANCE)-1;
1726
1727 return FALSE;
1728 }
1729
1730 return TRUE;
1731 }
1732
1733 #endif // wxUSE_RICHEDIT
1734
1735 #endif // wxUSE_TEXTCTRL
wxWidgets (Impactor)