1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/textctrl.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
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"
44 #include "wx/module.h"
47 #include "wx/clipbrd.h"
50 #include "wx/textfile.h"
54 #include "wx/msw/private.h"
55 #include "wx/msw/winundef.h"
61 #include <sys/types.h>
66 // old mingw32 has richedit stuff directly in windows.h and doesn't have
68 #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
72 #include "wx/msw/missing.h"
74 #endif // wxUSE_RICHEDIT
76 // ----------------------------------------------------------------------------
78 // ----------------------------------------------------------------------------
82 // this module initializes RichEdit DLL(s) if needed
83 class wxRichEditModule
: public wxModule
86 virtual bool OnInit();
87 virtual void OnExit();
89 // load the richedit DLL of at least of required version
90 static bool Load(int version
= 1);
93 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
94 static HINSTANCE ms_hRichEdit
[2];
96 DECLARE_DYNAMIC_CLASS(wxRichEditModule
)
99 HINSTANCE wxRichEditModule
::ms_hRichEdit
[2] = { NULL
, NULL
};
101 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule
, wxModule
)
103 #endif // wxUSE_RICHEDIT
105 // ----------------------------------------------------------------------------
106 // event tables and other macros
107 // ----------------------------------------------------------------------------
109 #if wxUSE_EXTENDED_RTTI
110 WX_DEFINE_FLAGS( wxTextCtrlStyle
)
112 wxBEGIN_FLAGS( wxTextCtrlStyle
)
113 // new style border flags, we put them first to
114 // use them for streaming out
115 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
116 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
117 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
118 wxFLAGS_MEMBER(wxBORDER_RAISED
)
119 wxFLAGS_MEMBER(wxBORDER_STATIC
)
120 wxFLAGS_MEMBER(wxBORDER_NONE
)
122 // old style border flags
123 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
124 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
125 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
126 wxFLAGS_MEMBER(wxRAISED_BORDER
)
127 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
128 wxFLAGS_MEMBER(wxNO_BORDER
)
130 // standard window styles
131 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
132 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
133 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
134 wxFLAGS_MEMBER(wxWANTS_CHARS
)
135 wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE
)
136 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
137 wxFLAGS_MEMBER(wxVSCROLL
)
138 wxFLAGS_MEMBER(wxHSCROLL
)
140 wxFLAGS_MEMBER(wxTE_PROCESS_ENTER
)
141 wxFLAGS_MEMBER(wxTE_PROCESS_TAB
)
142 wxFLAGS_MEMBER(wxTE_MULTILINE
)
143 wxFLAGS_MEMBER(wxTE_PASSWORD
)
144 wxFLAGS_MEMBER(wxTE_READONLY
)
145 wxFLAGS_MEMBER(wxHSCROLL
)
146 wxFLAGS_MEMBER(wxTE_RICH
)
147 wxFLAGS_MEMBER(wxTE_RICH2
)
148 wxFLAGS_MEMBER(wxTE_AUTO_URL
)
149 wxFLAGS_MEMBER(wxTE_NOHIDESEL
)
150 wxFLAGS_MEMBER(wxTE_LEFT
)
151 wxFLAGS_MEMBER(wxTE_CENTRE
)
152 wxFLAGS_MEMBER(wxTE_RIGHT
)
153 wxFLAGS_MEMBER(wxTE_DONTWRAP
)
154 wxFLAGS_MEMBER(wxTE_LINEWRAP
)
155 wxFLAGS_MEMBER(wxTE_WORDWRAP
)
157 wxEND_FLAGS( wxTextCtrlStyle
)
159 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTextCtrl
, wxControl
,"wx/textctrl.h")
161 wxBEGIN_PROPERTIES_TABLE(wxTextCtrl
)
162 wxEVENT_PROPERTY( TextUpdated
, wxEVT_COMMAND_TEXT_UPDATED
, wxCommandEvent
)
163 wxEVENT_PROPERTY( TextEnter
, wxEVT_COMMAND_TEXT_ENTER
, wxCommandEvent
)
165 wxPROPERTY( Font
, wxFont
, SetFont
, GetFont
,, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
166 wxPROPERTY( Value
, wxString
, SetValue
, GetValue
, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
167 wxPROPERTY_FLAGS( WindowStyle
, wxTextCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
168 wxEND_PROPERTIES_TABLE()
170 wxBEGIN_HANDLERS_TABLE(wxTextCtrl
)
171 wxEND_HANDLERS_TABLE()
173 wxCONSTRUCTOR_6( wxTextCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxString
, Value
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
175 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
179 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
180 EVT_CHAR(wxTextCtrl
::OnChar
)
181 EVT_DROP_FILES(wxTextCtrl
::OnDropFiles
)
184 EVT_RIGHT_UP(wxTextCtrl
::OnRightClick
)
187 EVT_MENU(wxID_CUT
, wxTextCtrl
::OnCut
)
188 EVT_MENU(wxID_COPY
, wxTextCtrl
::OnCopy
)
189 EVT_MENU(wxID_PASTE
, wxTextCtrl
::OnPaste
)
190 EVT_MENU(wxID_UNDO
, wxTextCtrl
::OnUndo
)
191 EVT_MENU(wxID_REDO
, wxTextCtrl
::OnRedo
)
192 EVT_MENU(wxID_CLEAR
, wxTextCtrl
::OnDelete
)
193 EVT_MENU(wxID_SELECTALL
, wxTextCtrl
::OnSelectAll
)
195 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl
::OnUpdateCut
)
196 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl
::OnUpdateCopy
)
197 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl
::OnUpdatePaste
)
198 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl
::OnUpdateUndo
)
199 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl
::OnUpdateRedo
)
200 EVT_UPDATE_UI(wxID_CLEAR
, wxTextCtrl
::OnUpdateDelete
)
201 EVT_UPDATE_UI(wxID_SELECTALL
, wxTextCtrl
::OnUpdateSelectAll
)
203 EVT_ERASE_BACKGROUND(wxTextCtrl
::OnEraseBackground
)
206 EVT_SET_FOCUS(wxTextCtrl
::OnSetFocus
)
209 // ============================================================================
211 // ============================================================================
213 // ----------------------------------------------------------------------------
215 // ----------------------------------------------------------------------------
217 void wxTextCtrl
::Init()
221 #endif // wxUSE_RICHEDIT
223 m_privateContextMenu
= NULL
;
224 m_suppressNextUpdate
= FALSE
;
225 m_isNativeCaretShown
= true;
228 wxTextCtrl
::~wxTextCtrl()
230 if (m_privateContextMenu
)
232 delete m_privateContextMenu
;
233 m_privateContextMenu
= NULL
;
237 bool wxTextCtrl
::Create(wxWindow
*parent
, wxWindowID id
,
238 const wxString
& value
,
242 const wxValidator
& validator
,
243 const wxString
& name
)
245 // base initialization
246 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
250 parent
->AddChild(this);
252 // translate wxWin style flags to MSW ones
253 WXDWORD msStyle
= MSWGetCreateWindowFlags();
255 // do create the control - either an EDIT or RICHEDIT
256 wxString windowClass
= wxT("EDIT");
259 if ( m_windowStyle
& wxTE_AUTO_URL
)
261 // automatic URL detection only works in RichEdit 2.0+
262 m_windowStyle
|= wxTE_RICH2
;
265 if ( m_windowStyle
& wxTE_RICH2
)
267 // using richedit 2.0 implies using wxTE_RICH
268 m_windowStyle
|= wxTE_RICH
;
271 // we need to load the richedit DLL before creating the rich edit control
272 if ( m_windowStyle
& wxTE_RICH
)
274 static bool s_errorGiven
= FALSE
;// MT-FIXME
276 // Which version do we need? Use 1.0 by default because it is much more
277 // like the the standard EDIT or 2.0 if explicitly requested, but use
278 // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
280 // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
281 // (and thus EDIT) much better than RichEdit 2.0 so we probably
282 // should use 3.0 if available as it is the best of both worlds -
283 // but as I can't test it right now I don't do it (VZ)
285 const int verRichEdit
= 2;
286 #else // !wxUSE_UNICODE
287 int verRichEdit
= m_windowStyle
& wxTE_RICH2 ?
2 : 1;
288 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
290 // only give the error msg once if the DLL can't be loaded
293 // try to load the RichEdit DLL (will do nothing if already done)
294 if ( !wxRichEditModule
::Load(verRichEdit
) )
297 // try another version?
298 verRichEdit
= 3 - verRichEdit
; // 1 <-> 2
300 if ( !wxRichEditModule
::Load(verRichEdit
) )
301 #endif // wxUSE_UNICODE
303 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
310 // have we managed to load any richedit version?
313 m_verRichEdit
= verRichEdit
;
314 if ( m_verRichEdit
== 1 )
316 windowClass
= wxT("RICHEDIT");
320 #ifndef RICHEDIT_CLASS
321 wxString RICHEDIT_CLASS
;
322 RICHEDIT_CLASS
.Printf(_T("RichEdit%d0"), m_verRichEdit
);
324 RICHEDIT_CLASS
+= _T('W');
326 RICHEDIT_CLASS
+= _T('A');
327 #endif // Unicode/ANSI
328 #endif // !RICHEDIT_CLASS
330 windowClass
= RICHEDIT_CLASS
;
334 #endif // wxUSE_RICHEDIT
336 // we need to turn '\n's into "\r\n"s for the multiline controls
338 if ( m_windowStyle
& wxTE_MULTILINE
)
340 valueWin
= wxTextFile
::Translate(value
, wxTextFileType_Dos
);
347 if ( !MSWCreateControl(windowClass
, msStyle
, pos
, size
, valueWin
) )
350 SetBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
));
355 // enable the events we're interested in: we want to get EN_CHANGE as
356 // for the normal controls
357 LPARAM mask
= ENM_CHANGE
;
359 if ( GetRichVersion() == 1 )
361 // we also need EN_MSGFILTER for richedit 1.0 for the reasons
362 // explained in its handler
363 mask
|= ENM_MOUSEEVENTS
;
365 else if ( m_windowStyle
& wxTE_AUTO_URL
)
369 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT
, TRUE
, 0);
372 ::SendMessage(GetHwnd(), EM_SETEVENTMASK
, 0, mask
);
374 #endif // wxUSE_RICHEDIT
379 // Make sure the window style (etc.) reflects the HWND style (roughly)
380 void wxTextCtrl
::AdoptAttributesFromHWND()
382 wxWindow
::AdoptAttributesFromHWND();
384 HWND hWnd
= GetHwnd();
385 long style
= ::GetWindowLong(hWnd
, GWL_STYLE
);
387 // retrieve the style to see whether this is an edit or richedit ctrl
389 wxString classname
= wxGetWindowClass(GetHWND());
391 if ( classname
.IsSameAs(_T("EDIT"), FALSE
/* no case */) )
398 if ( wxSscanf(classname
, _T("RichEdit%d0%c"), &m_verRichEdit
, &c
) != 2 )
400 wxLogDebug(_T("Unknown edit control '%s'."), classname
.c_str());
405 #endif // wxUSE_RICHEDIT
407 if (style
& ES_MULTILINE
)
408 m_windowStyle
|= wxTE_MULTILINE
;
409 if (style
& ES_PASSWORD
)
410 m_windowStyle
|= wxTE_PASSWORD
;
411 if (style
& ES_READONLY
)
412 m_windowStyle
|= wxTE_READONLY
;
413 if (style
& ES_WANTRETURN
)
414 m_windowStyle
|= wxTE_PROCESS_ENTER
;
415 if (style
& ES_CENTER
)
416 m_windowStyle
|= wxTE_CENTRE
;
417 if (style
& ES_RIGHT
)
418 m_windowStyle
|= wxTE_RIGHT
;
421 WXDWORD wxTextCtrl
::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
423 long msStyle
= wxControl
::MSWGetStyle(style
, exstyle
);
425 // styles which we alaways add by default
426 if ( style
& wxTE_MULTILINE
)
428 wxASSERT_MSG( !(style
& wxTE_PROCESS_ENTER
),
429 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
431 msStyle
|= ES_MULTILINE
| ES_WANTRETURN
;
432 if ( !(style
& wxTE_NO_VSCROLL
) )
434 // always adjust the vertical scrollbar automatically if we have it
435 msStyle
|= WS_VSCROLL
| ES_AUTOVSCROLL
;
438 // we have to use this style for the rich edit controls because
439 // without it the vertical scrollbar never appears at all in
440 // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it)
441 if ( style
& wxTE_RICH2
)
443 msStyle
|= ES_DISABLENOSCROLL
;
445 #endif // wxUSE_RICHEDIT
448 style
|= wxTE_PROCESS_ENTER
;
452 // there is really no reason to not have this style for single line
454 msStyle
|= ES_AUTOHSCROLL
;
457 // note that wxTE_DONTWRAP is the same as wxHSCROLL so if we have a horz
458 // scrollbar, there is no wrapping -- which makes sense
459 if ( style
& wxTE_DONTWRAP
)
461 // automatically scroll the control horizontally as necessary
462 msStyle
|= WS_HSCROLL
;
465 if ( style
& wxTE_READONLY
)
466 msStyle
|= ES_READONLY
;
468 if ( style
& wxTE_PASSWORD
)
469 msStyle
|= ES_PASSWORD
;
471 if ( style
& wxTE_NOHIDESEL
)
472 msStyle
|= ES_NOHIDESEL
;
474 // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0
475 if ( style
& wxTE_CENTRE
)
476 msStyle
|= ES_CENTER
;
477 else if ( style
& wxTE_RIGHT
)
480 msStyle
|= ES_LEFT
; // ES_LEFT is 0 as well but for consistency...
485 void wxTextCtrl
::SetWindowStyleFlag(long style
)
488 // we have to deal with some styles separately because they can't be
489 // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
490 // using richedit-specific EM_SETOPTIONS
492 ((style
& wxTE_NOHIDESEL
) != (GetWindowStyle() & wxTE_NOHIDESEL
)) )
494 bool set
= (style
& wxTE_NOHIDESEL
) != 0;
496 ::SendMessage(GetHwnd(), EM_SETOPTIONS
, set ? ECOOP_OR
: ECOOP_AND
,
497 set ? ECO_NOHIDESEL
: ~ECO_NOHIDESEL
);
499 #endif // wxUSE_RICHEDIT
501 wxControl
::SetWindowStyleFlag(style
);
504 // ----------------------------------------------------------------------------
505 // set/get the controls text
506 // ----------------------------------------------------------------------------
508 wxString wxTextCtrl
::GetValue() const
510 // range 0..-1 is special for GetRange() and means to retrieve all text
511 return GetRange(0, -1);
514 wxString wxTextCtrl
::GetRange(long from
, long to
) const
518 if ( from
>= to
&& to
!= -1 )
520 // nothing to retrieve
527 int len
= GetWindowTextLength(GetHwnd());
533 // we must use EM_STREAMOUT if we don't want to lose all characters
534 // not representable in the current character set (EM_GETTEXTRANGE
535 // simply replaces them with question marks...)
537 // as EM_STREAMOUT only works for the entire controls contents (or
538 // just the selection but it's probably a bad idea to play games
539 // with selection here...), we can't use it unless we're called
540 // from GetValue(), i.e. we want to retrieve all text
541 if ( GetRichVersion() > 1 && (from
== 0 && to
>= len
) )
543 wxFont font
= m_defaultStyle
.GetFont();
549 wxFontEncoding encoding
= font
.GetEncoding();
550 if ( encoding
!= wxFONTENCODING_SYSTEM
)
552 str
= StreamOut(encoding
);
557 // StreamOut() wasn't used or failed, try to do it in normal way
560 // alloc one extra WORD as needed by the control
561 wxStringBuffer
tmp(str
, ++len
);
565 textRange
.chrg
.cpMin
= from
;
566 textRange
.chrg
.cpMax
= to
== -1 ? len
: to
;
567 textRange
.lpstrText
= p
;
569 (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE
,
570 0, (LPARAM
)&textRange
);
572 if ( m_verRichEdit
> 1 )
574 // RichEdit 2.0 uses just CR ('\r') for the
575 // newlines which is neither Unix nor Windows
576 // style - convert it to something reasonable
579 if ( *p
== _T('\r') )
585 if ( m_verRichEdit
== 1 )
587 // convert to the canonical form - see comment below
588 str
= wxTextFile
::Translate(str
, wxTextFileType_Unix
);
591 //else: no text at all, leave the string empty
594 #endif // wxUSE_RICHEDIT
597 str
= wxGetWindowText(GetHWND());
599 // need only a range?
602 str
= str
.Mid(from
, to
- from
);
605 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
606 // canonical one (same one as above) for consistency with the other kinds
607 // of controls and, more importantly, with the other ports
608 str
= wxTextFile
::Translate(str
, wxTextFileType_Unix
);
614 void wxTextCtrl
::SetValue(const wxString
& value
)
616 // if the text is long enough, it's faster to just set it instead of first
617 // comparing it with the old one (chances are that it will be different
618 // anyhow, this comparison is there to avoid flicker for small single-line
619 // edit controls mostly)
620 if ( (value
.length() > 0x400) || (value
!= GetValue()) )
622 DoWriteText(value
, FALSE
/* not selection only */);
626 // still send an event for consistency
630 // we should reset the modified flag even if the value didn't really change
632 // mark the control as being not dirty - we changed its text, not the
636 // for compatibility, don't move the cursor when doing SetValue()
637 SetInsertionPoint(0);
640 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
642 // TODO: using memcpy() would improve performance a lot for big amounts of text
645 wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
649 const wchar_t ** const ppws
= (const wchar_t **)dwCookie
;
651 wchar_t *wbuf
= (wchar_t *)buf
;
652 const wchar_t *wpc
= *ppws
;
657 cb
-= sizeof(wchar_t);
658 (*pcb
) += sizeof(wchar_t);
667 wxRichEditStreamOut(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
671 wchar_t ** const ppws
= (wchar_t **)dwCookie
;
673 const wchar_t *wbuf
= (const wchar_t *)buf
;
674 wchar_t *wpc
= *ppws
;
679 cb
-= sizeof(wchar_t);
680 (*pcb
) += sizeof(wchar_t);
689 #if wxUSE_UNICODE_MSLU
690 #define UNUSED_IF_MSLU(param)
692 #define UNUSED_IF_MSLU(param) param
696 wxTextCtrl
::StreamIn(const wxString
& value
,
697 wxFontEncoding
UNUSED_IF_MSLU(encoding
),
700 #if wxUSE_UNICODE_MSLU
701 const wchar_t *wpc
= value
.c_str();
702 #else // !wxUSE_UNICODE_MSLU
703 wxCSConv
conv(encoding
);
705 const size_t len
= conv
.MB2WC(NULL
, value
, value
.length());
708 wxWCharBuffer
wchBuf(len
);
709 wchar_t *wpc
= wchBuf
.data();
711 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
712 wchar_t *wpc
= wchBuf
;
715 conv
.MB2WC(wpc
, value
, value
.length());
716 #endif // wxUSE_UNICODE_MSLU
718 // finally, stream it in the control
721 eds
.dwCookie
= (DWORD
)&wpc
;
722 // the cast below is needed for broken (very) old mingw32 headers
723 eds
.pfnCallback
= (EDITSTREAMCALLBACK
)wxRichEditStreamIn
;
725 // we're going to receive 2 EN_CHANGE notifications if we got any selection
726 // (same problem as in DoWriteText())
727 if ( selectionOnly
&& HasSelection() )
729 // so suppress one of them
730 m_suppressNextUpdate
= TRUE
;
733 ::SendMessage(GetHwnd(), EM_STREAMIN
,
736 (selectionOnly ? SFF_SELECTION
: 0),
741 wxLogLastError(_T("EM_STREAMIN"));
746 #endif // !wxUSE_WCHAR_T
751 #if !wxUSE_UNICODE_MSLU
754 wxTextCtrl
::StreamOut(wxFontEncoding encoding
, bool selectionOnly
) const
758 const int len
= GetWindowTextLength(GetHwnd());
761 wxWCharBuffer
wchBuf(len
);
762 wchar_t *wpc
= wchBuf
.data();
764 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
765 wchar_t *wpc
= wchBuf
;
770 eds
.dwCookie
= (DWORD
)&wpc
;
771 eds
.pfnCallback
= wxRichEditStreamOut
;
777 SF_TEXT
| SF_UNICODE
| (selectionOnly ? SFF_SELECTION
: 0),
783 wxLogLastError(_T("EM_STREAMOUT"));
785 else // streamed out ok
787 // now convert to the given encoding (this is a lossful conversion but
788 // what else can we do)
789 wxCSConv
conv(encoding
);
790 size_t lenNeeded
= conv
.WC2MB(NULL
, wchBuf
, len
);
793 conv
.WC2MB(wxStringBuffer(out
, lenNeeded
), wchBuf
, len
);
799 #endif // !wxUSE_WCHAR_T
804 #endif // !wxUSE_UNICODE_MSLU
806 #endif // wxUSE_RICHEDIT
808 void wxTextCtrl
::WriteText(const wxString
& value
)
813 void wxTextCtrl
::DoWriteText(const wxString
& value
, bool selectionOnly
)
816 if ( m_windowStyle
& wxTE_MULTILINE
)
817 valueDos
= wxTextFile
::Translate(value
, wxTextFileType_Dos
);
822 // there are several complications with the rich edit controls here
826 // first, ensure that the new text will be in the default style
827 if ( !m_defaultStyle
.IsDefault() )
830 GetSelection(&start
, &end
);
831 SetStyle(start
, end
, m_defaultStyle
);
834 #if wxUSE_UNICODE_MSLU
835 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
836 // but EM_STREAMIN works
837 if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
839 done
= StreamIn(valueDos
, wxFONTENCODING_SYSTEM
, selectionOnly
);
841 #endif // wxUSE_UNICODE_MSLU
844 // next check if the text we're inserting must be shown in a non
845 // default charset -- this only works for RichEdit > 1.0
846 if ( GetRichVersion() > 1 )
848 wxFont font
= m_defaultStyle
.GetFont();
854 wxFontEncoding encoding
= font
.GetEncoding();
855 if ( encoding
!= wxFONTENCODING_SYSTEM
)
857 // we have to use EM_STREAMIN to force richedit control 2.0+
858 // to show any text in the non default charset -- otherwise
859 // it thinks it knows better than we do and always shows it
860 // in the default one
861 done
= StreamIn(valueDos
, encoding
, selectionOnly
);
865 #endif // !wxUSE_UNICODE
869 #endif // wxUSE_RICHEDIT
871 // in some cases we get 2 EN_CHANGE notifications after the SendMessage
872 // call below which is confusing for the client code and so should be
875 // these cases are: (a) plain EDIT controls if EM_REPLACESEL is used
876 // and there is a non empty selection currently and (b) rich text
877 // controls in any case
881 #endif // wxUSE_RICHEDIT
882 (selectionOnly
&& HasSelection()) )
884 m_suppressNextUpdate
= TRUE
;
887 ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL
: WM_SETTEXT
,
888 0, (LPARAM
)valueDos
.c_str());
890 // OTOH, non rich text controls don't generate any events at all when
891 // we use WM_SETTEXT -- have to emulate them here
895 #endif // wxUSE_RICHEDIT
898 // Windows already sends an update event for single-line
900 if ( m_windowStyle
& wxTE_MULTILINE
)
908 void wxTextCtrl
::AppendText(const wxString
& text
)
910 SetInsertionPointEnd();
915 if ( IsMultiLine() && GetRichVersion() > 1 )
917 // setting the caret to the end and showing it simply doesn't work for
918 // RichEdit 2.0 -- force it to still do what we want
919 ::SendMessage(GetHwnd(), EM_LINESCROLL
, 0, GetNumberOfLines());
921 #endif // wxUSE_RICHEDIT
924 void wxTextCtrl
::Clear()
926 ::SetWindowText(GetHwnd(), wxEmptyString
);
930 #endif // wxUSE_RICHEDIT
932 // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves
933 // but the normal ones don't -- make Clear() behaviour consistent by
934 // always sending this event
936 // Windows already sends an update event for single-line
938 if ( m_windowStyle
& wxTE_MULTILINE
)
945 bool wxTextCtrl
::EmulateKeyPress(const wxKeyEvent
& event
)
949 size_t lenOld
= GetValue().length();
951 wxUint32 code
= event
.GetRawKeyCode();
952 ::keybd_event(code
, 0, 0 /* key press */, 0);
953 ::keybd_event(code
, 0, KEYEVENTF_KEYUP
, 0);
955 // assume that any alphanumeric key changes the total number of characters
956 // in the control - this should work in 99% of cases
957 return GetValue().length() != lenOld
;
962 // ----------------------------------------------------------------------------
963 // Clipboard operations
964 // ----------------------------------------------------------------------------
966 void wxTextCtrl
::Copy()
970 ::SendMessage(GetHwnd(), WM_COPY
, 0, 0L);
974 void wxTextCtrl
::Cut()
978 ::SendMessage(GetHwnd(), WM_CUT
, 0, 0L);
982 void wxTextCtrl
::Paste()
986 ::SendMessage(GetHwnd(), WM_PASTE
, 0, 0L);
990 bool wxTextCtrl
::HasSelection() const
993 GetSelection(&from
, &to
);
997 bool wxTextCtrl
::CanCopy() const
999 // Can copy if there's a selection
1000 return HasSelection();
1003 bool wxTextCtrl
::CanCut() const
1005 return CanCopy() && IsEditable();
1008 bool wxTextCtrl
::CanPaste() const
1010 if ( !IsEditable() )
1016 UINT cf
= 0; // 0 == any format
1018 return ::SendMessage(GetHwnd(), EM_CANPASTE
, cf
, 0) != 0;
1020 #endif // wxUSE_RICHEDIT
1022 // Standard edit control: check for straight text on clipboard
1023 if ( !::OpenClipboard(GetHwndOf(wxTheApp
->GetTopWindow())) )
1026 bool isTextAvailable
= ::IsClipboardFormatAvailable(CF_TEXT
) != 0;
1029 return isTextAvailable
;
1032 // ----------------------------------------------------------------------------
1034 // ----------------------------------------------------------------------------
1036 void wxTextCtrl
::SetEditable(bool editable
)
1038 HWND hWnd
= GetHwnd();
1039 SendMessage(hWnd
, EM_SETREADONLY
, (WPARAM
)!editable
, (LPARAM
)0L);
1042 void wxTextCtrl
::SetInsertionPoint(long pos
)
1044 DoSetSelection(pos
, pos
);
1047 void wxTextCtrl
::SetInsertionPointEnd()
1049 // we must not do anything if the caret is already there because calling
1050 // SetInsertionPoint() thaws the controls if Freeze() had been called even
1051 // if it doesn't actually move the caret anywhere and so the simple fact of
1052 // doing it results in horrible flicker when appending big amounts of text
1053 // to the control in a few chunks (see DoAddText() test in the text sample)
1054 if ( GetInsertionPoint() == GetLastPosition() )
1060 if ( m_verRichEdit
== 1 )
1062 // we don't have to waste time calling GetLastPosition() in this case
1065 else // !RichEdit 1.0
1066 #endif // wxUSE_RICHEDIT
1068 pos
= GetLastPosition();
1071 SetInsertionPoint(pos
);
1074 long wxTextCtrl
::GetInsertionPoint() const
1082 SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &range
);
1085 #endif // wxUSE_RICHEDIT
1087 DWORD Pos
= (DWORD
)SendMessage(GetHwnd(), EM_GETSEL
, 0, 0L);
1088 return Pos
& 0xFFFF;
1091 long wxTextCtrl
::GetLastPosition() const
1093 int numLines
= GetNumberOfLines();
1094 long posStartLastLine
= XYToPosition(0, numLines
- 1);
1096 long lenLastLine
= GetLengthOfLineContainingPos(posStartLastLine
);
1098 return posStartLastLine
+ lenLastLine
;
1101 // If the return values from and to are the same, there is no
1103 void wxTextCtrl
::GetSelection(long* from
, long* to
) const
1108 CHARRANGE charRange
;
1109 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &charRange
);
1111 *from
= charRange
.cpMin
;
1112 *to
= charRange
.cpMax
;
1115 #endif // !wxUSE_RICHEDIT
1117 DWORD dwStart
, dwEnd
;
1118 ::SendMessage(GetHwnd(), EM_GETSEL
, (WPARAM
)&dwStart
, (LPARAM
)&dwEnd
);
1125 bool wxTextCtrl
::IsEditable() const
1127 // strangely enough, we may be called before the control is created: our
1128 // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls
1133 long style
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1135 return (style
& ES_READONLY
) == 0;
1138 // ----------------------------------------------------------------------------
1140 // ----------------------------------------------------------------------------
1142 void wxTextCtrl
::SetSelection(long from
, long to
)
1144 // if from and to are both -1, it means (in wxWindows) that all text should
1145 // be selected - translate into Windows convention
1146 if ( (from
== -1) && (to
== -1) )
1152 DoSetSelection(from
, to
);
1155 void wxTextCtrl
::DoSetSelection(long from
, long to
, bool scrollCaret
)
1157 HWND hWnd
= GetHwnd();
1166 SendMessage(hWnd
, EM_EXSETSEL
, 0, (LPARAM
) &range
);
1169 #endif // wxUSE_RICHEDIT
1171 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)from
, (LPARAM
)to
);
1177 // richedit 3.0 (i.e. the version living in riched20.dll distributed
1178 // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when
1179 // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL
1180 // option is set (but it does work ok in richedit 1.0 mode...)
1182 // so to make it work we either need to give focus to it here which
1183 // will probably create many problems (dummy focus events; window
1184 // containing the text control being brought to foreground
1185 // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may
1186 // create other problems too -- and in fact it does because if we turn
1187 // on/off this style while appending the text to the control, the
1188 // vertical scrollbar never appears in it even if we append tons of
1189 // text and to work around this the only solution I found was to use
1190 // ES_DISABLENOSCROLL
1192 // this is very ugly but I don't see any other way to make this work
1193 if ( GetRichVersion() > 1 )
1195 if ( !HasFlag(wxTE_NOHIDESEL
) )
1197 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1198 ECOOP_OR
, ECO_NOHIDESEL
);
1200 //else: everything is already ok
1202 #endif // wxUSE_RICHEDIT
1204 SendMessage(hWnd
, EM_SCROLLCARET
, (WPARAM
)0, (LPARAM
)0);
1207 // restore ECO_NOHIDESEL if we changed it
1208 if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL
) )
1210 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1211 ECOOP_AND
, ~ECO_NOHIDESEL
);
1213 #endif // wxUSE_RICHEDIT
1216 // WPARAM is 0: selection is scrolled into view
1217 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)0, (LPARAM
)MAKELONG(from
, to
));
1221 // ----------------------------------------------------------------------------
1223 // ----------------------------------------------------------------------------
1225 void wxTextCtrl
::Replace(long from
, long to
, const wxString
& value
)
1227 // Set selection and remove it
1228 DoSetSelection(from
, to
, FALSE
/* don't scroll caret into view */);
1230 SendMessage(GetHwnd(), EM_REPLACESEL
,
1236 (LPARAM
)value
.c_str());
1239 void wxTextCtrl
::Remove(long from
, long to
)
1241 Replace(from
, to
, wxEmptyString
);
1244 bool wxTextCtrl
::LoadFile(const wxString
& file
)
1246 if ( wxTextCtrlBase
::LoadFile(file
) )
1248 // update the size limit if needed
1257 bool wxTextCtrl
::IsModified() const
1259 return SendMessage(GetHwnd(), EM_GETMODIFY
, 0, 0) != 0;
1262 // Makes 'unmodified'
1263 void wxTextCtrl
::DiscardEdits()
1265 SendMessage(GetHwnd(), EM_SETMODIFY
, FALSE
, 0L);
1268 int wxTextCtrl
::GetNumberOfLines() const
1270 return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT
, (WPARAM
)0, (LPARAM
)0);
1273 long wxTextCtrl
::XYToPosition(long x
, long y
) const
1275 // This gets the char index for the _beginning_ of this line
1276 long charIndex
= SendMessage(GetHwnd(), EM_LINEINDEX
, (WPARAM
)y
, (LPARAM
)0);
1278 return charIndex
+ x
;
1281 bool wxTextCtrl
::PositionToXY(long pos
, long *x
, long *y
) const
1283 HWND hWnd
= GetHwnd();
1285 // This gets the line number containing the character
1290 lineNo
= SendMessage(hWnd
, EM_EXLINEFROMCHAR
, 0, (LPARAM
)pos
);
1293 #endif // wxUSE_RICHEDIT
1295 lineNo
= SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, 0);
1304 // This gets the char index for the _beginning_ of this line
1305 long charIndex
= SendMessage(hWnd
, EM_LINEINDEX
, (WPARAM
)lineNo
, (LPARAM
)0);
1306 if ( charIndex
== -1 )
1311 // The X position must therefore be the different between pos and charIndex
1313 *x
= pos
- charIndex
;
1320 void wxTextCtrl
::ShowPosition(long pos
)
1322 HWND hWnd
= GetHwnd();
1324 // To scroll to a position, we pass the number of lines and characters
1325 // to scroll *by*. This means that we need to:
1326 // (1) Find the line position of the current line.
1327 // (2) Find the line position of pos.
1328 // (3) Scroll by (pos - current).
1329 // For now, ignore the horizontal scrolling.
1331 // Is this where scrolling is relative to - the line containing the caret?
1332 // Or is the first visible line??? Try first visible line.
1333 // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
1335 int currentLineLineNo
= (int)SendMessage(hWnd
, EM_GETFIRSTVISIBLELINE
, (WPARAM
)0, (LPARAM
)0L);
1337 int specifiedLineLineNo
= (int)SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, (LPARAM
)0L);
1339 int linesToScroll
= specifiedLineLineNo
- currentLineLineNo
;
1341 if (linesToScroll
!= 0)
1342 (void)SendMessage(hWnd
, EM_LINESCROLL
, (WPARAM
)0, (LPARAM
)linesToScroll
);
1345 long wxTextCtrl
::GetLengthOfLineContainingPos(long pos
) const
1347 return ::SendMessage(GetHwnd(), EM_LINELENGTH
, (WPARAM
)pos
, 0);
1350 int wxTextCtrl
::GetLineLength(long lineNo
) const
1352 long pos
= XYToPosition(0, lineNo
);
1354 return GetLengthOfLineContainingPos(pos
);
1357 wxString wxTextCtrl
::GetLineText(long lineNo
) const
1359 size_t len
= (size_t)GetLineLength(lineNo
) + 1;
1361 // there must be at least enough place for the length WORD in the
1363 len
+= sizeof(WORD
);
1367 wxStringBufferLength
tmp(str
, len
);
1370 *(WORD
*)buf
= (WORD
)len
;
1371 len
= (size_t)::SendMessage(GetHwnd(), EM_GETLINE
, lineNo
, (LPARAM
)buf
);
1376 // remove the '\r' returned by the rich edit control, the user code
1377 // should never see it
1378 if ( buf
[len
- 2] == _T('\r') && buf
[len
- 1] == _T('\n') )
1380 buf
[len
- 2] = _T('\n');
1384 #endif // wxUSE_RICHEDIT
1386 // remove the '\n' at the end, if any (this is how this function is
1387 // supposed to work according to the docs)
1388 if ( buf
[len
- 1] == _T('\n') )
1400 void wxTextCtrl
::SetMaxLength(unsigned long len
)
1402 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, len
, 0);
1405 // ----------------------------------------------------------------------------
1407 // ----------------------------------------------------------------------------
1409 void wxTextCtrl
::Undo()
1413 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1417 void wxTextCtrl
::Redo()
1421 // Same as Undo, since Undo undoes the undo, i.e. a redo.
1422 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1426 bool wxTextCtrl
::CanUndo() const
1428 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1431 bool wxTextCtrl
::CanRedo() const
1433 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1436 // ----------------------------------------------------------------------------
1437 // caret handling (Windows only)
1438 // ----------------------------------------------------------------------------
1440 bool wxTextCtrl
::ShowNativeCaret(bool show
)
1442 if ( show
!= m_isNativeCaretShown
)
1444 if ( !(show ?
::ShowCaret(GetHwnd()) : ::HideCaret(GetHwnd())) )
1446 // not an error, may simply indicate that it's not shown/hidden
1447 // yet (i.e. it had been hidden/showh 2 times before)
1451 m_isNativeCaretShown
= show
;
1457 // ----------------------------------------------------------------------------
1458 // implemenation details
1459 // ----------------------------------------------------------------------------
1461 void wxTextCtrl
::Command(wxCommandEvent
& event
)
1463 SetValue(event
.GetString());
1464 ProcessCommand (event
);
1467 void wxTextCtrl
::OnDropFiles(wxDropFilesEvent
& event
)
1469 // By default, load the first file into the text window.
1470 if (event
.GetNumberOfFiles() > 0)
1472 LoadFile(event
.GetFiles()[0]);
1476 // ----------------------------------------------------------------------------
1477 // kbd input processing
1478 // ----------------------------------------------------------------------------
1480 bool wxTextCtrl
::MSWShouldPreProcessMessage(WXMSG
* pMsg
)
1482 MSG
*msg
= (MSG
*)pMsg
;
1484 // check for our special keys here: if we don't do it and the parent frame
1485 // uses them as accelerators, they wouldn't work at all, so we disable
1486 // usual preprocessing for them
1487 if ( msg
->message
== WM_KEYDOWN
)
1489 WORD vkey
= (WORD
) msg
->wParam
;
1490 if ( (HIWORD(msg
->lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
1492 if ( vkey
== VK_BACK
)
1497 // we want to process some Ctrl-foo and Shift-bar but no key
1498 // combinations without either Ctrl or Shift nor with both of them
1500 const int ctrl
= wxIsCtrlDown(),
1501 shift
= wxIsShiftDown();
1502 switch ( ctrl
+ shift
)
1505 wxFAIL_MSG( _T("how many modifiers have we got?") );
1513 // either Ctrl or Shift pressed
1528 else // Shift is pressed
1530 if ( vkey
== VK_INSERT
|| vkey
== VK_DELETE
)
1537 return wxControl
::MSWShouldPreProcessMessage(pMsg
);
1540 void wxTextCtrl
::OnChar(wxKeyEvent
& event
)
1542 switch ( event
.GetKeyCode() )
1545 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1547 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1548 InitCommandEvent(event
);
1549 event
.SetString(GetValue());
1550 if ( GetEventHandler()->ProcessEvent(event
) )
1553 //else: multiline controls need Enter for themselves
1558 // always produce navigation event - even if we process TAB
1559 // ourselves the fact that we got here means that the user code
1560 // decided to skip processing of this TAB - probably to let it
1561 // do its default job.
1563 wxNavigationKeyEvent eventNav
;
1564 eventNav
.SetDirection(!event
.ShiftDown());
1565 eventNav
.SetWindowChange(event
.ControlDown());
1566 eventNav
.SetEventObject(this);
1568 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1574 // no, we didn't process it
1578 long wxTextCtrl
::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1580 long lRc
= wxTextCtrlBase
::MSWWindowProc(nMsg
, wParam
, lParam
);
1582 if ( nMsg
== WM_GETDLGCODE
)
1584 // we always want the chars and the arrows: the arrows for navigation
1585 // and the chars because we want Ctrl-C to work even in a read only
1587 long lDlgCode
= DLGC_WANTCHARS
| DLGC_WANTARROWS
;
1591 // we may have several different cases:
1592 // 1. normal case: both TAB and ENTER are used for dlg navigation
1593 // 2. ctrl which wants TAB for itself: ENTER is used to pass to the
1594 // next control in the dialog
1595 // 3. ctrl which wants ENTER for itself: TAB is used for dialog
1597 // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go
1598 // to the next control
1600 // the multiline edit control should always get <Return> for itself
1601 if ( HasFlag(wxTE_PROCESS_ENTER
) || HasFlag(wxTE_MULTILINE
) )
1602 lDlgCode
|= DLGC_WANTMESSAGE
;
1604 if ( HasFlag(wxTE_PROCESS_TAB
) )
1605 lDlgCode
|= DLGC_WANTTAB
;
1611 // NB: use "=", not "|=" as the base class version returns the
1612 // same flags is this state as usual (i.e. including
1613 // DLGC_WANTMESSAGE). This is strange (how does it work in the
1614 // native Win32 apps?) but for now live with it.
1622 // ----------------------------------------------------------------------------
1623 // text control event processing
1624 // ----------------------------------------------------------------------------
1626 bool wxTextCtrl
::SendUpdateEvent()
1628 // is event reporting suspended?
1629 if ( m_suppressNextUpdate
)
1631 // do process the next one
1632 m_suppressNextUpdate
= FALSE
;
1637 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, GetId());
1638 InitCommandEvent(event
);
1639 event
.SetString(GetValue());
1641 return ProcessCommand(event
);
1644 bool wxTextCtrl
::MSWCommand(WXUINT param
, WXWORD
WXUNUSED(id
))
1651 wxFocusEvent
event(param
== EN_KILLFOCUS ? wxEVT_KILL_FOCUS
1654 event
.SetEventObject(this);
1655 GetEventHandler()->ProcessEvent(event
);
1664 // the text size limit has been hit -- try to increase it
1665 if ( !AdjustSpaceLimit() )
1667 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, m_windowId
);
1668 InitCommandEvent(event
);
1669 event
.SetString(GetValue());
1670 ProcessCommand(event
);
1674 // the other edit notification messages are not processed
1683 WXHBRUSH wxTextCtrl
::OnCtlColor(WXHDC pDC
, WXHWND
WXUNUSED(pWnd
), WXUINT
WXUNUSED(nCtlColor
),
1689 WXUINT
WXUNUSED(message
),
1690 WXWPARAM
WXUNUSED(wParam
),
1691 WXLPARAM
WXUNUSED(lParam
)
1698 HBRUSH hbrush
= Ctl3dCtlColorEx(message
, wParam
, lParam
);
1699 return (WXHBRUSH
) hbrush
;
1701 #endif // wxUSE_CTL3D
1704 wxColour colBack
= GetBackgroundColour();
1706 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE
) == 0)
1707 colBack
= wxSystemSettings
::GetColour(wxSYS_COLOUR_3DFACE
);
1709 ::SetBkColor(hdc
, wxColourToRGB(colBack
));
1710 ::SetTextColor(hdc
, wxColourToRGB(GetForegroundColour()));
1712 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(colBack
, wxSOLID
);
1714 return (WXHBRUSH
)brush
->GetResourceHandle();
1717 // In WIN16, need to override normal erasing because
1718 // Ctl3D doesn't use the wxWindows background colour.
1720 void wxTextCtrl
::OnEraseBackground(wxEraseEvent
& event
)
1722 wxColour
col(m_backgroundColour
);
1726 col
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
1730 ::GetClientRect(GetHwnd(), &rect
);
1732 COLORREF ref
= wxColourToRGB(col
);
1733 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
1735 wxLogLastError(wxT("CreateSolidBrush"));
1737 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
1739 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
1741 ::FillRect(hdc
, &rect
, hBrush
);
1742 ::DeleteObject(hBrush
);
1743 ::SetMapMode(hdc
, mode
);
1748 bool wxTextCtrl
::AdjustSpaceLimit()
1751 unsigned int limit
= ::SendMessage(GetHwnd(), EM_GETLIMITTEXT
, 0, 0);
1753 // HACK: we try to automatically extend the limit for the amount of text
1754 // to allow (interactively) entering more than 64Kb of text under
1755 // Win9x but we shouldn't reset the text limit which was previously
1756 // set explicitly with SetMaxLength()
1758 // we could solve this by storing the limit we set in wxTextCtrl but
1759 // to save space we prefer to simply test here the actual limit
1760 // value: we consider that SetMaxLength() can only be called for
1762 if ( limit
< 0x8000 )
1764 // we've got more text than limit set by SetMaxLength()
1768 unsigned int len
= ::GetWindowTextLength(GetHwnd());
1771 limit
= len
+ 0x8000; // 32Kb
1776 // as a nice side effect, this also allows passing limit > 64Kb
1777 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT
, 0, limit
);
1780 #endif // wxUSE_RICHEDIT
1782 if ( limit
> 0xffff )
1784 // this will set it to a platform-dependent maximum (much more
1785 // than 64Kb under NT)
1789 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, limit
, 0);
1794 // we changed the limit
1798 bool wxTextCtrl
::AcceptsFocus() const
1800 // we don't want focus if we can't be edited unless we're a multiline
1801 // control because then it might be still nice to get focus from keyboard
1802 // to be able to scroll it without mouse
1803 return (IsEditable() || IsMultiLine()) && wxControl
::AcceptsFocus();
1806 wxSize wxTextCtrl
::DoGetBestSize() const
1809 wxGetCharSize(GetHWND(), &cx
, &cy
, &GetFont());
1811 int wText
= DEFAULT_ITEM_WIDTH
;
1813 int hText
= EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy
);
1814 if ( m_windowStyle
& wxTE_MULTILINE
)
1816 hText
*= wxMax(GetNumberOfLines(), 5);
1818 //else: for single line control everything is ok
1820 return wxSize(wText
, hText
);
1823 // ----------------------------------------------------------------------------
1824 // standard handlers for standard edit menu events
1825 // ----------------------------------------------------------------------------
1827 void wxTextCtrl
::OnCut(wxCommandEvent
& WXUNUSED(event
))
1832 void wxTextCtrl
::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1837 void wxTextCtrl
::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1842 void wxTextCtrl
::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1847 void wxTextCtrl
::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1852 void wxTextCtrl
::OnDelete(wxCommandEvent
& WXUNUSED(event
))
1855 GetSelection(& from
, & to
);
1856 if (from
!= -1 && to
!= -1)
1860 void wxTextCtrl
::OnSelectAll(wxCommandEvent
& WXUNUSED(event
))
1862 SetSelection(-1, -1);
1865 void wxTextCtrl
::OnUpdateCut(wxUpdateUIEvent
& event
)
1867 event
.Enable( CanCut() );
1870 void wxTextCtrl
::OnUpdateCopy(wxUpdateUIEvent
& event
)
1872 event
.Enable( CanCopy() );
1875 void wxTextCtrl
::OnUpdatePaste(wxUpdateUIEvent
& event
)
1877 event
.Enable( CanPaste() );
1880 void wxTextCtrl
::OnUpdateUndo(wxUpdateUIEvent
& event
)
1882 event
.Enable( CanUndo() );
1885 void wxTextCtrl
::OnUpdateRedo(wxUpdateUIEvent
& event
)
1887 event
.Enable( CanRedo() );
1890 void wxTextCtrl
::OnUpdateDelete(wxUpdateUIEvent
& event
)
1893 GetSelection(& from
, & to
);
1894 event
.Enable(from
!= -1 && to
!= -1 && from
!= to
&& IsEditable()) ;
1897 void wxTextCtrl
::OnUpdateSelectAll(wxUpdateUIEvent
& event
)
1899 event
.Enable(GetLastPosition() > 0);
1902 void wxTextCtrl
::OnRightClick(wxMouseEvent
& event
)
1907 if (!m_privateContextMenu
)
1909 m_privateContextMenu
= new wxMenu
;
1910 m_privateContextMenu
->Append(wxID_UNDO
, _("&Undo"));
1911 m_privateContextMenu
->Append(wxID_REDO
, _("&Redo"));
1912 m_privateContextMenu
->AppendSeparator();
1913 m_privateContextMenu
->Append(wxID_CUT
, _("Cu&t"));
1914 m_privateContextMenu
->Append(wxID_COPY
, _("&Copy"));
1915 m_privateContextMenu
->Append(wxID_PASTE
, _("&Paste"));
1916 m_privateContextMenu
->Append(wxID_CLEAR
, _("&Delete"));
1917 m_privateContextMenu
->AppendSeparator();
1918 m_privateContextMenu
->Append(wxID_SELECTALL
, _("Select &All"));
1920 PopupMenu(m_privateContextMenu
, event
.GetPosition());
1928 void wxTextCtrl
::OnSetFocus(wxFocusEvent
& WXUNUSED(event
))
1930 // be sure the caret remains invisible if the user had hidden it
1931 if ( !m_isNativeCaretShown
)
1933 ::HideCaret(GetHwnd());
1937 // the rest of the file only deals with the rich edit controls
1940 // ----------------------------------------------------------------------------
1941 // EN_LINK processing
1942 // ----------------------------------------------------------------------------
1944 bool wxTextCtrl
::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1946 NMHDR
*hdr
= (NMHDR
* )lParam
;
1947 switch ( hdr
->code
)
1951 const MSGFILTER
*msgf
= (MSGFILTER
*)lParam
;
1952 UINT msg
= msgf
->msg
;
1954 // this is a bit crazy but richedit 1.0 sends us all mouse
1955 // events _except_ WM_LBUTTONUP (don't ask me why) so we have
1956 // generate the wxWin events for this message manually
1958 // NB: in fact, this is still not totally correct as it does
1959 // send us WM_LBUTTONUP if the selection was cleared by the
1960 // last click -- so currently we get 2 events in this case,
1961 // but as I don't see any obvious way to check for this I
1962 // leave this code in place because it's still better than
1963 // not getting left up events at all
1964 if ( msg
== WM_LBUTTONUP
)
1966 WXUINT flags
= msgf
->wParam
;
1967 int x
= GET_X_LPARAM(msgf
->lParam
),
1968 y
= GET_Y_LPARAM(msgf
->lParam
);
1970 HandleMouseEvent(msg
, x
, y
, flags
);
1974 // return TRUE to process the event (and FALSE to ignore it)
1979 const ENLINK
*enlink
= (ENLINK
*)hdr
;
1981 switch ( enlink
->msg
)
1984 // ok, so it is hardcoded - do we really nee to
1986 ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND
)));
1991 case WM_LBUTTONDOWN
:
1993 case WM_LBUTTONDBLCLK
:
1994 case WM_RBUTTONDOWN
:
1996 case WM_RBUTTONDBLCLK
:
1997 // send a mouse event
1999 static const wxEventType eventsMouse
[] =
2010 // the event ids are consecutive
2012 evtMouse(eventsMouse
[enlink
->msg
- WM_MOUSEMOVE
]);
2014 InitMouseEvent(evtMouse
,
2015 GET_X_LPARAM(enlink
->lParam
),
2016 GET_Y_LPARAM(enlink
->lParam
),
2019 wxTextUrlEvent
event(m_windowId
, evtMouse
,
2021 enlink
->chrg
.cpMax
);
2023 InitCommandEvent(event
);
2025 *result
= ProcessCommand(event
);
2033 // not processed, leave it to the base class
2034 return wxTextCtrlBase
::MSWOnNotify(idCtrl
, lParam
, result
);
2037 // ----------------------------------------------------------------------------
2038 // colour setting for the rich edit controls
2039 // ----------------------------------------------------------------------------
2041 bool wxTextCtrl
::SetBackgroundColour(const wxColour
& colour
)
2043 if ( !wxTextCtrlBase
::SetBackgroundColour(colour
) )
2045 // colour didn't really change
2051 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
2052 // EM_SETBKGNDCOLOR additionally
2053 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR
, 0, wxColourToRGB(colour
));
2059 bool wxTextCtrl
::SetForegroundColour(const wxColour
& colour
)
2061 if ( !wxTextCtrlBase
::SetForegroundColour(colour
) )
2063 // colour didn't really change
2069 // change the colour of everything
2072 cf
.cbSize
= sizeof(cf
);
2073 cf
.dwMask
= CFM_COLOR
;
2074 cf
.crTextColor
= wxColourToRGB(colour
);
2075 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
, SCF_ALL
, (LPARAM
)&cf
);
2081 // ----------------------------------------------------------------------------
2082 // styling support for rich edit controls
2083 // ----------------------------------------------------------------------------
2087 bool wxTextCtrl
::SetStyle(long start
, long end
, const wxTextAttr
& style
)
2091 // can't do it with normal text control
2095 // the richedit 1.0 doesn't handle setting background colour, so don't
2096 // even try to do anything if it's the only thing we want to change
2097 if ( m_verRichEdit
== 1 && !style
.HasFont() && !style
.HasTextColour() &&
2098 !style
.HasLeftIndent() && !style
.HasRightIndent() && !style
.HasAlignment() &&
2101 // nothing to do: return TRUE if there was really nothing to do and
2102 // FALSE if we failed to set bg colour
2103 return !style
.HasBackgroundColour();
2106 // order the range if needed
2114 // we can only change the format of the selection, so select the range we
2115 // want and restore the old selection later
2116 long startOld
, endOld
;
2117 GetSelection(&startOld
, &endOld
);
2119 // but do we really have to change the selection?
2120 bool changeSel
= start
!= startOld
|| end
!= endOld
;
2124 DoSetSelection(start
, end
, FALSE
/* don't scroll caret into view */);
2127 // initialize CHARFORMAT struct
2136 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2137 // CHARFORMAT in that case
2139 if ( m_verRichEdit
== 1 )
2141 // this is the only thing the control is going to grok
2142 cf
.cbSize
= sizeof(CHARFORMAT
);
2147 // CHARFORMAT or CHARFORMAT2
2148 cf
.cbSize
= sizeof(cf
);
2151 if ( style
.HasFont() )
2153 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
2154 // but using it doesn't seem to hurt neither so leaving it for now
2156 cf
.dwMask
|= CFM_FACE
| CFM_SIZE
| CFM_CHARSET
|
2157 CFM_ITALIC
| CFM_BOLD
| CFM_UNDERLINE
;
2159 // fill in data from LOGFONT but recalculate lfHeight because we need
2160 // the real height in twips and not the negative number which
2161 // wxFillLogFont() returns (this is correct in general and works with
2162 // the Windows font mapper, but not here)
2164 wxFillLogFont(&lf
, &style
.GetFont());
2165 cf
.yHeight
= 20*style
.GetFont().GetPointSize(); // 1 pt = 20 twips
2166 cf
.bCharSet
= lf
.lfCharSet
;
2167 cf
.bPitchAndFamily
= lf
.lfPitchAndFamily
;
2168 wxStrncpy( cf
.szFaceName
, lf
.lfFaceName
, WXSIZEOF(cf
.szFaceName
) );
2170 // also deal with underline/italic/bold attributes: note that we must
2171 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
2172 // style to allow clearing it
2175 cf
.dwEffects
|= CFE_ITALIC
;
2178 if ( lf
.lfWeight
== FW_BOLD
)
2180 cf
.dwEffects
|= CFE_BOLD
;
2183 if ( lf
.lfUnderline
)
2185 cf
.dwEffects
|= CFE_UNDERLINE
;
2188 // strikeout fonts are not supported by wxWindows
2191 if ( style
.HasTextColour() )
2193 cf
.dwMask
|= CFM_COLOR
;
2194 cf
.crTextColor
= wxColourToRGB(style
.GetTextColour());
2198 if ( m_verRichEdit
!= 1 && style
.HasBackgroundColour() )
2200 cf
.dwMask
|= CFM_BACKCOLOR
;
2201 cf
.crBackColor
= wxColourToRGB(style
.GetBackgroundColour());
2203 #endif // wxUSE_RICHEDIT2
2205 // do format the selection
2206 bool ok
= ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
,
2207 SCF_SELECTION
, (LPARAM
)&cf
) != 0;
2210 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
2213 // now do the paragraph formatting
2216 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2217 // PARAFORMAT in that case
2219 if ( m_verRichEdit
== 1 )
2221 // this is the only thing the control is going to grok
2222 pf
.cbSize
= sizeof(PARAFORMAT
);
2227 // PARAFORMAT or PARAFORMAT2
2228 pf
.cbSize
= sizeof(pf
);
2231 if (style
.HasAlignment())
2233 pf
.dwMask
|= PFM_ALIGNMENT
;
2234 if (style
.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT
)
2235 pf
.wAlignment
= PFA_RIGHT
;
2236 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE
)
2237 pf
.wAlignment
= PFA_CENTER
;
2238 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED
)
2239 pf
.wAlignment
= PFA_JUSTIFY
;
2241 pf
.wAlignment
= PFA_LEFT
;
2244 if (style
.HasLeftIndent())
2246 pf
.dwMask
|= PFM_STARTINDENT
;
2248 // Convert from 1/10 mm to TWIPS
2249 pf
.dxStartIndent
= (int) (((double) style
.GetLeftIndent()) * mm2twips
/ 10.0) ;
2251 // TODO: do we need to specify dxOffset?
2254 if (style
.HasRightIndent())
2256 pf
.dwMask
|= PFM_RIGHTINDENT
;
2258 // Convert from 1/10 mm to TWIPS
2259 pf
.dxRightIndent
= (int) (((double) style
.GetRightIndent()) * mm2twips
/ 10.0) ;
2262 if (style
.HasTabs())
2264 pf
.dwMask
|= PFM_TABSTOPS
;
2266 const wxArrayInt
& tabs
= style
.GetTabs();
2268 pf
.cTabCount
= wxMin(tabs
.GetCount(), MAX_TAB_STOPS
);
2270 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2272 // Convert from 1/10 mm to TWIPS
2273 pf
.rgxTabs
[i
] = (int) (((double) tabs
[i
]) * mm2twips
/ 10.0) ;
2279 // do format the selection
2280 bool ok
= ::SendMessage(GetHwnd(), EM_SETPARAFORMAT
,
2281 0, (LPARAM
) &pf
) != 0;
2284 wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed"));
2290 // restore the original selection
2291 DoSetSelection(startOld
, endOld
, FALSE
);
2297 bool wxTextCtrl
::SetDefaultStyle(const wxTextAttr
& style
)
2299 if ( !wxTextCtrlBase
::SetDefaultStyle(style
) )
2302 // we have to do this or the style wouldn't apply for the text typed by the
2304 long posLast
= GetLastPosition();
2305 SetStyle(posLast
, posLast
, m_defaultStyle
);
2310 bool wxTextCtrl
::GetStyle(long position
, wxTextAttr
& style
)
2314 // can't do it with normal text control
2318 // initialize CHARFORMAT struct
2327 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2328 // CHARFORMAT in that case
2330 if ( m_verRichEdit
== 1 )
2332 // this is the only thing the control is going to grok
2333 cf
.cbSize
= sizeof(CHARFORMAT
);
2338 // CHARFORMAT or CHARFORMAT2
2339 cf
.cbSize
= sizeof(cf
);
2341 // we can only change the format of the selection, so select the range we
2342 // want and restore the old selection later
2343 long startOld
, endOld
;
2344 GetSelection(&startOld
, &endOld
);
2346 // but do we really have to change the selection?
2347 bool changeSel
= position
!= startOld
|| position
!= endOld
;
2351 DoSetSelection(position
, position
, FALSE
/* don't scroll caret into view */);
2354 // get the selection formatting
2355 (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT
,
2356 SCF_SELECTION
, (LPARAM
)&cf
) ;
2359 lf
.lfHeight
= cf
.yHeight
;
2361 lf
.lfCharSet
= ANSI_CHARSET
; // FIXME: how to get correct charset?
2362 lf
.lfClipPrecision
= 0;
2363 lf
.lfEscapement
= 0;
2364 wxStrcpy(lf
.lfFaceName
, cf
.szFaceName
);
2365 if (cf
.dwEffects
& CFE_ITALIC
)
2367 lf
.lfOrientation
= 0;
2368 lf
.lfPitchAndFamily
= cf
.bPitchAndFamily
;
2370 if (cf
.dwEffects
& CFE_STRIKEOUT
)
2371 lf
.lfStrikeOut
= TRUE
;
2372 if (cf
.dwEffects
& CFE_UNDERLINE
)
2373 lf
.lfUnderline
= TRUE
;
2374 if (cf
.dwEffects
& CFE_BOLD
)
2375 lf
.lfWeight
= FW_BOLD
;
2377 wxFont font
= wxCreateFontFromLogFont(& lf
);
2380 style
.SetFont(font
);
2382 style
.SetTextColour(wxColour(cf
.crTextColor
));
2385 if ( m_verRichEdit
!= 1 )
2387 // cf.dwMask |= CFM_BACKCOLOR;
2388 style
.SetBackgroundColour(wxColour(cf
.crBackColor
));
2390 #endif // wxUSE_RICHEDIT2
2392 // now get the paragraph formatting
2395 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2396 // PARAFORMAT in that case
2398 if ( m_verRichEdit
== 1 )
2400 // this is the only thing the control is going to grok
2401 pf
.cbSize
= sizeof(PARAFORMAT
);
2406 // PARAFORMAT or PARAFORMAT2
2407 pf
.cbSize
= sizeof(pf
);
2410 // do format the selection
2411 (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT
, 0, (LPARAM
) &pf
) ;
2413 style
.SetLeftIndent( (int) ((double) pf
.dxStartIndent
* twips2mm
* 10.0) );
2414 style
.SetRightIndent( (int) ((double) pf
.dxRightIndent
* twips2mm
* 10.0) );
2416 if (pf
.wAlignment
== PFA_CENTER
)
2417 style
.SetAlignment(wxTEXT_ALIGNMENT_CENTRE
);
2418 else if (pf
.wAlignment
== PFA_RIGHT
)
2419 style
.SetAlignment(wxTEXT_ALIGNMENT_RIGHT
);
2420 else if (pf
.wAlignment
== PFA_JUSTIFY
)
2421 style
.SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED
);
2423 style
.SetAlignment(wxTEXT_ALIGNMENT_LEFT
);
2425 wxArrayInt tabStops
;
2427 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2429 tabStops
[i
] = (int) ((double) (pf
.rgxTabs
[i
] & 0xFFFF) * twips2mm
* 10.0) ;
2434 // restore the original selection
2435 DoSetSelection(startOld
, endOld
, FALSE
);
2443 // ----------------------------------------------------------------------------
2445 // ----------------------------------------------------------------------------
2447 bool wxRichEditModule
::OnInit()
2449 // don't do anything - we will load it when needed
2453 void wxRichEditModule
::OnExit()
2455 for ( size_t i
= 0; i
< WXSIZEOF(ms_hRichEdit
); i
++ )
2457 if ( ms_hRichEdit
[i
] )
2459 ::FreeLibrary(ms_hRichEdit
[i
]);
2460 ms_hRichEdit
[i
] = NULL
;
2466 bool wxRichEditModule
::Load(int version
)
2468 // we don't support loading richedit 3.0 as I don't know how to distinguish
2469 // it from 2.0 anyhow
2470 wxCHECK_MSG( version
== 1 || version
== 2, FALSE
,
2471 _T("incorrect richedit control version requested") );
2473 // make it the index in the array
2476 if ( ms_hRichEdit
[version
] == (HINSTANCE
)-1 )
2478 // we had already tried to load it and failed
2482 if ( ms_hRichEdit
[version
] )
2484 // we've already got this one
2488 wxString dllname
= version ?
_T("riched20") : _T("riched32");
2489 dllname
+= _T(".dll");
2491 ms_hRichEdit
[version
] = ::LoadLibrary(dllname
);
2493 if ( !ms_hRichEdit
[version
] )
2495 wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname
.c_str());
2497 ms_hRichEdit
[version
] = (HINSTANCE
)-1;
2505 #endif // wxUSE_RICHEDIT
2507 #endif // wxUSE_TEXTCTRL