1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/textctrl.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
17 #pragma implementation "textctrl.h"
20 // ----------------------------------------------------------------------------
22 // ----------------------------------------------------------------------------
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
34 #include "wx/textctrl.h"
35 #include "wx/settings.h"
43 #include "wx/module.h"
46 #include "wx/clipbrd.h"
49 #include "wx/textfile.h"
53 #include "wx/msw/private.h"
57 #include <sys/types.h>
59 #if wxUSE_RICHEDIT && (!defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__))
63 // old mingw32 doesn't define this
65 #define CFM_CHARSET 0x08000000
69 #define CFM_BACKCOLOR 0x04000000
72 // cygwin does not have these defined for richedit
74 #define ENM_LINK 0x04000000
77 #ifndef EM_AUTOURLDETECT
78 #define EM_AUTOURLDETECT (WM_USER + 91)
82 #define EN_LINK 0x070b
84 typedef struct _enlink
95 #define SF_UNICODE 0x0010
98 // Watcom C++ doesn't define this
100 #define SCF_ALL 0x0004
103 // ----------------------------------------------------------------------------
105 // ----------------------------------------------------------------------------
109 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
);
111 #endif // wxUSE_RICHEDIT
113 // ----------------------------------------------------------------------------
115 // ----------------------------------------------------------------------------
119 // this module initializes RichEdit DLL(s) if needed
120 class wxRichEditModule
: public wxModule
123 virtual bool OnInit();
124 virtual void OnExit();
126 // load the richedit DLL of at least of required version
127 static bool Load(int version
= 1);
130 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
131 static HINSTANCE ms_hRichEdit
[2];
133 DECLARE_DYNAMIC_CLASS(wxRichEditModule
)
136 HINSTANCE
wxRichEditModule::ms_hRichEdit
[2] = { NULL
, NULL
};
138 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule
, wxModule
)
140 #endif // wxUSE_RICHEDIT
142 // ----------------------------------------------------------------------------
143 // event tables and other macros
144 // ----------------------------------------------------------------------------
146 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
148 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
149 EVT_CHAR(wxTextCtrl::OnChar
)
150 EVT_DROP_FILES(wxTextCtrl::OnDropFiles
)
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
)
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
)
164 EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground
)
168 // ============================================================================
170 // ============================================================================
172 // ----------------------------------------------------------------------------
174 // ----------------------------------------------------------------------------
176 void wxTextCtrl::Init()
183 bool wxTextCtrl::Create(wxWindow
*parent
, wxWindowID id
,
184 const wxString
& value
,
188 const wxValidator
& validator
,
189 const wxString
& name
)
191 // base initialization
192 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
196 parent
->AddChild(this);
198 // translate wxWin style flags to MSW ones
199 WXDWORD msStyle
= MSWGetCreateWindowFlags();
201 // do create the control - either an EDIT or RICHEDIT
202 wxString windowClass
= wxT("EDIT");
205 if ( m_windowStyle
& wxTE_AUTO_URL
)
207 // automatic URL detection only works in RichEdit 2.0+
208 m_windowStyle
|= wxTE_RICH2
;
211 if ( m_windowStyle
& wxTE_RICH2
)
213 // using richedit 2.0 implies using wxTE_RICH
214 m_windowStyle
|= wxTE_RICH
;
217 // we need to load the richedit DLL before creating the rich edit control
218 if ( m_windowStyle
& wxTE_RICH
)
220 static bool s_errorGiven
= FALSE
;// MT-FIXME
222 // Which version do we need? Use 1.0 by default because it is much more
223 // like the the standard EDIT or 2.0 if explicitly requested, but use
224 // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
226 // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
227 // (and thus EDIT) much better than RichEdit 2.0 so we probably
228 // should use 3.0 if available as it is the best of both worlds -
229 // but as I can't test it right now I don't do it (VZ)
231 const int verRichEdit
= 2;
232 #else // !wxUSE_UNICODE
233 int verRichEdit
= m_windowStyle
& wxTE_RICH2
? 2 : 1;
234 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
236 // only give the error msg once if the DLL can't be loaded
239 // try to load the RichEdit DLL (will do nothing if already done)
240 if ( !wxRichEditModule::Load(verRichEdit
) )
243 // try another version?
244 verRichEdit
= 3 - verRichEdit
; // 1 <-> 2
246 if ( !wxRichEditModule::Load(verRichEdit
) )
247 #endif // wxUSE_UNICODE
249 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
256 // have we managed to load any richedit version?
259 msStyle
|= ES_AUTOVSCROLL
;
261 m_verRichEdit
= verRichEdit
;
262 if ( m_verRichEdit
== 1 )
264 windowClass
= wxT("RICHEDIT");
268 #ifndef RICHEDIT_CLASS
269 wxString RICHEDIT_CLASS
;
270 RICHEDIT_CLASS
.Printf(_T("RichEdit%d0"), m_verRichEdit
);
272 RICHEDIT_CLASS
+= _T('W');
274 RICHEDIT_CLASS
+= _T('A');
275 #endif // Unicode/ANSI
276 #endif // !RICHEDIT_CLASS
278 windowClass
= RICHEDIT_CLASS
;
282 #endif // wxUSE_RICHEDIT
284 // we need to turn '\n's into "\r\n"s for the multiline controls
286 if ( m_windowStyle
& wxTE_MULTILINE
)
288 valueWin
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
295 if ( !MSWCreateControl(windowClass
, msStyle
, pos
, size
, valueWin
) )
298 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
303 // have to enable events manually
304 LPARAM mask
= ENM_CHANGE
| ENM_DROPFILES
| ENM_SELCHANGE
| ENM_UPDATE
;
306 if ( m_windowStyle
& wxTE_AUTO_URL
)
310 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT
, TRUE
, 0);
313 ::SendMessage(GetHwnd(), EM_SETEVENTMASK
, 0, mask
);
315 #endif // wxUSE_RICHEDIT
320 // Make sure the window style (etc.) reflects the HWND style (roughly)
321 void wxTextCtrl::AdoptAttributesFromHWND()
323 wxWindow::AdoptAttributesFromHWND();
325 HWND hWnd
= GetHwnd();
326 long style
= ::GetWindowLong(hWnd
, GWL_STYLE
);
328 // retrieve the style to see whether this is an edit or richedit ctrl
330 wxString classname
= wxGetWindowClass(GetHWND());
332 if ( classname
.IsSameAs(_T("EDIT"), FALSE
/* no case */) )
339 if ( wxSscanf(classname
, _T("RichEdit%d0%c"), &m_verRichEdit
, &c
) != 2 )
341 wxLogDebug(_T("Unknown edit control '%s'."), classname
.c_str());
346 #endif // wxUSE_RICHEDIT
348 if (style
& ES_MULTILINE
)
349 m_windowStyle
|= wxTE_MULTILINE
;
350 if (style
& ES_PASSWORD
)
351 m_windowStyle
|= wxTE_PASSWORD
;
352 if (style
& ES_READONLY
)
353 m_windowStyle
|= wxTE_READONLY
;
354 if (style
& ES_WANTRETURN
)
355 m_windowStyle
|= wxTE_PROCESS_ENTER
;
358 WXDWORD
wxTextCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
360 // default border for the text controls is the sunken one
361 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
363 style
|= wxBORDER_SUNKEN
;
366 long msStyle
= wxControl::MSWGetStyle(style
, exstyle
);
371 if ( style
& wxTE_MULTILINE
)
373 wxASSERT_MSG( !(style
& wxTE_PROCESS_ENTER
),
374 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
376 msStyle
|= ES_MULTILINE
| ES_WANTRETURN
;
377 if ( !(style
& wxTE_NO_VSCROLL
) )
378 msStyle
|= WS_VSCROLL
;
380 style
|= wxTE_PROCESS_ENTER
;
384 // there is really no reason to not have this style for single line
386 msStyle
|= ES_AUTOHSCROLL
;
389 if ( style
& wxHSCROLL
)
390 msStyle
|= WS_HSCROLL
| ES_AUTOHSCROLL
;
392 if ( style
& wxTE_READONLY
)
393 msStyle
|= ES_READONLY
;
395 if ( style
& wxTE_PASSWORD
)
396 msStyle
|= ES_PASSWORD
;
398 if ( style
& wxTE_AUTO_SCROLL
)
399 msStyle
|= ES_AUTOHSCROLL
;
401 if ( style
& wxTE_NOHIDESEL
)
402 msStyle
|= ES_NOHIDESEL
;
407 void wxTextCtrl::SetWindowStyleFlag(long style
)
410 // we have to deal with some styles separately because they can't be
411 // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
412 // using richedit-specific EM_SETOPTIONS
414 ((style
& wxTE_NOHIDESEL
) != (GetWindowStyle() & wxTE_NOHIDESEL
)) )
416 bool set
= (style
& wxTE_NOHIDESEL
) != 0;
418 ::SendMessage(GetHwnd(), EM_SETOPTIONS
, set
? ECOOP_OR
: ECOOP_AND
,
419 set
? ECO_NOHIDESEL
: ~ECO_NOHIDESEL
);
421 #endif // wxUSE_RICHEDIT
423 wxControl::SetWindowStyleFlag(style
);
426 // ----------------------------------------------------------------------------
427 // set/get the controls text
428 // ----------------------------------------------------------------------------
430 wxString
wxTextCtrl::GetValue() const
432 // range 0..-1 is special for GetRange() and means to retrieve all text
433 return GetRange(0, -1);
436 wxString
wxTextCtrl::GetRange(long from
, long to
) const
440 if ( from
>= to
&& to
!= -1 )
442 // nothing to retrieve
449 int len
= GetWindowTextLength(GetHwnd());
452 // alloc one extra WORD as needed by the control
453 wxChar
*p
= str
.GetWriteBuf(++len
);
456 textRange
.chrg
.cpMin
= from
;
457 textRange
.chrg
.cpMax
= to
== -1 ? len
: to
;
458 textRange
.lpstrText
= p
;
460 (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE
, 0, (LPARAM
)&textRange
);
462 if ( m_verRichEdit
> 1 )
464 // RichEdit 2.0 uses just CR ('\r') for the newlines which is
465 // neither Unix nor Windows style - convert it to something
469 if ( *p
== _T('\r') )
476 if ( m_verRichEdit
== 1 )
478 // convert to the canonical form - see comment below
479 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
482 //else: no text at all, leave the string empty
485 #endif // wxUSE_RICHEDIT
488 str
= wxGetWindowText(GetHWND());
490 // need only a range?
493 str
= str
.Mid(from
, to
- from
);
496 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
497 // canonical one (same one as above) for consistency with the other kinds
498 // of controls and, more importantly, with the other ports
499 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
505 void wxTextCtrl::SetValue(const wxString
& value
)
507 // if the text is long enough, it's faster to just set it instead of first
508 // comparing it with the old one (chances are that it will be different
509 // anyhow, this comparison is there to avoid flicker for small single-line
510 // edit controls mostly)
511 if ( (value
.length() > 0x400) || (value
!= GetValue()) )
513 DoWriteText(value
, FALSE
/* not selection only */);
515 // mark the control as being not dirty - we changed its text, not the
519 // for compatibility, don't move the cursor when doing SetValue()
520 SetInsertionPoint(0);
524 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
526 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
530 wchar_t *wbuf
= (wchar_t *)buf
;
531 const wchar_t *wpc
= *(const wchar_t **)dwCookie
;
536 cb
-= sizeof(wchar_t);
537 (*pcb
) += sizeof(wchar_t);
540 *(const wchar_t **)dwCookie
= wpc
;
545 extern long wxEncodingToCodepage(wxFontEncoding encoding
); // from utils.cpp
547 #if wxUSE_UNICODE_MSLU
548 bool wxTextCtrl::StreamIn(const wxString
& value
,
549 wxFontEncoding
WXUNUSED(encoding
),
552 const wchar_t *wpc
= value
.c_str();
553 #else // !wxUSE_UNICODE_MSLU
554 bool wxTextCtrl::StreamIn(const wxString
& value
,
555 wxFontEncoding encoding
,
558 // we have to use EM_STREAMIN to force richedit control 2.0+ to show any
559 // text in the non default charset - otherwise it thinks it knows better
560 // than we do and always shows it in the default one
562 // first get the Windows code page for this encoding
563 long codepage
= wxEncodingToCodepage(encoding
);
564 if ( codepage
== -1 )
570 // next translate to Unicode using this code page
571 int len
= ::MultiByteToWideChar(codepage
, 0, value
, -1, NULL
, 0);
574 wxWCharBuffer
wchBuf(len
);
576 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
579 if ( !::MultiByteToWideChar(codepage
, 0, value
, -1,
580 (wchar_t *)(const wchar_t *)wchBuf
, len
) )
582 wxLogLastError(_T("MultiByteToWideChar"));
585 // finally, stream it in the control
586 const wchar_t *wpc
= wchBuf
;
587 #endif // wxUSE_UNICODE_MSLU
591 eds
.dwCookie
= (DWORD
)&wpc
;
592 // the cast below is needed for broken (very) old mingw32 headers
593 eds
.pfnCallback
= (EDITSTREAMCALLBACK
)wxRichEditStreamIn
;
595 if ( !::SendMessage(GetHwnd(), EM_STREAMIN
,
598 (selectionOnly
? SFF_SELECTION
: 0),
599 (LPARAM
)&eds
) || eds
.dwError
)
601 wxLogLastError(_T("EM_STREAMIN"));
606 #endif // !wxUSE_WCHAR_T
611 #endif // wxUSE_RICHEDIT
613 void wxTextCtrl::WriteText(const wxString
& value
)
618 void wxTextCtrl::DoWriteText(const wxString
& value
, bool selectionOnly
)
621 if ( m_windowStyle
& wxTE_MULTILINE
)
622 valueDos
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
627 // there are several complications with the rich edit controls here
631 // first, ensure that the new text will be in the default style
632 if ( !m_defaultStyle
.IsDefault() )
635 GetSelection(&start
, &end
);
636 SetStyle(start
, end
, m_defaultStyle
);
639 #if wxUSE_UNICODE_MSLU
640 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
641 // but EM_STREAMIN works
642 if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
644 done
= StreamIn(valueDos
, wxFONTENCODING_SYSTEM
, selectionOnly
);
646 #endif // wxUSE_UNICODE_MSLU
649 // next check if the text we're inserting must be shown in a non
650 // default charset -- this only works for RichEdit > 1.0
651 if ( GetRichVersion() > 1 )
653 wxFont font
= m_defaultStyle
.GetFont();
659 wxFontEncoding encoding
= font
.GetEncoding();
660 if ( encoding
!= wxFONTENCODING_SYSTEM
)
662 done
= StreamIn(valueDos
, encoding
, selectionOnly
);
666 #endif // !wxUSE_UNICODE
670 #endif // wxUSE_RICHEDIT
672 if ( !selectionOnly
)
674 SetSelection(-1, -1);
677 ::SendMessage(GetHwnd(), EM_REPLACESEL
, 0, (LPARAM
)valueDos
.c_str());
683 void wxTextCtrl::AppendText(const wxString
& text
)
685 SetInsertionPointEnd();
690 void wxTextCtrl::Clear()
692 ::SetWindowText(GetHwnd(), wxT(""));
697 bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent
& event
)
701 size_t lenOld
= GetValue().length();
703 wxUint32 code
= event
.GetRawKeyCode();
704 ::keybd_event(code
, 0, 0 /* key press */, NULL
);
705 ::keybd_event(code
, 0, KEYEVENTF_KEYUP
, NULL
);
707 // assume that any alphanumeric key changes the total number of characters
708 // in the control - this should work in 99% of cases
709 return GetValue().length() != lenOld
;
714 // ----------------------------------------------------------------------------
715 // Clipboard operations
716 // ----------------------------------------------------------------------------
718 void wxTextCtrl::Copy()
722 ::SendMessage(GetHwnd(), WM_COPY
, 0, 0L);
726 void wxTextCtrl::Cut()
730 ::SendMessage(GetHwnd(), WM_CUT
, 0, 0L);
734 void wxTextCtrl::Paste()
738 ::SendMessage(GetHwnd(), WM_PASTE
, 0, 0L);
742 bool wxTextCtrl::CanCopy() const
744 // Can copy if there's a selection
746 GetSelection(&from
, &to
);
750 bool wxTextCtrl::CanCut() const
752 return CanCopy() && IsEditable();
755 bool wxTextCtrl::CanPaste() const
763 UINT cf
= 0; // 0 == any format
765 return ::SendMessage(GetHwnd(), EM_CANPASTE
, cf
, 0) != 0;
767 #endif // wxUSE_RICHEDIT
769 // Standard edit control: check for straight text on clipboard
770 if ( !::OpenClipboard(GetHwndOf(wxTheApp
->GetTopWindow())) )
773 bool isTextAvailable
= ::IsClipboardFormatAvailable(CF_TEXT
) != 0;
776 return isTextAvailable
;
779 // ----------------------------------------------------------------------------
781 // ----------------------------------------------------------------------------
783 void wxTextCtrl::SetEditable(bool editable
)
785 HWND hWnd
= GetHwnd();
786 SendMessage(hWnd
, EM_SETREADONLY
, (WPARAM
)!editable
, (LPARAM
)0L);
789 void wxTextCtrl::SetInsertionPoint(long pos
)
791 DoSetSelection(pos
, pos
);
794 void wxTextCtrl::SetInsertionPointEnd()
799 if ( m_verRichEdit
== 1 )
801 // we don't have to waste time calling GetLastPosition() in this case
804 else // !RichEdit 1.0
805 #endif // wxUSE_RICHEDIT
807 pos
= GetLastPosition();
810 SetInsertionPoint(pos
);
813 long wxTextCtrl::GetInsertionPoint() const
821 SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &range
);
824 #endif // wxUSE_RICHEDIT
826 DWORD Pos
= (DWORD
)SendMessage(GetHwnd(), EM_GETSEL
, 0, 0L);
830 long wxTextCtrl::GetLastPosition() const
832 int numLines
= GetNumberOfLines();
833 long posStartLastLine
= XYToPosition(0, numLines
- 1);
835 long lenLastLine
= GetLengthOfLineContainingPos(posStartLastLine
);
837 return posStartLastLine
+ lenLastLine
;
840 // If the return values from and to are the same, there is no
842 void wxTextCtrl::GetSelection(long* from
, long* to
) const
848 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &charRange
);
850 *from
= charRange
.cpMin
;
851 *to
= charRange
.cpMax
;
854 #endif // !wxUSE_RICHEDIT
856 DWORD dwStart
, dwEnd
;
857 ::SendMessage(GetHwnd(), EM_GETSEL
, (WPARAM
)&dwStart
, (LPARAM
)&dwEnd
);
864 bool wxTextCtrl::IsEditable() const
866 // strangely enough, we may be called before the control is created: our
867 // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls
872 long style
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
874 return (style
& ES_READONLY
) == 0;
877 // ----------------------------------------------------------------------------
879 // ----------------------------------------------------------------------------
881 void wxTextCtrl::SetSelection(long from
, long to
)
883 // if from and to are both -1, it means (in wxWindows) that all text should
884 // be selected - translate into Windows convention
885 if ( (from
== -1) && (to
== -1) )
891 DoSetSelection(from
, to
);
894 void wxTextCtrl::DoSetSelection(long from
, long to
, bool scrollCaret
)
896 HWND hWnd
= GetHwnd();
905 SendMessage(hWnd
, EM_EXSETSEL
, 0, (LPARAM
) &range
);
908 #endif // wxUSE_RICHEDIT
910 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)from
, (LPARAM
)to
);
915 SendMessage(hWnd
, EM_SCROLLCARET
, (WPARAM
)0, (LPARAM
)0);
918 // WPARAM is 0: selection is scrolled into view
919 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)0, (LPARAM
)MAKELONG(from
, to
));
923 // ----------------------------------------------------------------------------
925 // ----------------------------------------------------------------------------
927 void wxTextCtrl::Replace(long from
, long to
, const wxString
& value
)
929 // Set selection and remove it
930 DoSetSelection(from
, to
, FALSE
/* don't scroll caret into view */);
932 SendMessage(GetHwnd(), EM_REPLACESEL
,
938 (LPARAM
)value
.c_str());
941 void wxTextCtrl::Remove(long from
, long to
)
943 Replace(from
, to
, _T(""));
946 bool wxTextCtrl::LoadFile(const wxString
& file
)
948 if ( wxTextCtrlBase::LoadFile(file
) )
950 // update the size limit if needed
959 bool wxTextCtrl::IsModified() const
961 return SendMessage(GetHwnd(), EM_GETMODIFY
, 0, 0) != 0;
964 // Makes 'unmodified'
965 void wxTextCtrl::DiscardEdits()
967 SendMessage(GetHwnd(), EM_SETMODIFY
, FALSE
, 0L);
970 int wxTextCtrl::GetNumberOfLines() const
972 return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT
, (WPARAM
)0, (LPARAM
)0);
975 long wxTextCtrl::XYToPosition(long x
, long y
) const
977 // This gets the char index for the _beginning_ of this line
978 long charIndex
= SendMessage(GetHwnd(), EM_LINEINDEX
, (WPARAM
)y
, (LPARAM
)0);
980 return charIndex
+ x
;
983 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
985 HWND hWnd
= GetHwnd();
987 // This gets the line number containing the character
992 lineNo
= SendMessage(hWnd
, EM_EXLINEFROMCHAR
, 0, (LPARAM
)pos
);
995 #endif // wxUSE_RICHEDIT
997 lineNo
= SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, 0);
1006 // This gets the char index for the _beginning_ of this line
1007 long charIndex
= SendMessage(hWnd
, EM_LINEINDEX
, (WPARAM
)lineNo
, (LPARAM
)0);
1008 if ( charIndex
== -1 )
1013 // The X position must therefore be the different between pos and charIndex
1015 *x
= pos
- charIndex
;
1022 void wxTextCtrl::ShowPosition(long pos
)
1024 HWND hWnd
= GetHwnd();
1026 // To scroll to a position, we pass the number of lines and characters
1027 // to scroll *by*. This means that we need to:
1028 // (1) Find the line position of the current line.
1029 // (2) Find the line position of pos.
1030 // (3) Scroll by (pos - current).
1031 // For now, ignore the horizontal scrolling.
1033 // Is this where scrolling is relative to - the line containing the caret?
1034 // Or is the first visible line??? Try first visible line.
1035 // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
1037 int currentLineLineNo
= (int)SendMessage(hWnd
, EM_GETFIRSTVISIBLELINE
, (WPARAM
)0, (LPARAM
)0L);
1039 int specifiedLineLineNo
= (int)SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, (LPARAM
)0L);
1041 int linesToScroll
= specifiedLineLineNo
- currentLineLineNo
;
1043 if (linesToScroll
!= 0)
1044 (void)SendMessage(hWnd
, EM_LINESCROLL
, (WPARAM
)0, (LPARAM
)linesToScroll
);
1047 long wxTextCtrl::GetLengthOfLineContainingPos(long pos
) const
1049 return ::SendMessage(GetHwnd(), EM_LINELENGTH
, (WPARAM
)pos
, 0);
1052 int wxTextCtrl::GetLineLength(long lineNo
) const
1054 long pos
= XYToPosition(0, lineNo
);
1056 return GetLengthOfLineContainingPos(pos
);
1059 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1061 size_t len
= (size_t)GetLineLength(lineNo
) + 1;
1063 // there must be at least enough place for the length WORD in the
1065 len
+= sizeof(WORD
);
1068 wxChar
*buf
= str
.GetWriteBuf(len
);
1070 *(WORD
*)buf
= (WORD
)len
;
1071 len
= (size_t)::SendMessage(GetHwnd(), EM_GETLINE
, lineNo
, (LPARAM
)buf
);
1074 str
.UngetWriteBuf(len
);
1079 void wxTextCtrl::SetMaxLength(unsigned long len
)
1081 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, len
, 0);
1084 // ----------------------------------------------------------------------------
1086 // ----------------------------------------------------------------------------
1088 void wxTextCtrl::Undo()
1092 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1096 void wxTextCtrl::Redo()
1100 // Same as Undo, since Undo undoes the undo, i.e. a redo.
1101 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1105 bool wxTextCtrl::CanUndo() const
1107 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1110 bool wxTextCtrl::CanRedo() const
1112 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1115 // ----------------------------------------------------------------------------
1116 // implemenation details
1117 // ----------------------------------------------------------------------------
1119 void wxTextCtrl::Command(wxCommandEvent
& event
)
1121 SetValue(event
.GetString());
1122 ProcessCommand (event
);
1125 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1127 // By default, load the first file into the text window.
1128 if (event
.GetNumberOfFiles() > 0)
1130 LoadFile(event
.GetFiles()[0]);
1134 // ----------------------------------------------------------------------------
1135 // kbd input processing
1136 // ----------------------------------------------------------------------------
1138 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG
* pMsg
)
1140 MSG
*msg
= (MSG
*)pMsg
;
1142 // check for our special keys here: if we don't do it and the parent frame
1143 // uses them as accelerators, they wouldn't work at all, so we disable
1144 // usual preprocessing for them
1145 if ( msg
->message
== WM_KEYDOWN
)
1147 WORD vkey
= (WORD
) msg
->wParam
;
1148 if ( (HIWORD(msg
->lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
1150 if ( vkey
== VK_BACK
)
1155 if ( wxIsCtrlDown() )
1169 else if ( wxIsShiftDown() )
1171 if ( vkey
== VK_INSERT
|| vkey
== VK_DELETE
)
1177 return wxControl::MSWShouldPreProcessMessage(pMsg
);
1180 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1182 switch ( event
.KeyCode() )
1185 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1187 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1188 InitCommandEvent(event
);
1189 event
.SetString(GetValue());
1190 if ( GetEventHandler()->ProcessEvent(event
) )
1193 //else: multiline controls need Enter for themselves
1198 // always produce navigation event - even if we process TAB
1199 // ourselves the fact that we got here means that the user code
1200 // decided to skip processing of this TAB - probably to let it
1201 // do its default job.
1203 wxNavigationKeyEvent eventNav
;
1204 eventNav
.SetDirection(!event
.ShiftDown());
1205 eventNav
.SetWindowChange(event
.ControlDown());
1206 eventNav
.SetEventObject(this);
1208 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1214 // no, we didn't process it
1218 long wxTextCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1220 if ( nMsg
== WM_GETDLGCODE
)
1222 // we always want the chars and the arrows
1223 long lDlgCode
= DLGC_WANTCHARS
| DLGC_WANTARROWS
;
1225 // we may have several different cases:
1226 // 1. normal case: both TAB and ENTER are used for dialog navigation
1227 // 2. ctrl which wants TAB for itself: ENTER is used to pass to the
1228 // next control in the dialog
1229 // 3. ctrl which wants ENTER for itself: TAB is used for dialog
1231 // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to pass
1232 // to the next control
1234 // the multiline edit control should always get <Return> for itself
1235 if ( HasFlag(wxTE_PROCESS_ENTER
) || HasFlag(wxTE_MULTILINE
) )
1236 lDlgCode
|= DLGC_WANTMESSAGE
;
1238 if ( HasFlag(wxTE_PROCESS_TAB
) )
1239 lDlgCode
|= DLGC_WANTTAB
;
1244 return wxTextCtrlBase::MSWWindowProc(nMsg
, wParam
, lParam
);
1247 void wxTextCtrl::SetFocus()
1249 wxTextCtrlBase::SetFocus();
1251 // to be consistent with the standard Windows behaviour we select all text
1252 // in the single line edit controls when the user TABs to them and also, to
1253 // be consistent with this behaviour in turn, do it whenever SetFocus() is
1255 if ( !HasFlag(wxTE_MULTILINE
) )
1257 SetSelection(-1, -1);
1261 // ----------------------------------------------------------------------------
1262 // text control event processing
1263 // ----------------------------------------------------------------------------
1265 bool wxTextCtrl::MSWCommand(WXUINT param
, WXWORD
WXUNUSED(id
))
1272 wxFocusEvent
event(param
== EN_KILLFOCUS
? wxEVT_KILL_FOCUS
1275 event
.SetEventObject( this );
1276 GetEventHandler()->ProcessEvent(event
);
1282 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
1283 InitCommandEvent(event
);
1284 event
.SetString(GetValue());
1285 ProcessCommand(event
);
1290 // the text size limit has been hit - increase it
1291 if ( !AdjustSpaceLimit() )
1293 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, m_windowId
);
1294 InitCommandEvent(event
);
1295 event
.SetString(GetValue());
1296 ProcessCommand(event
);
1300 // the other notification messages are not processed
1314 WXHBRUSH
wxTextCtrl::OnCtlColor(WXHDC pDC
, WXHWND
WXUNUSED(pWnd
), WXUINT
WXUNUSED(nCtlColor
),
1320 WXUINT
WXUNUSED(message
),
1321 WXWPARAM
WXUNUSED(wParam
),
1322 WXLPARAM
WXUNUSED(lParam
)
1329 HBRUSH hbrush
= Ctl3dCtlColorEx(message
, wParam
, lParam
);
1330 return (WXHBRUSH
) hbrush
;
1332 #endif // wxUSE_CTL3D
1335 if (GetParent()->GetTransparentBackground())
1336 SetBkMode(hdc
, TRANSPARENT
);
1338 SetBkMode(hdc
, OPAQUE
);
1340 wxColour colBack
= GetBackgroundColour();
1342 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE
) == 0)
1343 colBack
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
1345 ::SetBkColor(hdc
, wxColourToRGB(colBack
));
1346 ::SetTextColor(hdc
, wxColourToRGB(GetForegroundColour()));
1348 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(colBack
, wxSOLID
);
1350 return (WXHBRUSH
)brush
->GetResourceHandle();
1353 // In WIN16, need to override normal erasing because
1354 // Ctl3D doesn't use the wxWindows background colour.
1356 void wxTextCtrl::OnEraseBackground(wxEraseEvent
& event
)
1358 wxColour
col(m_backgroundColour
);
1362 col
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1366 ::GetClientRect(GetHwnd(), &rect
);
1368 COLORREF ref
= wxColourToRGB(col
);
1369 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
1371 wxLogLastError(wxT("CreateSolidBrush"));
1373 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
1375 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
1377 ::FillRect(hdc
, &rect
, hBrush
);
1378 ::DeleteObject(hBrush
);
1379 ::SetMapMode(hdc
, mode
);
1384 bool wxTextCtrl::AdjustSpaceLimit()
1387 unsigned int limit
= ::SendMessage(GetHwnd(), EM_GETLIMITTEXT
, 0, 0);
1389 // HACK: we try to automatically extend the limit for the amount of text
1390 // to allow (interactively) entering more than 64Kb of text under
1391 // Win9x but we shouldn't reset the text limit which was previously
1392 // set explicitly with SetMaxLength()
1394 // we could solve this by storing the limit we set in wxTextCtrl but
1395 // to save space we prefer to simply test here the actual limit
1396 // value: we consider that SetMaxLength() can only be called for
1398 if ( limit
< 0x8000 )
1400 // we've got more text than limit set by SetMaxLength()
1404 unsigned int len
= ::GetWindowTextLength(GetHwnd());
1407 limit
= len
+ 0x8000; // 32Kb
1412 // as a nice side effect, this also allows passing limit > 64Kb
1413 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT
, 0, limit
);
1416 #endif // wxUSE_RICHEDIT
1418 if ( limit
> 0xffff )
1420 // this will set it to a platform-dependent maximum (much more
1421 // than 64Kb under NT)
1425 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, limit
, 0);
1430 // we changed the limit
1434 bool wxTextCtrl::AcceptsFocus() const
1436 // we don't want focus if we can't be edited
1437 return IsEditable() && wxControl::AcceptsFocus();
1440 wxSize
wxTextCtrl::DoGetBestSize() const
1443 wxGetCharSize(GetHWND(), &cx
, &cy
, &GetFont());
1445 int wText
= DEFAULT_ITEM_WIDTH
;
1447 int hText
= EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy
);
1448 if ( m_windowStyle
& wxTE_MULTILINE
)
1450 hText
*= wxMax(GetNumberOfLines(), 5);
1452 //else: for single line control everything is ok
1454 return wxSize(wText
, hText
);
1457 // ----------------------------------------------------------------------------
1458 // standard handlers for standard edit menu events
1459 // ----------------------------------------------------------------------------
1461 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1466 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1471 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1476 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1481 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1486 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1488 event
.Enable( CanCut() );
1491 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1493 event
.Enable( CanCopy() );
1496 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1498 event
.Enable( CanPaste() );
1501 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1503 event
.Enable( CanUndo() );
1506 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1508 event
.Enable( CanRedo() );
1511 // the rest of the file only deals with the rich edit controls
1514 // ----------------------------------------------------------------------------
1515 // EN_LINK processing
1516 // ----------------------------------------------------------------------------
1518 bool wxTextCtrl::MSWOnNotify(int WXUNUSED(idCtrl
), WXLPARAM lParam
, WXLPARAM
*result
)
1520 NMHDR
*hdr
= (NMHDR
* )lParam
;
1521 if ( hdr
->code
== EN_LINK
)
1523 ENLINK
*enlink
= (ENLINK
*)hdr
;
1525 switch ( enlink
->msg
)
1528 // ok, so it is hardcoded - do we really nee to customize it?
1529 ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND
)));
1533 case WM_LBUTTONDOWN
:
1535 case WM_LBUTTONDBLCLK
:
1536 case WM_RBUTTONDOWN
:
1538 case WM_RBUTTONDBLCLK
:
1539 // send a mouse event
1541 static const wxEventType eventsMouse
[] =
1552 // the event ids are consecutive
1554 evtMouse(eventsMouse
[enlink
->msg
- WM_MOUSEMOVE
]);
1556 InitMouseEvent(evtMouse
,
1557 GET_X_LPARAM(enlink
->lParam
),
1558 GET_Y_LPARAM(enlink
->lParam
),
1561 wxTextUrlEvent
event(m_windowId
, evtMouse
,
1563 enlink
->chrg
.cpMax
);
1565 InitCommandEvent(event
);
1567 *result
= ProcessCommand(event
);
1579 // ----------------------------------------------------------------------------
1580 // colour setting for the rich edit controls
1581 // ----------------------------------------------------------------------------
1583 bool wxTextCtrl::SetBackgroundColour(const wxColour
& colour
)
1585 if ( !wxTextCtrlBase::SetBackgroundColour(colour
) )
1587 // colour didn't really change
1593 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
1594 // EM_SETBKGNDCOLOR additionally
1595 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR
, 0, wxColourToRGB(colour
));
1601 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1603 if ( !wxTextCtrlBase::SetForegroundColour(colour
) )
1605 // colour didn't really change
1611 // change the colour of everything
1614 cf
.cbSize
= sizeof(cf
);
1615 cf
.dwMask
= CFM_COLOR
;
1616 cf
.crTextColor
= wxColourToRGB(colour
);
1617 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
, SCF_ALL
, (LPARAM
)&cf
);
1623 // ----------------------------------------------------------------------------
1624 // styling support for rich edit controls
1625 // ----------------------------------------------------------------------------
1627 bool wxTextCtrl::SetStyle(long start
, long end
, const wxTextAttr
& style
)
1631 // can't do it with normal text control
1635 // the richedit 1.0 doesn't handle setting background colour, so don't
1636 // even try to do anything if it's the only thing we want to change
1637 if ( m_verRichEdit
== 1 && !style
.HasFont() && !style
.HasTextColour() )
1639 // nothing to do: return TRUE if there was really nothing to do and
1640 // FALSE if we failed to set bg colour
1641 return !style
.HasBackgroundColour();
1644 // order the range if needed
1652 // we can only change the format of the selection, so select the range we
1653 // want and restore the old selection later
1654 long startOld
, endOld
;
1655 GetSelection(&startOld
, &endOld
);
1657 // but do we really have to change the selection?
1658 bool changeSel
= start
!= startOld
|| end
!= endOld
;
1662 DoSetSelection(start
, end
, FALSE
/* don't scroll caret into view */);
1665 // initialize CHARFORMAT struct
1674 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
1675 // CHARFORMAT in that case
1677 if ( m_verRichEdit
== 1 )
1679 // this is the only thing the control is going to grok
1680 cf
.cbSize
= sizeof(CHARFORMAT
);
1685 // CHARFORMAT or CHARFORMAT2
1686 cf
.cbSize
= sizeof(cf
);
1689 if ( style
.HasFont() )
1691 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
1692 // but using it doesn't seem to hurt neither so leaving it for now
1694 cf
.dwMask
|= CFM_FACE
| CFM_SIZE
| CFM_CHARSET
|
1695 CFM_ITALIC
| CFM_BOLD
| CFM_UNDERLINE
;
1697 // fill in data from LOGFONT but recalculate lfHeight because we need
1698 // the real height in twips and not the negative number which
1699 // wxFillLogFont() returns (this is correct in general and works with
1700 // the Windows font mapper, but not here)
1702 wxFillLogFont(&lf
, &style
.GetFont());
1703 cf
.yHeight
= 20*style
.GetFont().GetPointSize(); // 1 pt = 20 twips
1704 cf
.bCharSet
= lf
.lfCharSet
;
1705 cf
.bPitchAndFamily
= lf
.lfPitchAndFamily
;
1706 wxStrncpy( cf
.szFaceName
, lf
.lfFaceName
, WXSIZEOF(cf
.szFaceName
) );
1708 // also deal with underline/italic/bold attributes: note that we must
1709 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
1710 // style to allow clearing it
1713 cf
.dwEffects
|= CFE_ITALIC
;
1716 if ( lf
.lfWeight
== FW_BOLD
)
1718 cf
.dwEffects
|= CFE_BOLD
;
1721 if ( lf
.lfUnderline
)
1723 cf
.dwEffects
|= CFE_UNDERLINE
;
1726 // strikeout fonts are not supported by wxWindows
1729 if ( style
.HasTextColour() )
1731 cf
.dwMask
|= CFM_COLOR
;
1732 cf
.crTextColor
= wxColourToRGB(style
.GetTextColour());
1736 if ( m_verRichEdit
!= 1 && style
.HasBackgroundColour() )
1738 cf
.dwMask
|= CFM_BACKCOLOR
;
1739 cf
.crBackColor
= wxColourToRGB(style
.GetBackgroundColour());
1741 #endif // wxUSE_RICHEDIT2
1743 // do format the selection
1744 bool ok
= ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
,
1745 SCF_SELECTION
, (LPARAM
)&cf
) != 0;
1748 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
1753 // restore the original selection
1754 DoSetSelection(startOld
, endOld
, FALSE
);
1760 // ----------------------------------------------------------------------------
1762 // ----------------------------------------------------------------------------
1764 bool wxRichEditModule::OnInit()
1766 // don't do anything - we will load it when needed
1770 void wxRichEditModule::OnExit()
1772 for ( size_t i
= 0; i
< WXSIZEOF(ms_hRichEdit
); i
++ )
1774 if ( ms_hRichEdit
[i
] )
1776 ::FreeLibrary(ms_hRichEdit
[i
]);
1782 bool wxRichEditModule::Load(int version
)
1784 // we don't support loading richedit 3.0 as I don't know how to distinguish
1785 // it from 2.0 anyhow
1786 wxCHECK_MSG( version
== 1 || version
== 2, FALSE
,
1787 _T("incorrect richedit control version requested") );
1789 // make it the index in the array
1792 if ( ms_hRichEdit
[version
] == (HINSTANCE
)-1 )
1794 // we had already tried to load it and failed
1798 if ( ms_hRichEdit
[version
] )
1800 // we've already got this one
1804 wxString dllname
= version
? _T("riched20") : _T("riched32");
1805 dllname
+= _T(".dll");
1807 ms_hRichEdit
[version
] = ::LoadLibrary(dllname
);
1809 if ( !ms_hRichEdit
[version
] )
1811 wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname
.c_str());
1813 ms_hRichEdit
[version
] = (HINSTANCE
)-1;
1821 #endif // wxUSE_RICHEDIT
1823 #endif // wxUSE_TEXTCTRL