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