1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/textctrl.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
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"
44 #include "wx/module.h"
47 #include "wx/clipbrd.h"
50 #include "wx/textfile.h"
54 #include "wx/msw/private.h"
58 #include <sys/types.h>
62 // old mingw32 has richedit stuff directly in windows.h and doesn't have
64 #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
68 // old mingw32 doesn't define this
70 #define CFM_CHARSET 0x08000000
74 #define CFM_BACKCOLOR 0x04000000
77 // cygwin does not have these defined for richedit
79 #define ENM_LINK 0x04000000
82 #ifndef EM_AUTOURLDETECT
83 #define EM_AUTOURLDETECT (WM_USER + 91)
87 #define EN_LINK 0x070b
89 typedef struct _enlink
100 #define SF_UNICODE 0x0010
103 // Watcom C++ doesn't define this
105 #define SCF_ALL 0x0004
108 #endif // wxUSE_RICHEDIT
110 // ----------------------------------------------------------------------------
112 // ----------------------------------------------------------------------------
116 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
);
118 #endif // wxUSE_RICHEDIT
120 // ----------------------------------------------------------------------------
122 // ----------------------------------------------------------------------------
126 // this module initializes RichEdit DLL(s) if needed
127 class wxRichEditModule
: public wxModule
130 virtual bool OnInit();
131 virtual void OnExit();
133 // load the richedit DLL of at least of required version
134 static bool Load(int version
= 1);
137 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
138 static HINSTANCE ms_hRichEdit
[2];
140 DECLARE_DYNAMIC_CLASS(wxRichEditModule
)
143 HINSTANCE
wxRichEditModule::ms_hRichEdit
[2] = { NULL
, NULL
};
145 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule
, wxModule
)
147 #endif // wxUSE_RICHEDIT
149 // ----------------------------------------------------------------------------
150 // event tables and other macros
151 // ----------------------------------------------------------------------------
153 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
155 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
156 EVT_CHAR(wxTextCtrl::OnChar
)
157 EVT_DROP_FILES(wxTextCtrl::OnDropFiles
)
160 EVT_RIGHT_UP(wxTextCtrl::OnRightClick
)
163 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
164 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
165 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
166 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
167 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
168 EVT_MENU(wxID_CLEAR
, wxTextCtrl::OnDelete
)
169 EVT_MENU(wxID_SELECTALL
, wxTextCtrl::OnSelectAll
)
171 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
172 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
173 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
174 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
175 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
176 EVT_UPDATE_UI(wxID_CLEAR
, wxTextCtrl::OnUpdateDelete
)
177 EVT_UPDATE_UI(wxID_SELECTALL
, wxTextCtrl::OnUpdateSelectAll
)
179 EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground
)
183 // ============================================================================
185 // ============================================================================
187 // ----------------------------------------------------------------------------
189 // ----------------------------------------------------------------------------
191 void wxTextCtrl::Init()
195 #endif // wxUSE_RICHEDIT
197 m_privateContextMenu
= NULL
;
198 m_suppressNextUpdate
= FALSE
;
201 wxTextCtrl::~wxTextCtrl()
203 if (m_privateContextMenu
)
205 delete m_privateContextMenu
;
206 m_privateContextMenu
= NULL
;
210 bool wxTextCtrl::Create(wxWindow
*parent
, wxWindowID id
,
211 const wxString
& value
,
215 const wxValidator
& validator
,
216 const wxString
& name
)
218 // base initialization
219 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
223 parent
->AddChild(this);
225 // translate wxWin style flags to MSW ones
226 WXDWORD msStyle
= MSWGetCreateWindowFlags();
228 // do create the control - either an EDIT or RICHEDIT
229 wxString windowClass
= wxT("EDIT");
232 if ( m_windowStyle
& wxTE_AUTO_URL
)
234 // automatic URL detection only works in RichEdit 2.0+
235 m_windowStyle
|= wxTE_RICH2
;
238 if ( m_windowStyle
& wxTE_RICH2
)
240 // using richedit 2.0 implies using wxTE_RICH
241 m_windowStyle
|= wxTE_RICH
;
244 // we need to load the richedit DLL before creating the rich edit control
245 if ( m_windowStyle
& wxTE_RICH
)
247 static bool s_errorGiven
= FALSE
;// MT-FIXME
249 // Which version do we need? Use 1.0 by default because it is much more
250 // like the the standard EDIT or 2.0 if explicitly requested, but use
251 // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
253 // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
254 // (and thus EDIT) much better than RichEdit 2.0 so we probably
255 // should use 3.0 if available as it is the best of both worlds -
256 // but as I can't test it right now I don't do it (VZ)
258 const int verRichEdit
= 2;
259 #else // !wxUSE_UNICODE
260 int verRichEdit
= m_windowStyle
& wxTE_RICH2
? 2 : 1;
261 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
263 // only give the error msg once if the DLL can't be loaded
266 // try to load the RichEdit DLL (will do nothing if already done)
267 if ( !wxRichEditModule::Load(verRichEdit
) )
270 // try another version?
271 verRichEdit
= 3 - verRichEdit
; // 1 <-> 2
273 if ( !wxRichEditModule::Load(verRichEdit
) )
274 #endif // wxUSE_UNICODE
276 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
283 // have we managed to load any richedit version?
286 m_verRichEdit
= verRichEdit
;
287 if ( m_verRichEdit
== 1 )
289 windowClass
= wxT("RICHEDIT");
293 #ifndef RICHEDIT_CLASS
294 wxString RICHEDIT_CLASS
;
295 RICHEDIT_CLASS
.Printf(_T("RichEdit%d0"), m_verRichEdit
);
297 RICHEDIT_CLASS
+= _T('W');
299 RICHEDIT_CLASS
+= _T('A');
300 #endif // Unicode/ANSI
301 #endif // !RICHEDIT_CLASS
303 windowClass
= RICHEDIT_CLASS
;
307 #endif // wxUSE_RICHEDIT
309 // we need to turn '\n's into "\r\n"s for the multiline controls
311 if ( m_windowStyle
& wxTE_MULTILINE
)
313 valueWin
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
320 if ( !MSWCreateControl(windowClass
, msStyle
, pos
, size
, valueWin
) )
323 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
328 // enable the events we're interested in: we want to get EN_CHANGE as
329 // for the normal controls
330 LPARAM mask
= ENM_CHANGE
;
332 if ( GetRichVersion() == 1 )
334 // we also need EN_MSGFILTER for richedit 1.0 for the reasons
335 // explained in its handler
336 mask
|= ENM_MOUSEEVENTS
;
338 else if ( m_windowStyle
& wxTE_AUTO_URL
)
342 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT
, TRUE
, 0);
345 ::SendMessage(GetHwnd(), EM_SETEVENTMASK
, 0, mask
);
347 #endif // wxUSE_RICHEDIT
352 // Make sure the window style (etc.) reflects the HWND style (roughly)
353 void wxTextCtrl::AdoptAttributesFromHWND()
355 wxWindow::AdoptAttributesFromHWND();
357 HWND hWnd
= GetHwnd();
358 long style
= ::GetWindowLong(hWnd
, GWL_STYLE
);
360 // retrieve the style to see whether this is an edit or richedit ctrl
362 wxString classname
= wxGetWindowClass(GetHWND());
364 if ( classname
.IsSameAs(_T("EDIT"), FALSE
/* no case */) )
371 if ( wxSscanf(classname
, _T("RichEdit%d0%c"), &m_verRichEdit
, &c
) != 2 )
373 wxLogDebug(_T("Unknown edit control '%s'."), classname
.c_str());
378 #endif // wxUSE_RICHEDIT
380 if (style
& ES_MULTILINE
)
381 m_windowStyle
|= wxTE_MULTILINE
;
382 if (style
& ES_PASSWORD
)
383 m_windowStyle
|= wxTE_PASSWORD
;
384 if (style
& ES_READONLY
)
385 m_windowStyle
|= wxTE_READONLY
;
386 if (style
& ES_WANTRETURN
)
387 m_windowStyle
|= wxTE_PROCESS_ENTER
;
388 if (style
& ES_CENTER
)
389 m_windowStyle
|= wxTE_CENTRE
;
390 if (style
& ES_RIGHT
)
391 m_windowStyle
|= wxTE_RIGHT
;
394 WXDWORD
wxTextCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
396 // default border for the text controls is the sunken one
397 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
399 style
|= wxBORDER_SUNKEN
;
402 long msStyle
= wxControl::MSWGetStyle(style
, exstyle
);
404 // styles which we alaways add by default
405 if ( style
& wxTE_MULTILINE
)
407 wxASSERT_MSG( !(style
& wxTE_PROCESS_ENTER
),
408 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
410 msStyle
|= ES_MULTILINE
| ES_WANTRETURN
;
411 if ( !(style
& wxTE_NO_VSCROLL
) )
413 // always adjust the vertical scrollbar automatically if we have it
414 msStyle
|= WS_VSCROLL
| ES_AUTOVSCROLL
;
417 // we have to use this style for the rich edit controls because
418 // without it the vertical scrollbar never appears at all in
419 // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it)
420 if ( style
& wxTE_RICH2
)
422 msStyle
|= ES_DISABLENOSCROLL
;
424 #endif // wxUSE_RICHEDIT
427 style
|= wxTE_PROCESS_ENTER
;
431 // there is really no reason to not have this style for single line
433 msStyle
|= ES_AUTOHSCROLL
;
436 // styles which we add depending on the specified wxWindows styles
437 if ( style
& wxHSCROLL
)
439 // automatically scroll the control horizontally as necessary
440 msStyle
|= WS_HSCROLL
;// | ES_AUTOHSCROLL;
443 if ( style
& wxTE_READONLY
)
444 msStyle
|= ES_READONLY
;
446 if ( style
& wxTE_PASSWORD
)
447 msStyle
|= ES_PASSWORD
;
449 if ( style
& wxTE_NOHIDESEL
)
450 msStyle
|= ES_NOHIDESEL
;
452 // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0
453 if ( style
& wxTE_CENTRE
)
454 msStyle
|= ES_CENTER
;
455 else if ( style
& wxTE_RIGHT
)
458 msStyle
|= ES_LEFT
; // ES_LEFT if 0 as well but for consistency...
463 void wxTextCtrl::SetWindowStyleFlag(long style
)
465 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
466 style
|= wxBORDER_SUNKEN
;
469 // we have to deal with some styles separately because they can't be
470 // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
471 // using richedit-specific EM_SETOPTIONS
473 ((style
& wxTE_NOHIDESEL
) != (GetWindowStyle() & wxTE_NOHIDESEL
)) )
475 bool set
= (style
& wxTE_NOHIDESEL
) != 0;
477 ::SendMessage(GetHwnd(), EM_SETOPTIONS
, set
? ECOOP_OR
: ECOOP_AND
,
478 set
? ECO_NOHIDESEL
: ~ECO_NOHIDESEL
);
480 #endif // wxUSE_RICHEDIT
482 wxControl::SetWindowStyleFlag(style
);
485 // ----------------------------------------------------------------------------
486 // set/get the controls text
487 // ----------------------------------------------------------------------------
489 wxString
wxTextCtrl::GetValue() const
491 // range 0..-1 is special for GetRange() and means to retrieve all text
492 return GetRange(0, -1);
495 wxString
wxTextCtrl::GetRange(long from
, long to
) const
499 if ( from
>= to
&& to
!= -1 )
501 // nothing to retrieve
508 int len
= GetWindowTextLength(GetHwnd());
511 // alloc one extra WORD as needed by the control
512 wxChar
*p
= str
.GetWriteBuf(++len
);
515 textRange
.chrg
.cpMin
= from
;
516 textRange
.chrg
.cpMax
= to
== -1 ? len
: to
;
517 textRange
.lpstrText
= p
;
519 (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE
, 0, (LPARAM
)&textRange
);
521 if ( m_verRichEdit
> 1 )
523 // RichEdit 2.0 uses just CR ('\r') for the newlines which is
524 // neither Unix nor Windows style - convert it to something
528 if ( *p
== _T('\r') )
535 if ( m_verRichEdit
== 1 )
537 // convert to the canonical form - see comment below
538 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
541 //else: no text at all, leave the string empty
544 #endif // wxUSE_RICHEDIT
547 str
= wxGetWindowText(GetHWND());
549 // need only a range?
552 str
= str
.Mid(from
, to
- from
);
555 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
556 // canonical one (same one as above) for consistency with the other kinds
557 // of controls and, more importantly, with the other ports
558 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
564 void wxTextCtrl::SetValue(const wxString
& value
)
566 // if the text is long enough, it's faster to just set it instead of first
567 // comparing it with the old one (chances are that it will be different
568 // anyhow, this comparison is there to avoid flicker for small single-line
569 // edit controls mostly)
570 if ( (value
.length() > 0x400) || (value
!= GetValue()) )
572 DoWriteText(value
, FALSE
/* not selection only */);
575 // we should reset the modified flag even if the value didn't really change
577 // mark the control as being not dirty - we changed its text, not the
581 // for compatibility, don't move the cursor when doing SetValue()
582 SetInsertionPoint(0);
585 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
587 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
591 wchar_t *wbuf
= (wchar_t *)buf
;
592 const wchar_t *wpc
= *(const wchar_t **)dwCookie
;
597 cb
-= sizeof(wchar_t);
598 (*pcb
) += sizeof(wchar_t);
601 *(const wchar_t **)dwCookie
= wpc
;
606 extern long wxEncodingToCodepage(wxFontEncoding encoding
); // from utils.cpp
608 #if wxUSE_UNICODE_MSLU
609 bool wxTextCtrl::StreamIn(const wxString
& value
,
610 wxFontEncoding
WXUNUSED(encoding
),
613 const wchar_t *wpc
= value
.c_str();
614 #else // !wxUSE_UNICODE_MSLU
615 bool wxTextCtrl::StreamIn(const wxString
& value
,
616 wxFontEncoding encoding
,
619 // we have to use EM_STREAMIN to force richedit control 2.0+ to show any
620 // text in the non default charset -- otherwise it thinks it knows better
621 // than we do and always shows it in the default one
623 // first get the Windows code page for this encoding
624 long codepage
= wxEncodingToCodepage(encoding
);
625 if ( codepage
== -1 )
631 // next translate to Unicode using this code page
632 int len
= ::MultiByteToWideChar(codepage
, 0, value
, -1, NULL
, 0);
635 wxWCharBuffer
wchBuf(len
);
637 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
640 if ( !::MultiByteToWideChar(codepage
, 0, value
, -1,
641 (wchar_t *)(const wchar_t *)wchBuf
, len
) )
643 wxLogLastError(_T("MultiByteToWideChar"));
646 // finally, stream it in the control
647 const wchar_t *wpc
= wchBuf
;
648 #endif // wxUSE_UNICODE_MSLU
652 eds
.dwCookie
= (DWORD
)&wpc
;
653 // the cast below is needed for broken (very) old mingw32 headers
654 eds
.pfnCallback
= (EDITSTREAMCALLBACK
)wxRichEditStreamIn
;
656 // we're going to receive 2 EN_CHANGE notifications if we got any selection
657 // (same problem as in DoWriteText())
658 if ( selectionOnly
&& HasSelection() )
660 // so suppress one of them
661 m_suppressNextUpdate
= TRUE
;
664 ::SendMessage(GetHwnd(), EM_STREAMIN
,
667 (selectionOnly
? SFF_SELECTION
: 0),
672 wxLogLastError(_T("EM_STREAMIN"));
677 #endif // !wxUSE_WCHAR_T
682 #endif // wxUSE_RICHEDIT
684 void wxTextCtrl::WriteText(const wxString
& value
)
689 void wxTextCtrl::DoWriteText(const wxString
& value
, bool selectionOnly
)
692 if ( m_windowStyle
& wxTE_MULTILINE
)
693 valueDos
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
698 // there are several complications with the rich edit controls here
702 // first, ensure that the new text will be in the default style
703 if ( !m_defaultStyle
.IsDefault() )
706 GetSelection(&start
, &end
);
707 SetStyle(start
, end
, m_defaultStyle
);
710 #if wxUSE_UNICODE_MSLU
711 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
712 // but EM_STREAMIN works
713 if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
715 done
= StreamIn(valueDos
, wxFONTENCODING_SYSTEM
, selectionOnly
);
717 #endif // wxUSE_UNICODE_MSLU
720 // next check if the text we're inserting must be shown in a non
721 // default charset -- this only works for RichEdit > 1.0
722 if ( GetRichVersion() > 1 )
724 wxFont font
= m_defaultStyle
.GetFont();
730 wxFontEncoding encoding
= font
.GetEncoding();
731 if ( encoding
!= wxFONTENCODING_SYSTEM
)
733 done
= StreamIn(valueDos
, encoding
, selectionOnly
);
737 #endif // !wxUSE_UNICODE
741 #endif // wxUSE_RICHEDIT
743 // in some cases we get 2 EN_CHANGE notifications after the SendMessage
744 // call below which is confusing for the client code and so should be
747 // these cases are: (a) plain EDIT controls if EM_REPLACESEL is used
748 // and there is a non empty selection currently and (b) rich text
749 // controls in any case
753 #endif // wxUSE_RICHEDIT
754 (selectionOnly
&& HasSelection()) )
756 m_suppressNextUpdate
= TRUE
;
759 ::SendMessage(GetHwnd(), selectionOnly
? EM_REPLACESEL
: WM_SETTEXT
,
760 0, (LPARAM
)valueDos
.c_str());
762 // OTOH, non rich text controls don't generate any events at all when
763 // we use WM_SETTEXT -- have to emulate them here
767 #endif // wxUSE_RICHEDIT
770 // Windows already sends an update event for single-line
772 if ( m_windowStyle
& wxTE_MULTILINE
)
780 void wxTextCtrl::AppendText(const wxString
& text
)
782 SetInsertionPointEnd();
787 if ( IsMultiLine() && GetRichVersion() > 1 )
789 // setting the caret to the end and showing it simply doesn't work for
790 // RichEdit 2.0 -- force it to still do what we want
791 ::SendMessage(GetHwnd(), EM_LINESCROLL
, 0, GetNumberOfLines());
793 #endif // wxUSE_RICHEDIT
796 void wxTextCtrl::Clear()
798 ::SetWindowText(GetHwnd(), wxT(""));
802 #endif // wxUSE_RICHEDIT
804 // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves
805 // but the normal ones don't -- make Clear() behaviour consistent by
806 // always sending this event
808 // Windows already sends an update event for single-line
810 if ( m_windowStyle
& wxTE_MULTILINE
)
817 bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent
& event
)
821 size_t lenOld
= GetValue().length();
823 wxUint32 code
= event
.GetRawKeyCode();
824 ::keybd_event(code
, 0, 0 /* key press */, 0);
825 ::keybd_event(code
, 0, KEYEVENTF_KEYUP
, 0);
827 // assume that any alphanumeric key changes the total number of characters
828 // in the control - this should work in 99% of cases
829 return GetValue().length() != lenOld
;
834 // ----------------------------------------------------------------------------
835 // Clipboard operations
836 // ----------------------------------------------------------------------------
838 void wxTextCtrl::Copy()
842 ::SendMessage(GetHwnd(), WM_COPY
, 0, 0L);
846 void wxTextCtrl::Cut()
850 ::SendMessage(GetHwnd(), WM_CUT
, 0, 0L);
854 void wxTextCtrl::Paste()
858 ::SendMessage(GetHwnd(), WM_PASTE
, 0, 0L);
862 bool wxTextCtrl::HasSelection() const
865 GetSelection(&from
, &to
);
869 bool wxTextCtrl::CanCopy() const
871 // Can copy if there's a selection
872 return HasSelection();
875 bool wxTextCtrl::CanCut() const
877 return CanCopy() && IsEditable();
880 bool wxTextCtrl::CanPaste() const
888 UINT cf
= 0; // 0 == any format
890 return ::SendMessage(GetHwnd(), EM_CANPASTE
, cf
, 0) != 0;
892 #endif // wxUSE_RICHEDIT
894 // Standard edit control: check for straight text on clipboard
895 if ( !::OpenClipboard(GetHwndOf(wxTheApp
->GetTopWindow())) )
898 bool isTextAvailable
= ::IsClipboardFormatAvailable(CF_TEXT
) != 0;
901 return isTextAvailable
;
904 // ----------------------------------------------------------------------------
906 // ----------------------------------------------------------------------------
908 void wxTextCtrl::SetEditable(bool editable
)
910 HWND hWnd
= GetHwnd();
911 SendMessage(hWnd
, EM_SETREADONLY
, (WPARAM
)!editable
, (LPARAM
)0L);
914 void wxTextCtrl::SetInsertionPoint(long pos
)
916 DoSetSelection(pos
, pos
);
919 void wxTextCtrl::SetInsertionPointEnd()
921 // we must not do anything if the caret is already there because calling
922 // SetInsertionPoint() thaws the controls if Freeze() had been called even
923 // if it doesn't actually move the caret anywhere and so the simple fact of
924 // doing it results in horrible flicker when appending big amounts of text
925 // to the control in a few chunks (see DoAddText() test in the text sample)
926 if ( GetInsertionPoint() == GetLastPosition() )
932 if ( m_verRichEdit
== 1 )
934 // we don't have to waste time calling GetLastPosition() in this case
937 else // !RichEdit 1.0
938 #endif // wxUSE_RICHEDIT
940 pos
= GetLastPosition();
943 SetInsertionPoint(pos
);
946 long wxTextCtrl::GetInsertionPoint() const
954 SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &range
);
957 #endif // wxUSE_RICHEDIT
959 DWORD Pos
= (DWORD
)SendMessage(GetHwnd(), EM_GETSEL
, 0, 0L);
963 long wxTextCtrl::GetLastPosition() const
965 int numLines
= GetNumberOfLines();
966 long posStartLastLine
= XYToPosition(0, numLines
- 1);
968 long lenLastLine
= GetLengthOfLineContainingPos(posStartLastLine
);
970 return posStartLastLine
+ lenLastLine
;
973 // If the return values from and to are the same, there is no
975 void wxTextCtrl::GetSelection(long* from
, long* to
) const
981 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &charRange
);
983 *from
= charRange
.cpMin
;
984 *to
= charRange
.cpMax
;
987 #endif // !wxUSE_RICHEDIT
989 DWORD dwStart
, dwEnd
;
990 ::SendMessage(GetHwnd(), EM_GETSEL
, (WPARAM
)&dwStart
, (LPARAM
)&dwEnd
);
997 bool wxTextCtrl::IsEditable() const
999 // strangely enough, we may be called before the control is created: our
1000 // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls
1005 long style
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1007 return (style
& ES_READONLY
) == 0;
1010 // ----------------------------------------------------------------------------
1012 // ----------------------------------------------------------------------------
1014 void wxTextCtrl::SetSelection(long from
, long to
)
1016 // if from and to are both -1, it means (in wxWindows) that all text should
1017 // be selected - translate into Windows convention
1018 if ( (from
== -1) && (to
== -1) )
1024 DoSetSelection(from
, to
);
1027 void wxTextCtrl::DoSetSelection(long from
, long to
, bool scrollCaret
)
1029 HWND hWnd
= GetHwnd();
1038 SendMessage(hWnd
, EM_EXSETSEL
, 0, (LPARAM
) &range
);
1041 #endif // wxUSE_RICHEDIT
1043 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)from
, (LPARAM
)to
);
1049 // richedit 3.0 (i.e. the version living in riched20.dll distributed
1050 // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when
1051 // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL
1052 // option is set (but it does work ok in richedit 1.0 mode...)
1054 // so to make it work we either need to give focus to it here which
1055 // will probably create many problems (dummy focus events; window
1056 // containing the text control being brought to foreground
1057 // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may
1058 // create other problems too -- and in fact it does because if we turn
1059 // on/off this style while appending the text to the control, the
1060 // vertical scrollbar never appears in it even if we append tons of
1061 // text and to work around this the only solution I found was to use
1062 // ES_DISABLENOSCROLL
1064 // this is very ugly but I don't see any other way to make this work
1065 if ( GetRichVersion() > 1 )
1067 if ( !HasFlag(wxTE_NOHIDESEL
) )
1069 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1070 ECOOP_OR
, ECO_NOHIDESEL
);
1072 //else: everything is already ok
1074 #endif // wxUSE_RICHEDIT
1076 SendMessage(hWnd
, EM_SCROLLCARET
, (WPARAM
)0, (LPARAM
)0);
1079 // restore ECO_NOHIDESEL if we changed it
1080 if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL
) )
1082 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1083 ECOOP_AND
, ~ECO_NOHIDESEL
);
1085 #endif // wxUSE_RICHEDIT
1088 // WPARAM is 0: selection is scrolled into view
1089 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)0, (LPARAM
)MAKELONG(from
, to
));
1093 // ----------------------------------------------------------------------------
1095 // ----------------------------------------------------------------------------
1097 void wxTextCtrl::Replace(long from
, long to
, const wxString
& value
)
1099 // Set selection and remove it
1100 DoSetSelection(from
, to
, FALSE
/* don't scroll caret into view */);
1102 SendMessage(GetHwnd(), EM_REPLACESEL
,
1108 (LPARAM
)value
.c_str());
1111 void wxTextCtrl::Remove(long from
, long to
)
1113 Replace(from
, to
, _T(""));
1116 bool wxTextCtrl::LoadFile(const wxString
& file
)
1118 if ( wxTextCtrlBase::LoadFile(file
) )
1120 // update the size limit if needed
1129 bool wxTextCtrl::IsModified() const
1131 return SendMessage(GetHwnd(), EM_GETMODIFY
, 0, 0) != 0;
1134 // Makes 'unmodified'
1135 void wxTextCtrl::DiscardEdits()
1137 SendMessage(GetHwnd(), EM_SETMODIFY
, FALSE
, 0L);
1140 int wxTextCtrl::GetNumberOfLines() const
1142 return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT
, (WPARAM
)0, (LPARAM
)0);
1145 long wxTextCtrl::XYToPosition(long x
, long y
) const
1147 // This gets the char index for the _beginning_ of this line
1148 long charIndex
= SendMessage(GetHwnd(), EM_LINEINDEX
, (WPARAM
)y
, (LPARAM
)0);
1150 return charIndex
+ x
;
1153 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1155 HWND hWnd
= GetHwnd();
1157 // This gets the line number containing the character
1162 lineNo
= SendMessage(hWnd
, EM_EXLINEFROMCHAR
, 0, (LPARAM
)pos
);
1165 #endif // wxUSE_RICHEDIT
1167 lineNo
= SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, 0);
1176 // This gets the char index for the _beginning_ of this line
1177 long charIndex
= SendMessage(hWnd
, EM_LINEINDEX
, (WPARAM
)lineNo
, (LPARAM
)0);
1178 if ( charIndex
== -1 )
1183 // The X position must therefore be the different between pos and charIndex
1185 *x
= pos
- charIndex
;
1192 void wxTextCtrl::ShowPosition(long pos
)
1194 HWND hWnd
= GetHwnd();
1196 // To scroll to a position, we pass the number of lines and characters
1197 // to scroll *by*. This means that we need to:
1198 // (1) Find the line position of the current line.
1199 // (2) Find the line position of pos.
1200 // (3) Scroll by (pos - current).
1201 // For now, ignore the horizontal scrolling.
1203 // Is this where scrolling is relative to - the line containing the caret?
1204 // Or is the first visible line??? Try first visible line.
1205 // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
1207 int currentLineLineNo
= (int)SendMessage(hWnd
, EM_GETFIRSTVISIBLELINE
, (WPARAM
)0, (LPARAM
)0L);
1209 int specifiedLineLineNo
= (int)SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, (LPARAM
)0L);
1211 int linesToScroll
= specifiedLineLineNo
- currentLineLineNo
;
1213 if (linesToScroll
!= 0)
1214 (void)SendMessage(hWnd
, EM_LINESCROLL
, (WPARAM
)0, (LPARAM
)linesToScroll
);
1217 long wxTextCtrl::GetLengthOfLineContainingPos(long pos
) const
1219 return ::SendMessage(GetHwnd(), EM_LINELENGTH
, (WPARAM
)pos
, 0);
1222 int wxTextCtrl::GetLineLength(long lineNo
) const
1224 long pos
= XYToPosition(0, lineNo
);
1226 return GetLengthOfLineContainingPos(pos
);
1229 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1231 size_t len
= (size_t)GetLineLength(lineNo
) + 1;
1233 // there must be at least enough place for the length WORD in the
1235 len
+= sizeof(WORD
);
1238 wxChar
*buf
= str
.GetWriteBuf(len
);
1240 *(WORD
*)buf
= (WORD
)len
;
1241 len
= (size_t)::SendMessage(GetHwnd(), EM_GETLINE
, lineNo
, (LPARAM
)buf
);
1244 str
.UngetWriteBuf(len
);
1249 void wxTextCtrl::SetMaxLength(unsigned long len
)
1251 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, len
, 0);
1254 // ----------------------------------------------------------------------------
1256 // ----------------------------------------------------------------------------
1258 void wxTextCtrl::Undo()
1262 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1266 void wxTextCtrl::Redo()
1270 // Same as Undo, since Undo undoes the undo, i.e. a redo.
1271 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1275 bool wxTextCtrl::CanUndo() const
1277 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1280 bool wxTextCtrl::CanRedo() const
1282 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1285 // ----------------------------------------------------------------------------
1286 // implemenation details
1287 // ----------------------------------------------------------------------------
1289 void wxTextCtrl::Command(wxCommandEvent
& event
)
1291 SetValue(event
.GetString());
1292 ProcessCommand (event
);
1295 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1297 // By default, load the first file into the text window.
1298 if (event
.GetNumberOfFiles() > 0)
1300 LoadFile(event
.GetFiles()[0]);
1304 // ----------------------------------------------------------------------------
1305 // kbd input processing
1306 // ----------------------------------------------------------------------------
1308 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG
* pMsg
)
1310 MSG
*msg
= (MSG
*)pMsg
;
1312 // check for our special keys here: if we don't do it and the parent frame
1313 // uses them as accelerators, they wouldn't work at all, so we disable
1314 // usual preprocessing for them
1315 if ( msg
->message
== WM_KEYDOWN
)
1317 WORD vkey
= (WORD
) msg
->wParam
;
1318 if ( (HIWORD(msg
->lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
1320 if ( vkey
== VK_BACK
)
1325 // we want to process some Ctrl-foo and Shift-bar but no key
1326 // combinations without either Ctrl or Shift nor with both of them
1328 const int ctrl
= wxIsCtrlDown(),
1329 shift
= wxIsShiftDown();
1330 switch ( ctrl
+ shift
)
1333 wxFAIL_MSG( _T("how many modifiers have we got?") );
1341 // either Ctrl or Shift pressed
1356 else // Shift is pressed
1358 if ( vkey
== VK_INSERT
|| vkey
== VK_DELETE
)
1365 return wxControl::MSWShouldPreProcessMessage(pMsg
);
1368 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1370 switch ( event
.GetKeyCode() )
1373 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1375 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1376 InitCommandEvent(event
);
1377 event
.SetString(GetValue());
1378 if ( GetEventHandler()->ProcessEvent(event
) )
1381 //else: multiline controls need Enter for themselves
1386 // always produce navigation event - even if we process TAB
1387 // ourselves the fact that we got here means that the user code
1388 // decided to skip processing of this TAB - probably to let it
1389 // do its default job.
1391 wxNavigationKeyEvent eventNav
;
1392 eventNav
.SetDirection(!event
.ShiftDown());
1393 eventNav
.SetWindowChange(event
.ControlDown());
1394 eventNav
.SetEventObject(this);
1396 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1402 // no, we didn't process it
1406 long wxTextCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1408 long lRc
= wxTextCtrlBase::MSWWindowProc(nMsg
, wParam
, lParam
);
1410 if ( nMsg
== WM_GETDLGCODE
)
1412 // we always want the chars and the arrows: the arrows for navigation
1413 // and the chars because we want Ctrl-C to work even in a read only
1415 long lDlgCode
= DLGC_WANTCHARS
| DLGC_WANTARROWS
;
1419 // we may have several different cases:
1420 // 1. normal case: both TAB and ENTER are used for dlg navigation
1421 // 2. ctrl which wants TAB for itself: ENTER is used to pass to the
1422 // next control in the dialog
1423 // 3. ctrl which wants ENTER for itself: TAB is used for dialog
1425 // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go
1426 // to the next control
1428 // the multiline edit control should always get <Return> for itself
1429 if ( HasFlag(wxTE_PROCESS_ENTER
) || HasFlag(wxTE_MULTILINE
) )
1430 lDlgCode
|= DLGC_WANTMESSAGE
;
1432 if ( HasFlag(wxTE_PROCESS_TAB
) )
1433 lDlgCode
|= DLGC_WANTTAB
;
1439 // NB: use "=", not "|=" as the base class version returns the
1440 // same flags is this state as usual (i.e. including
1441 // DLGC_WANTMESSAGE). This is strange (how does it work in the
1442 // native Win32 apps?) but for now live with it.
1450 // ----------------------------------------------------------------------------
1451 // text control event processing
1452 // ----------------------------------------------------------------------------
1454 bool wxTextCtrl::SendUpdateEvent()
1456 // is event reporting suspended?
1457 if ( m_suppressNextUpdate
)
1459 // do process the next one
1460 m_suppressNextUpdate
= FALSE
;
1465 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, GetId());
1466 InitCommandEvent(event
);
1467 event
.SetString(GetValue());
1469 return ProcessCommand(event
);
1472 bool wxTextCtrl::MSWCommand(WXUINT param
, WXWORD
WXUNUSED(id
))
1479 wxFocusEvent
event(param
== EN_KILLFOCUS
? wxEVT_KILL_FOCUS
1482 event
.SetEventObject(this);
1483 GetEventHandler()->ProcessEvent(event
);
1492 // the text size limit has been hit -- try to increase it
1493 if ( !AdjustSpaceLimit() )
1495 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, m_windowId
);
1496 InitCommandEvent(event
);
1497 event
.SetString(GetValue());
1498 ProcessCommand(event
);
1502 // the other edit notification messages are not processed
1511 WXHBRUSH
wxTextCtrl::OnCtlColor(WXHDC pDC
, WXHWND
WXUNUSED(pWnd
), WXUINT
WXUNUSED(nCtlColor
),
1517 WXUINT
WXUNUSED(message
),
1518 WXWPARAM
WXUNUSED(wParam
),
1519 WXLPARAM
WXUNUSED(lParam
)
1526 HBRUSH hbrush
= Ctl3dCtlColorEx(message
, wParam
, lParam
);
1527 return (WXHBRUSH
) hbrush
;
1529 #endif // wxUSE_CTL3D
1532 if (GetParent()->GetTransparentBackground())
1533 SetBkMode(hdc
, TRANSPARENT
);
1535 SetBkMode(hdc
, OPAQUE
);
1537 wxColour colBack
= GetBackgroundColour();
1539 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE
) == 0)
1540 colBack
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
1542 ::SetBkColor(hdc
, wxColourToRGB(colBack
));
1543 ::SetTextColor(hdc
, wxColourToRGB(GetForegroundColour()));
1545 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(colBack
, wxSOLID
);
1547 return (WXHBRUSH
)brush
->GetResourceHandle();
1550 // In WIN16, need to override normal erasing because
1551 // Ctl3D doesn't use the wxWindows background colour.
1553 void wxTextCtrl::OnEraseBackground(wxEraseEvent
& event
)
1555 wxColour
col(m_backgroundColour
);
1559 col
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1563 ::GetClientRect(GetHwnd(), &rect
);
1565 COLORREF ref
= wxColourToRGB(col
);
1566 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
1568 wxLogLastError(wxT("CreateSolidBrush"));
1570 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
1572 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
1574 ::FillRect(hdc
, &rect
, hBrush
);
1575 ::DeleteObject(hBrush
);
1576 ::SetMapMode(hdc
, mode
);
1581 bool wxTextCtrl::AdjustSpaceLimit()
1584 unsigned int limit
= ::SendMessage(GetHwnd(), EM_GETLIMITTEXT
, 0, 0);
1586 // HACK: we try to automatically extend the limit for the amount of text
1587 // to allow (interactively) entering more than 64Kb of text under
1588 // Win9x but we shouldn't reset the text limit which was previously
1589 // set explicitly with SetMaxLength()
1591 // we could solve this by storing the limit we set in wxTextCtrl but
1592 // to save space we prefer to simply test here the actual limit
1593 // value: we consider that SetMaxLength() can only be called for
1595 if ( limit
< 0x8000 )
1597 // we've got more text than limit set by SetMaxLength()
1601 unsigned int len
= ::GetWindowTextLength(GetHwnd());
1604 limit
= len
+ 0x8000; // 32Kb
1609 // as a nice side effect, this also allows passing limit > 64Kb
1610 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT
, 0, limit
);
1613 #endif // wxUSE_RICHEDIT
1615 if ( limit
> 0xffff )
1617 // this will set it to a platform-dependent maximum (much more
1618 // than 64Kb under NT)
1622 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, limit
, 0);
1627 // we changed the limit
1631 bool wxTextCtrl::AcceptsFocus() const
1633 // we don't want focus if we can't be edited unless we're a multiline
1634 // control because then it might be still nice to get focus from keyboard
1635 // to be able to scroll it without mouse
1636 return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus();
1639 wxSize
wxTextCtrl::DoGetBestSize() const
1642 wxGetCharSize(GetHWND(), &cx
, &cy
, &GetFont());
1644 int wText
= DEFAULT_ITEM_WIDTH
;
1646 int hText
= EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy
);
1647 if ( m_windowStyle
& wxTE_MULTILINE
)
1649 hText
*= wxMax(GetNumberOfLines(), 5);
1651 //else: for single line control everything is ok
1653 return wxSize(wText
, hText
);
1656 // ----------------------------------------------------------------------------
1657 // standard handlers for standard edit menu events
1658 // ----------------------------------------------------------------------------
1660 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1665 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1670 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1675 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1680 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1685 void wxTextCtrl::OnDelete(wxCommandEvent
& event
)
1688 GetSelection(& from
, & to
);
1689 if (from
!= -1 && to
!= -1)
1693 void wxTextCtrl::OnSelectAll(wxCommandEvent
& event
)
1695 SetSelection(-1, -1);
1698 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1700 event
.Enable( CanCut() );
1703 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1705 event
.Enable( CanCopy() );
1708 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1710 event
.Enable( CanPaste() );
1713 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1715 event
.Enable( CanUndo() );
1718 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1720 event
.Enable( CanRedo() );
1723 void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent
& event
)
1726 GetSelection(& from
, & to
);
1727 event
.Enable(from
!= -1 && to
!= -1 && from
!= to
&& IsEditable()) ;
1730 void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent
& event
)
1732 event
.Enable(GetLastPosition() > 0);
1735 void wxTextCtrl::OnRightClick(wxMouseEvent
& event
)
1740 if (!m_privateContextMenu
)
1742 m_privateContextMenu
= new wxMenu
;
1743 m_privateContextMenu
->Append(wxID_UNDO
, _("&Undo"));
1744 m_privateContextMenu
->Append(wxID_REDO
, _("&Redo"));
1745 m_privateContextMenu
->AppendSeparator();
1746 m_privateContextMenu
->Append(wxID_CUT
, _("Cu&t"));
1747 m_privateContextMenu
->Append(wxID_COPY
, _("&Copy"));
1748 m_privateContextMenu
->Append(wxID_PASTE
, _("&Paste"));
1749 m_privateContextMenu
->Append(wxID_CLEAR
, _("&Delete"));
1750 m_privateContextMenu
->AppendSeparator();
1751 m_privateContextMenu
->Append(wxID_SELECTALL
, _("Select &All"));
1753 PopupMenu(m_privateContextMenu
, event
.GetPosition());
1761 // the rest of the file only deals with the rich edit controls
1764 // ----------------------------------------------------------------------------
1765 // EN_LINK processing
1766 // ----------------------------------------------------------------------------
1768 bool wxTextCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1770 NMHDR
*hdr
= (NMHDR
* )lParam
;
1771 switch ( hdr
->code
)
1775 const MSGFILTER
*msgf
= (MSGFILTER
*)lParam
;
1776 UINT msg
= msgf
->msg
;
1778 // this is a bit crazy but richedit 1.0 sends us all mouse
1779 // events _except_ WM_LBUTTONUP (don't ask me why) so we have
1780 // generate the wxWin events for this message manually
1782 // NB: in fact, this is still not totally correct as it does
1783 // send us WM_LBUTTONUP if the selection was cleared by the
1784 // last click -- so currently we get 2 events in this case,
1785 // but as I don't see any obvious way to check for this I
1786 // leave this code in place because it's still better than
1787 // not getting left up events at all
1788 if ( msg
== WM_LBUTTONUP
)
1790 WXUINT flags
= msgf
->wParam
;
1791 int x
= GET_X_LPARAM(msgf
->lParam
),
1792 y
= GET_Y_LPARAM(msgf
->lParam
);
1794 HandleMouseEvent(msg
, x
, y
, flags
);
1798 // return TRUE to process the event (and FALSE to ignore it)
1803 const ENLINK
*enlink
= (ENLINK
*)hdr
;
1805 switch ( enlink
->msg
)
1808 // ok, so it is hardcoded - do we really nee to
1810 ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND
)));
1815 case WM_LBUTTONDOWN
:
1817 case WM_LBUTTONDBLCLK
:
1818 case WM_RBUTTONDOWN
:
1820 case WM_RBUTTONDBLCLK
:
1821 // send a mouse event
1823 static const wxEventType eventsMouse
[] =
1834 // the event ids are consecutive
1836 evtMouse(eventsMouse
[enlink
->msg
- WM_MOUSEMOVE
]);
1838 InitMouseEvent(evtMouse
,
1839 GET_X_LPARAM(enlink
->lParam
),
1840 GET_Y_LPARAM(enlink
->lParam
),
1843 wxTextUrlEvent
event(m_windowId
, evtMouse
,
1845 enlink
->chrg
.cpMax
);
1847 InitCommandEvent(event
);
1849 *result
= ProcessCommand(event
);
1857 // not processed, leave it to the base class
1858 return wxTextCtrlBase::MSWOnNotify(idCtrl
, lParam
, result
);
1861 // ----------------------------------------------------------------------------
1862 // colour setting for the rich edit controls
1863 // ----------------------------------------------------------------------------
1865 bool wxTextCtrl::SetBackgroundColour(const wxColour
& colour
)
1867 if ( !wxTextCtrlBase::SetBackgroundColour(colour
) )
1869 // colour didn't really change
1875 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
1876 // EM_SETBKGNDCOLOR additionally
1877 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR
, 0, wxColourToRGB(colour
));
1883 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1885 if ( !wxTextCtrlBase::SetForegroundColour(colour
) )
1887 // colour didn't really change
1893 // change the colour of everything
1896 cf
.cbSize
= sizeof(cf
);
1897 cf
.dwMask
= CFM_COLOR
;
1898 cf
.crTextColor
= wxColourToRGB(colour
);
1899 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
, SCF_ALL
, (LPARAM
)&cf
);
1905 // ----------------------------------------------------------------------------
1906 // styling support for rich edit controls
1907 // ----------------------------------------------------------------------------
1911 bool wxTextCtrl::SetStyle(long start
, long end
, const wxTextAttr
& style
)
1915 // can't do it with normal text control
1919 // the richedit 1.0 doesn't handle setting background colour, so don't
1920 // even try to do anything if it's the only thing we want to change
1921 if ( m_verRichEdit
== 1 && !style
.HasFont() && !style
.HasTextColour() &&
1922 !style
.HasLeftIndent() && !style
.HasRightIndent() && !style
.HasAlignment() &&
1925 // nothing to do: return TRUE if there was really nothing to do and
1926 // FALSE if we failed to set bg colour
1927 return !style
.HasBackgroundColour();
1930 // order the range if needed
1938 // we can only change the format of the selection, so select the range we
1939 // want and restore the old selection later
1940 long startOld
, endOld
;
1941 GetSelection(&startOld
, &endOld
);
1943 // but do we really have to change the selection?
1944 bool changeSel
= start
!= startOld
|| end
!= endOld
;
1948 DoSetSelection(start
, end
, FALSE
/* don't scroll caret into view */);
1951 // initialize CHARFORMAT struct
1960 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
1961 // CHARFORMAT in that case
1963 if ( m_verRichEdit
== 1 )
1965 // this is the only thing the control is going to grok
1966 cf
.cbSize
= sizeof(CHARFORMAT
);
1971 // CHARFORMAT or CHARFORMAT2
1972 cf
.cbSize
= sizeof(cf
);
1975 if ( style
.HasFont() )
1977 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
1978 // but using it doesn't seem to hurt neither so leaving it for now
1980 cf
.dwMask
|= CFM_FACE
| CFM_SIZE
| CFM_CHARSET
|
1981 CFM_ITALIC
| CFM_BOLD
| CFM_UNDERLINE
;
1983 // fill in data from LOGFONT but recalculate lfHeight because we need
1984 // the real height in twips and not the negative number which
1985 // wxFillLogFont() returns (this is correct in general and works with
1986 // the Windows font mapper, but not here)
1988 wxFillLogFont(&lf
, &style
.GetFont());
1989 cf
.yHeight
= 20*style
.GetFont().GetPointSize(); // 1 pt = 20 twips
1990 cf
.bCharSet
= lf
.lfCharSet
;
1991 cf
.bPitchAndFamily
= lf
.lfPitchAndFamily
;
1992 wxStrncpy( cf
.szFaceName
, lf
.lfFaceName
, WXSIZEOF(cf
.szFaceName
) );
1994 // also deal with underline/italic/bold attributes: note that we must
1995 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
1996 // style to allow clearing it
1999 cf
.dwEffects
|= CFE_ITALIC
;
2002 if ( lf
.lfWeight
== FW_BOLD
)
2004 cf
.dwEffects
|= CFE_BOLD
;
2007 if ( lf
.lfUnderline
)
2009 cf
.dwEffects
|= CFE_UNDERLINE
;
2012 // strikeout fonts are not supported by wxWindows
2015 if ( style
.HasTextColour() )
2017 cf
.dwMask
|= CFM_COLOR
;
2018 cf
.crTextColor
= wxColourToRGB(style
.GetTextColour());
2022 if ( m_verRichEdit
!= 1 && style
.HasBackgroundColour() )
2024 cf
.dwMask
|= CFM_BACKCOLOR
;
2025 cf
.crBackColor
= wxColourToRGB(style
.GetBackgroundColour());
2027 #endif // wxUSE_RICHEDIT2
2029 // do format the selection
2030 bool ok
= ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
,
2031 SCF_SELECTION
, (LPARAM
)&cf
) != 0;
2034 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
2037 // now do the paragraph formatting
2040 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2041 // PARAFORMAT in that case
2043 if ( m_verRichEdit
== 1 )
2045 // this is the only thing the control is going to grok
2046 pf
.cbSize
= sizeof(PARAFORMAT
);
2051 // PARAFORMAT or PARAFORMAT2
2052 pf
.cbSize
= sizeof(pf
);
2055 if (style
.HasAlignment())
2057 pf
.dwMask
|= PFM_ALIGNMENT
;
2058 if (style
.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT
)
2059 pf
.wAlignment
= PFA_RIGHT
;
2060 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE
)
2061 pf
.wAlignment
= PFA_CENTER
;
2062 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED
)
2063 pf
.wAlignment
= PFA_JUSTIFY
;
2065 pf
.wAlignment
= PFA_LEFT
;
2068 if (style
.HasLeftIndent())
2070 pf
.dwMask
|= PFM_STARTINDENT
;
2072 // Convert from 1/10 mm to TWIPS
2073 pf
.dxStartIndent
= (int) (((double) style
.GetLeftIndent()) * mm2twips
/ 10.0) ;
2075 // TODO: do we need to specify dxOffset?
2078 if (style
.HasRightIndent())
2080 pf
.dwMask
|= PFM_RIGHTINDENT
;
2082 // Convert from 1/10 mm to TWIPS
2083 pf
.dxRightIndent
= (int) (((double) style
.GetRightIndent()) * mm2twips
/ 10.0) ;
2086 if (style
.HasTabs())
2088 pf
.dwMask
|= PFM_TABSTOPS
;
2090 const wxArrayInt
& tabs
= style
.GetTabs();
2092 pf
.cTabCount
= wxMin(tabs
.GetCount(), MAX_TAB_STOPS
);
2094 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2096 // Convert from 1/10 mm to TWIPS
2097 pf
.rgxTabs
[i
] = (int) (((double) tabs
[i
]) * mm2twips
/ 10.0) ;
2103 // do format the selection
2104 bool ok
= ::SendMessage(GetHwnd(), EM_SETPARAFORMAT
,
2105 0, (LPARAM
) &pf
) != 0;
2108 wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed"));
2114 // restore the original selection
2115 DoSetSelection(startOld
, endOld
, FALSE
);
2121 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr
& style
)
2123 if ( !wxTextCtrlBase::SetDefaultStyle(style
) )
2126 // we have to do this or the style wouldn't apply for the text typed by the
2128 long posLast
= GetLastPosition();
2129 SetStyle(posLast
, posLast
, m_defaultStyle
);
2134 bool wxTextCtrl::GetStyle(long WXUNUSED(position
), wxTextAttr
& WXUNUSED(style
))
2142 // ----------------------------------------------------------------------------
2144 // ----------------------------------------------------------------------------
2146 bool wxRichEditModule::OnInit()
2148 // don't do anything - we will load it when needed
2152 void wxRichEditModule::OnExit()
2154 for ( size_t i
= 0; i
< WXSIZEOF(ms_hRichEdit
); i
++ )
2156 if ( ms_hRichEdit
[i
] )
2158 ::FreeLibrary(ms_hRichEdit
[i
]);
2164 bool wxRichEditModule::Load(int version
)
2166 // we don't support loading richedit 3.0 as I don't know how to distinguish
2167 // it from 2.0 anyhow
2168 wxCHECK_MSG( version
== 1 || version
== 2, FALSE
,
2169 _T("incorrect richedit control version requested") );
2171 // make it the index in the array
2174 if ( ms_hRichEdit
[version
] == (HINSTANCE
)-1 )
2176 // we had already tried to load it and failed
2180 if ( ms_hRichEdit
[version
] )
2182 // we've already got this one
2186 wxString dllname
= version
? _T("riched20") : _T("riched32");
2187 dllname
+= _T(".dll");
2189 ms_hRichEdit
[version
] = ::LoadLibrary(dllname
);
2191 if ( !ms_hRichEdit
[version
] )
2193 wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname
.c_str());
2195 ms_hRichEdit
[version
] = (HINSTANCE
)-1;
2203 #endif // wxUSE_RICHEDIT
2205 #endif // wxUSE_TEXTCTRL