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 #include "wx/msw/missing.h"
70 #endif // wxUSE_RICHEDIT
72 // ----------------------------------------------------------------------------
74 // ----------------------------------------------------------------------------
78 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
);
80 #endif // wxUSE_RICHEDIT
82 // ----------------------------------------------------------------------------
84 // ----------------------------------------------------------------------------
88 // this module initializes RichEdit DLL(s) if needed
89 class wxRichEditModule
: public wxModule
92 virtual bool OnInit();
93 virtual void OnExit();
95 // load the richedit DLL of at least of required version
96 static bool Load(int version
= 1);
99 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
100 static HINSTANCE ms_hRichEdit
[2];
102 DECLARE_DYNAMIC_CLASS(wxRichEditModule
)
105 HINSTANCE
wxRichEditModule::ms_hRichEdit
[2] = { NULL
, NULL
};
107 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule
, wxModule
)
109 #endif // wxUSE_RICHEDIT
111 // ----------------------------------------------------------------------------
112 // event tables and other macros
113 // ----------------------------------------------------------------------------
115 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
117 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
118 EVT_CHAR(wxTextCtrl::OnChar
)
119 EVT_DROP_FILES(wxTextCtrl::OnDropFiles
)
122 EVT_RIGHT_UP(wxTextCtrl::OnRightClick
)
125 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
126 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
127 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
128 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
129 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
130 EVT_MENU(wxID_CLEAR
, wxTextCtrl::OnDelete
)
131 EVT_MENU(wxID_SELECTALL
, wxTextCtrl::OnSelectAll
)
133 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
134 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
135 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
136 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
137 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
138 EVT_UPDATE_UI(wxID_CLEAR
, wxTextCtrl::OnUpdateDelete
)
139 EVT_UPDATE_UI(wxID_SELECTALL
, wxTextCtrl::OnUpdateSelectAll
)
141 EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground
)
145 // ============================================================================
147 // ============================================================================
149 // ----------------------------------------------------------------------------
151 // ----------------------------------------------------------------------------
153 void wxTextCtrl::Init()
157 #endif // wxUSE_RICHEDIT
159 m_privateContextMenu
= NULL
;
160 m_suppressNextUpdate
= FALSE
;
163 wxTextCtrl::~wxTextCtrl()
165 if (m_privateContextMenu
)
167 delete m_privateContextMenu
;
168 m_privateContextMenu
= NULL
;
172 bool wxTextCtrl::Create(wxWindow
*parent
, wxWindowID id
,
173 const wxString
& value
,
177 const wxValidator
& validator
,
178 const wxString
& name
)
180 // base initialization
181 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
185 parent
->AddChild(this);
187 // translate wxWin style flags to MSW ones
188 WXDWORD msStyle
= MSWGetCreateWindowFlags();
190 // do create the control - either an EDIT or RICHEDIT
191 wxString windowClass
= wxT("EDIT");
194 if ( m_windowStyle
& wxTE_AUTO_URL
)
196 // automatic URL detection only works in RichEdit 2.0+
197 m_windowStyle
|= wxTE_RICH2
;
200 if ( m_windowStyle
& wxTE_RICH2
)
202 // using richedit 2.0 implies using wxTE_RICH
203 m_windowStyle
|= wxTE_RICH
;
206 // we need to load the richedit DLL before creating the rich edit control
207 if ( m_windowStyle
& wxTE_RICH
)
209 static bool s_errorGiven
= FALSE
;// MT-FIXME
211 // Which version do we need? Use 1.0 by default because it is much more
212 // like the the standard EDIT or 2.0 if explicitly requested, but use
213 // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
215 // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
216 // (and thus EDIT) much better than RichEdit 2.0 so we probably
217 // should use 3.0 if available as it is the best of both worlds -
218 // but as I can't test it right now I don't do it (VZ)
220 const int verRichEdit
= 2;
221 #else // !wxUSE_UNICODE
222 int verRichEdit
= m_windowStyle
& wxTE_RICH2
? 2 : 1;
223 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
225 // only give the error msg once if the DLL can't be loaded
228 // try to load the RichEdit DLL (will do nothing if already done)
229 if ( !wxRichEditModule::Load(verRichEdit
) )
232 // try another version?
233 verRichEdit
= 3 - verRichEdit
; // 1 <-> 2
235 if ( !wxRichEditModule::Load(verRichEdit
) )
236 #endif // wxUSE_UNICODE
238 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
245 // have we managed to load any richedit version?
248 m_verRichEdit
= verRichEdit
;
249 if ( m_verRichEdit
== 1 )
251 windowClass
= wxT("RICHEDIT");
255 #ifndef RICHEDIT_CLASS
256 wxString RICHEDIT_CLASS
;
257 RICHEDIT_CLASS
.Printf(_T("RichEdit%d0"), m_verRichEdit
);
259 RICHEDIT_CLASS
+= _T('W');
261 RICHEDIT_CLASS
+= _T('A');
262 #endif // Unicode/ANSI
263 #endif // !RICHEDIT_CLASS
265 windowClass
= RICHEDIT_CLASS
;
269 #endif // wxUSE_RICHEDIT
271 // we need to turn '\n's into "\r\n"s for the multiline controls
273 if ( m_windowStyle
& wxTE_MULTILINE
)
275 valueWin
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
282 if ( !MSWCreateControl(windowClass
, msStyle
, pos
, size
, valueWin
) )
285 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
290 // enable the events we're interested in: we want to get EN_CHANGE as
291 // for the normal controls
292 LPARAM mask
= ENM_CHANGE
;
294 if ( GetRichVersion() == 1 )
296 // we also need EN_MSGFILTER for richedit 1.0 for the reasons
297 // explained in its handler
298 mask
|= ENM_MOUSEEVENTS
;
300 else if ( m_windowStyle
& wxTE_AUTO_URL
)
304 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT
, TRUE
, 0);
307 ::SendMessage(GetHwnd(), EM_SETEVENTMASK
, 0, mask
);
309 #endif // wxUSE_RICHEDIT
314 // Make sure the window style (etc.) reflects the HWND style (roughly)
315 void wxTextCtrl::AdoptAttributesFromHWND()
317 wxWindow::AdoptAttributesFromHWND();
319 HWND hWnd
= GetHwnd();
320 long style
= ::GetWindowLong(hWnd
, GWL_STYLE
);
322 // retrieve the style to see whether this is an edit or richedit ctrl
324 wxString classname
= wxGetWindowClass(GetHWND());
326 if ( classname
.IsSameAs(_T("EDIT"), FALSE
/* no case */) )
333 if ( wxSscanf(classname
, _T("RichEdit%d0%c"), &m_verRichEdit
, &c
) != 2 )
335 wxLogDebug(_T("Unknown edit control '%s'."), classname
.c_str());
340 #endif // wxUSE_RICHEDIT
342 if (style
& ES_MULTILINE
)
343 m_windowStyle
|= wxTE_MULTILINE
;
344 if (style
& ES_PASSWORD
)
345 m_windowStyle
|= wxTE_PASSWORD
;
346 if (style
& ES_READONLY
)
347 m_windowStyle
|= wxTE_READONLY
;
348 if (style
& ES_WANTRETURN
)
349 m_windowStyle
|= wxTE_PROCESS_ENTER
;
350 if (style
& ES_CENTER
)
351 m_windowStyle
|= wxTE_CENTRE
;
352 if (style
& ES_RIGHT
)
353 m_windowStyle
|= wxTE_RIGHT
;
356 WXDWORD
wxTextCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
358 // default border for the text controls is the sunken one
359 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
361 style
|= wxBORDER_SUNKEN
;
364 long msStyle
= wxControl::MSWGetStyle(style
, exstyle
);
366 // styles which we alaways add by default
367 if ( style
& wxTE_MULTILINE
)
369 wxASSERT_MSG( !(style
& wxTE_PROCESS_ENTER
),
370 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
372 msStyle
|= ES_MULTILINE
| ES_WANTRETURN
;
373 if ( !(style
& wxTE_NO_VSCROLL
) )
375 // always adjust the vertical scrollbar automatically if we have it
376 msStyle
|= WS_VSCROLL
| ES_AUTOVSCROLL
;
379 // we have to use this style for the rich edit controls because
380 // without it the vertical scrollbar never appears at all in
381 // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it)
382 if ( style
& wxTE_RICH2
)
384 msStyle
|= ES_DISABLENOSCROLL
;
386 #endif // wxUSE_RICHEDIT
389 style
|= wxTE_PROCESS_ENTER
;
393 // there is really no reason to not have this style for single line
395 msStyle
|= ES_AUTOHSCROLL
;
398 // styles which we add depending on the specified wxWindows styles
399 if ( style
& wxHSCROLL
)
401 // automatically scroll the control horizontally as necessary
402 msStyle
|= WS_HSCROLL
;// | ES_AUTOHSCROLL;
405 if ( style
& wxTE_READONLY
)
406 msStyle
|= ES_READONLY
;
408 if ( style
& wxTE_PASSWORD
)
409 msStyle
|= ES_PASSWORD
;
411 if ( style
& wxTE_NOHIDESEL
)
412 msStyle
|= ES_NOHIDESEL
;
414 // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0
415 if ( style
& wxTE_CENTRE
)
416 msStyle
|= ES_CENTER
;
417 else if ( style
& wxTE_RIGHT
)
420 msStyle
|= ES_LEFT
; // ES_LEFT if 0 as well but for consistency...
425 void wxTextCtrl::SetWindowStyleFlag(long style
)
427 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
428 style
|= wxBORDER_SUNKEN
;
431 // we have to deal with some styles separately because they can't be
432 // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
433 // using richedit-specific EM_SETOPTIONS
435 ((style
& wxTE_NOHIDESEL
) != (GetWindowStyle() & wxTE_NOHIDESEL
)) )
437 bool set
= (style
& wxTE_NOHIDESEL
) != 0;
439 ::SendMessage(GetHwnd(), EM_SETOPTIONS
, set
? ECOOP_OR
: ECOOP_AND
,
440 set
? ECO_NOHIDESEL
: ~ECO_NOHIDESEL
);
442 #endif // wxUSE_RICHEDIT
444 wxControl::SetWindowStyleFlag(style
);
447 // ----------------------------------------------------------------------------
448 // set/get the controls text
449 // ----------------------------------------------------------------------------
451 wxString
wxTextCtrl::GetValue() const
453 // range 0..-1 is special for GetRange() and means to retrieve all text
454 return GetRange(0, -1);
457 wxString
wxTextCtrl::GetRange(long from
, long to
) const
461 if ( from
>= to
&& to
!= -1 )
463 // nothing to retrieve
470 int len
= GetWindowTextLength(GetHwnd());
473 // alloc one extra WORD as needed by the control
474 wxChar
*p
= str
.GetWriteBuf(++len
);
477 textRange
.chrg
.cpMin
= from
;
478 textRange
.chrg
.cpMax
= to
== -1 ? len
: to
;
479 textRange
.lpstrText
= p
;
481 (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE
, 0, (LPARAM
)&textRange
);
483 if ( m_verRichEdit
> 1 )
485 // RichEdit 2.0 uses just CR ('\r') for the newlines which is
486 // neither Unix nor Windows style - convert it to something
490 if ( *p
== _T('\r') )
497 if ( m_verRichEdit
== 1 )
499 // convert to the canonical form - see comment below
500 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
503 //else: no text at all, leave the string empty
506 #endif // wxUSE_RICHEDIT
509 str
= wxGetWindowText(GetHWND());
511 // need only a range?
514 str
= str
.Mid(from
, to
- from
);
517 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
518 // canonical one (same one as above) for consistency with the other kinds
519 // of controls and, more importantly, with the other ports
520 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
526 void wxTextCtrl::SetValue(const wxString
& value
)
528 // if the text is long enough, it's faster to just set it instead of first
529 // comparing it with the old one (chances are that it will be different
530 // anyhow, this comparison is there to avoid flicker for small single-line
531 // edit controls mostly)
532 if ( (value
.length() > 0x400) || (value
!= GetValue()) )
534 DoWriteText(value
, FALSE
/* not selection only */);
537 // we should reset the modified flag even if the value didn't really change
539 // mark the control as being not dirty - we changed its text, not the
543 // for compatibility, don't move the cursor when doing SetValue()
544 SetInsertionPoint(0);
547 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
549 DWORD CALLBACK
wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
553 wchar_t *wbuf
= (wchar_t *)buf
;
554 const wchar_t *wpc
= *(const wchar_t **)dwCookie
;
559 cb
-= sizeof(wchar_t);
560 (*pcb
) += sizeof(wchar_t);
563 *(const wchar_t **)dwCookie
= wpc
;
568 extern long wxEncodingToCodepage(wxFontEncoding encoding
); // from utils.cpp
570 #if wxUSE_UNICODE_MSLU
571 bool wxTextCtrl::StreamIn(const wxString
& value
,
572 wxFontEncoding
WXUNUSED(encoding
),
575 const wchar_t *wpc
= value
.c_str();
576 #else // !wxUSE_UNICODE_MSLU
577 bool wxTextCtrl::StreamIn(const wxString
& value
,
578 wxFontEncoding encoding
,
581 // we have to use EM_STREAMIN to force richedit control 2.0+ to show any
582 // text in the non default charset -- otherwise it thinks it knows better
583 // than we do and always shows it in the default one
585 // first get the Windows code page for this encoding
586 long codepage
= wxEncodingToCodepage(encoding
);
587 if ( codepage
== -1 )
593 // next translate to Unicode using this code page
594 int len
= ::MultiByteToWideChar(codepage
, 0, value
, -1, NULL
, 0);
597 wxWCharBuffer
wchBuf(len
);
599 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
602 if ( !::MultiByteToWideChar(codepage
, 0, value
, -1,
603 (wchar_t *)(const wchar_t *)wchBuf
, len
) )
605 wxLogLastError(_T("MultiByteToWideChar"));
608 // finally, stream it in the control
609 const wchar_t *wpc
= wchBuf
;
610 #endif // wxUSE_UNICODE_MSLU
614 eds
.dwCookie
= (DWORD
)&wpc
;
615 // the cast below is needed for broken (very) old mingw32 headers
616 eds
.pfnCallback
= (EDITSTREAMCALLBACK
)wxRichEditStreamIn
;
618 // we're going to receive 2 EN_CHANGE notifications if we got any selection
619 // (same problem as in DoWriteText())
620 if ( selectionOnly
&& HasSelection() )
622 // so suppress one of them
623 m_suppressNextUpdate
= TRUE
;
626 ::SendMessage(GetHwnd(), EM_STREAMIN
,
629 (selectionOnly
? SFF_SELECTION
: 0),
634 wxLogLastError(_T("EM_STREAMIN"));
639 #endif // !wxUSE_WCHAR_T
644 #endif // wxUSE_RICHEDIT
646 void wxTextCtrl::WriteText(const wxString
& value
)
651 void wxTextCtrl::DoWriteText(const wxString
& value
, bool selectionOnly
)
654 if ( m_windowStyle
& wxTE_MULTILINE
)
655 valueDos
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
660 // there are several complications with the rich edit controls here
664 // first, ensure that the new text will be in the default style
665 if ( !m_defaultStyle
.IsDefault() )
668 GetSelection(&start
, &end
);
669 SetStyle(start
, end
, m_defaultStyle
);
672 #if wxUSE_UNICODE_MSLU
673 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
674 // but EM_STREAMIN works
675 if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
677 done
= StreamIn(valueDos
, wxFONTENCODING_SYSTEM
, selectionOnly
);
679 #endif // wxUSE_UNICODE_MSLU
682 // next check if the text we're inserting must be shown in a non
683 // default charset -- this only works for RichEdit > 1.0
684 if ( GetRichVersion() > 1 )
686 wxFont font
= m_defaultStyle
.GetFont();
692 wxFontEncoding encoding
= font
.GetEncoding();
693 if ( encoding
!= wxFONTENCODING_SYSTEM
)
695 done
= StreamIn(valueDos
, encoding
, selectionOnly
);
699 #endif // !wxUSE_UNICODE
703 #endif // wxUSE_RICHEDIT
705 // in some cases we get 2 EN_CHANGE notifications after the SendMessage
706 // call below which is confusing for the client code and so should be
709 // these cases are: (a) plain EDIT controls if EM_REPLACESEL is used
710 // and there is a non empty selection currently and (b) rich text
711 // controls in any case
715 #endif // wxUSE_RICHEDIT
716 (selectionOnly
&& HasSelection()) )
718 m_suppressNextUpdate
= TRUE
;
721 ::SendMessage(GetHwnd(), selectionOnly
? EM_REPLACESEL
: WM_SETTEXT
,
722 0, (LPARAM
)valueDos
.c_str());
724 // OTOH, non rich text controls don't generate any events at all when
725 // we use WM_SETTEXT -- have to emulate them here
729 #endif // wxUSE_RICHEDIT
732 // Windows already sends an update event for single-line
734 if ( m_windowStyle
& wxTE_MULTILINE
)
742 void wxTextCtrl::AppendText(const wxString
& text
)
744 SetInsertionPointEnd();
749 if ( IsMultiLine() && GetRichVersion() > 1 )
751 // setting the caret to the end and showing it simply doesn't work for
752 // RichEdit 2.0 -- force it to still do what we want
753 ::SendMessage(GetHwnd(), EM_LINESCROLL
, 0, GetNumberOfLines());
755 #endif // wxUSE_RICHEDIT
758 void wxTextCtrl::Clear()
760 ::SetWindowText(GetHwnd(), wxT(""));
764 #endif // wxUSE_RICHEDIT
766 // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves
767 // but the normal ones don't -- make Clear() behaviour consistent by
768 // always sending this event
770 // Windows already sends an update event for single-line
772 if ( m_windowStyle
& wxTE_MULTILINE
)
779 bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent
& event
)
783 size_t lenOld
= GetValue().length();
785 wxUint32 code
= event
.GetRawKeyCode();
786 ::keybd_event(code
, 0, 0 /* key press */, 0);
787 ::keybd_event(code
, 0, KEYEVENTF_KEYUP
, 0);
789 // assume that any alphanumeric key changes the total number of characters
790 // in the control - this should work in 99% of cases
791 return GetValue().length() != lenOld
;
796 // ----------------------------------------------------------------------------
797 // Clipboard operations
798 // ----------------------------------------------------------------------------
800 void wxTextCtrl::Copy()
804 ::SendMessage(GetHwnd(), WM_COPY
, 0, 0L);
808 void wxTextCtrl::Cut()
812 ::SendMessage(GetHwnd(), WM_CUT
, 0, 0L);
816 void wxTextCtrl::Paste()
820 ::SendMessage(GetHwnd(), WM_PASTE
, 0, 0L);
824 bool wxTextCtrl::HasSelection() const
827 GetSelection(&from
, &to
);
831 bool wxTextCtrl::CanCopy() const
833 // Can copy if there's a selection
834 return HasSelection();
837 bool wxTextCtrl::CanCut() const
839 return CanCopy() && IsEditable();
842 bool wxTextCtrl::CanPaste() const
850 UINT cf
= 0; // 0 == any format
852 return ::SendMessage(GetHwnd(), EM_CANPASTE
, cf
, 0) != 0;
854 #endif // wxUSE_RICHEDIT
856 // Standard edit control: check for straight text on clipboard
857 if ( !::OpenClipboard(GetHwndOf(wxTheApp
->GetTopWindow())) )
860 bool isTextAvailable
= ::IsClipboardFormatAvailable(CF_TEXT
) != 0;
863 return isTextAvailable
;
866 // ----------------------------------------------------------------------------
868 // ----------------------------------------------------------------------------
870 void wxTextCtrl::SetEditable(bool editable
)
872 HWND hWnd
= GetHwnd();
873 SendMessage(hWnd
, EM_SETREADONLY
, (WPARAM
)!editable
, (LPARAM
)0L);
876 void wxTextCtrl::SetInsertionPoint(long pos
)
878 DoSetSelection(pos
, pos
);
881 void wxTextCtrl::SetInsertionPointEnd()
883 // we must not do anything if the caret is already there because calling
884 // SetInsertionPoint() thaws the controls if Freeze() had been called even
885 // if it doesn't actually move the caret anywhere and so the simple fact of
886 // doing it results in horrible flicker when appending big amounts of text
887 // to the control in a few chunks (see DoAddText() test in the text sample)
888 if ( GetInsertionPoint() == GetLastPosition() )
894 if ( m_verRichEdit
== 1 )
896 // we don't have to waste time calling GetLastPosition() in this case
899 else // !RichEdit 1.0
900 #endif // wxUSE_RICHEDIT
902 pos
= GetLastPosition();
905 SetInsertionPoint(pos
);
908 long wxTextCtrl::GetInsertionPoint() const
916 SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &range
);
919 #endif // wxUSE_RICHEDIT
921 DWORD Pos
= (DWORD
)SendMessage(GetHwnd(), EM_GETSEL
, 0, 0L);
925 long wxTextCtrl::GetLastPosition() const
927 int numLines
= GetNumberOfLines();
928 long posStartLastLine
= XYToPosition(0, numLines
- 1);
930 long lenLastLine
= GetLengthOfLineContainingPos(posStartLastLine
);
932 return posStartLastLine
+ lenLastLine
;
935 // If the return values from and to are the same, there is no
937 void wxTextCtrl::GetSelection(long* from
, long* to
) const
943 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &charRange
);
945 *from
= charRange
.cpMin
;
946 *to
= charRange
.cpMax
;
949 #endif // !wxUSE_RICHEDIT
951 DWORD dwStart
, dwEnd
;
952 ::SendMessage(GetHwnd(), EM_GETSEL
, (WPARAM
)&dwStart
, (LPARAM
)&dwEnd
);
959 bool wxTextCtrl::IsEditable() const
961 // strangely enough, we may be called before the control is created: our
962 // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls
967 long style
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
969 return (style
& ES_READONLY
) == 0;
972 // ----------------------------------------------------------------------------
974 // ----------------------------------------------------------------------------
976 void wxTextCtrl::SetSelection(long from
, long to
)
978 // if from and to are both -1, it means (in wxWindows) that all text should
979 // be selected - translate into Windows convention
980 if ( (from
== -1) && (to
== -1) )
986 DoSetSelection(from
, to
);
989 void wxTextCtrl::DoSetSelection(long from
, long to
, bool scrollCaret
)
991 HWND hWnd
= GetHwnd();
1000 SendMessage(hWnd
, EM_EXSETSEL
, 0, (LPARAM
) &range
);
1003 #endif // wxUSE_RICHEDIT
1005 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)from
, (LPARAM
)to
);
1011 // richedit 3.0 (i.e. the version living in riched20.dll distributed
1012 // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when
1013 // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL
1014 // option is set (but it does work ok in richedit 1.0 mode...)
1016 // so to make it work we either need to give focus to it here which
1017 // will probably create many problems (dummy focus events; window
1018 // containing the text control being brought to foreground
1019 // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may
1020 // create other problems too -- and in fact it does because if we turn
1021 // on/off this style while appending the text to the control, the
1022 // vertical scrollbar never appears in it even if we append tons of
1023 // text and to work around this the only solution I found was to use
1024 // ES_DISABLENOSCROLL
1026 // this is very ugly but I don't see any other way to make this work
1027 if ( GetRichVersion() > 1 )
1029 if ( !HasFlag(wxTE_NOHIDESEL
) )
1031 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1032 ECOOP_OR
, ECO_NOHIDESEL
);
1034 //else: everything is already ok
1036 #endif // wxUSE_RICHEDIT
1038 SendMessage(hWnd
, EM_SCROLLCARET
, (WPARAM
)0, (LPARAM
)0);
1041 // restore ECO_NOHIDESEL if we changed it
1042 if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL
) )
1044 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1045 ECOOP_AND
, ~ECO_NOHIDESEL
);
1047 #endif // wxUSE_RICHEDIT
1050 // WPARAM is 0: selection is scrolled into view
1051 SendMessage(hWnd
, EM_SETSEL
, (WPARAM
)0, (LPARAM
)MAKELONG(from
, to
));
1055 // ----------------------------------------------------------------------------
1057 // ----------------------------------------------------------------------------
1059 void wxTextCtrl::Replace(long from
, long to
, const wxString
& value
)
1061 // Set selection and remove it
1062 DoSetSelection(from
, to
, FALSE
/* don't scroll caret into view */);
1064 SendMessage(GetHwnd(), EM_REPLACESEL
,
1070 (LPARAM
)value
.c_str());
1073 void wxTextCtrl::Remove(long from
, long to
)
1075 Replace(from
, to
, _T(""));
1078 bool wxTextCtrl::LoadFile(const wxString
& file
)
1080 if ( wxTextCtrlBase::LoadFile(file
) )
1082 // update the size limit if needed
1091 bool wxTextCtrl::IsModified() const
1093 return SendMessage(GetHwnd(), EM_GETMODIFY
, 0, 0) != 0;
1096 // Makes 'unmodified'
1097 void wxTextCtrl::DiscardEdits()
1099 SendMessage(GetHwnd(), EM_SETMODIFY
, FALSE
, 0L);
1102 int wxTextCtrl::GetNumberOfLines() const
1104 return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT
, (WPARAM
)0, (LPARAM
)0);
1107 long wxTextCtrl::XYToPosition(long x
, long y
) const
1109 // This gets the char index for the _beginning_ of this line
1110 long charIndex
= SendMessage(GetHwnd(), EM_LINEINDEX
, (WPARAM
)y
, (LPARAM
)0);
1112 return charIndex
+ x
;
1115 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1117 HWND hWnd
= GetHwnd();
1119 // This gets the line number containing the character
1124 lineNo
= SendMessage(hWnd
, EM_EXLINEFROMCHAR
, 0, (LPARAM
)pos
);
1127 #endif // wxUSE_RICHEDIT
1129 lineNo
= SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, 0);
1138 // This gets the char index for the _beginning_ of this line
1139 long charIndex
= SendMessage(hWnd
, EM_LINEINDEX
, (WPARAM
)lineNo
, (LPARAM
)0);
1140 if ( charIndex
== -1 )
1145 // The X position must therefore be the different between pos and charIndex
1147 *x
= pos
- charIndex
;
1154 void wxTextCtrl::ShowPosition(long pos
)
1156 HWND hWnd
= GetHwnd();
1158 // To scroll to a position, we pass the number of lines and characters
1159 // to scroll *by*. This means that we need to:
1160 // (1) Find the line position of the current line.
1161 // (2) Find the line position of pos.
1162 // (3) Scroll by (pos - current).
1163 // For now, ignore the horizontal scrolling.
1165 // Is this where scrolling is relative to - the line containing the caret?
1166 // Or is the first visible line??? Try first visible line.
1167 // int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
1169 int currentLineLineNo
= (int)SendMessage(hWnd
, EM_GETFIRSTVISIBLELINE
, (WPARAM
)0, (LPARAM
)0L);
1171 int specifiedLineLineNo
= (int)SendMessage(hWnd
, EM_LINEFROMCHAR
, (WPARAM
)pos
, (LPARAM
)0L);
1173 int linesToScroll
= specifiedLineLineNo
- currentLineLineNo
;
1175 if (linesToScroll
!= 0)
1176 (void)SendMessage(hWnd
, EM_LINESCROLL
, (WPARAM
)0, (LPARAM
)linesToScroll
);
1179 long wxTextCtrl::GetLengthOfLineContainingPos(long pos
) const
1181 return ::SendMessage(GetHwnd(), EM_LINELENGTH
, (WPARAM
)pos
, 0);
1184 int wxTextCtrl::GetLineLength(long lineNo
) const
1186 long pos
= XYToPosition(0, lineNo
);
1188 return GetLengthOfLineContainingPos(pos
);
1191 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1193 size_t len
= (size_t)GetLineLength(lineNo
) + 1;
1195 // there must be at least enough place for the length WORD in the
1197 len
+= sizeof(WORD
);
1200 wxChar
*buf
= str
.GetWriteBuf(len
);
1202 *(WORD
*)buf
= (WORD
)len
;
1203 len
= (size_t)::SendMessage(GetHwnd(), EM_GETLINE
, lineNo
, (LPARAM
)buf
);
1206 str
.UngetWriteBuf(len
);
1211 void wxTextCtrl::SetMaxLength(unsigned long len
)
1213 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, len
, 0);
1216 // ----------------------------------------------------------------------------
1218 // ----------------------------------------------------------------------------
1220 void wxTextCtrl::Undo()
1224 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1228 void wxTextCtrl::Redo()
1232 // Same as Undo, since Undo undoes the undo, i.e. a redo.
1233 ::SendMessage(GetHwnd(), EM_UNDO
, 0, 0);
1237 bool wxTextCtrl::CanUndo() const
1239 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1242 bool wxTextCtrl::CanRedo() const
1244 return ::SendMessage(GetHwnd(), EM_CANUNDO
, 0, 0) != 0;
1247 // ----------------------------------------------------------------------------
1248 // implemenation details
1249 // ----------------------------------------------------------------------------
1251 void wxTextCtrl::Command(wxCommandEvent
& event
)
1253 SetValue(event
.GetString());
1254 ProcessCommand (event
);
1257 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1259 // By default, load the first file into the text window.
1260 if (event
.GetNumberOfFiles() > 0)
1262 LoadFile(event
.GetFiles()[0]);
1266 // ----------------------------------------------------------------------------
1267 // kbd input processing
1268 // ----------------------------------------------------------------------------
1270 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG
* pMsg
)
1272 MSG
*msg
= (MSG
*)pMsg
;
1274 // check for our special keys here: if we don't do it and the parent frame
1275 // uses them as accelerators, they wouldn't work at all, so we disable
1276 // usual preprocessing for them
1277 if ( msg
->message
== WM_KEYDOWN
)
1279 WORD vkey
= (WORD
) msg
->wParam
;
1280 if ( (HIWORD(msg
->lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
1282 if ( vkey
== VK_BACK
)
1287 // we want to process some Ctrl-foo and Shift-bar but no key
1288 // combinations without either Ctrl or Shift nor with both of them
1290 const int ctrl
= wxIsCtrlDown(),
1291 shift
= wxIsShiftDown();
1292 switch ( ctrl
+ shift
)
1295 wxFAIL_MSG( _T("how many modifiers have we got?") );
1303 // either Ctrl or Shift pressed
1318 else // Shift is pressed
1320 if ( vkey
== VK_INSERT
|| vkey
== VK_DELETE
)
1327 return wxControl::MSWShouldPreProcessMessage(pMsg
);
1330 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1332 switch ( event
.GetKeyCode() )
1335 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1337 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1338 InitCommandEvent(event
);
1339 event
.SetString(GetValue());
1340 if ( GetEventHandler()->ProcessEvent(event
) )
1343 //else: multiline controls need Enter for themselves
1348 // always produce navigation event - even if we process TAB
1349 // ourselves the fact that we got here means that the user code
1350 // decided to skip processing of this TAB - probably to let it
1351 // do its default job.
1353 wxNavigationKeyEvent eventNav
;
1354 eventNav
.SetDirection(!event
.ShiftDown());
1355 eventNav
.SetWindowChange(event
.ControlDown());
1356 eventNav
.SetEventObject(this);
1358 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1364 // no, we didn't process it
1368 long wxTextCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1370 long lRc
= wxTextCtrlBase::MSWWindowProc(nMsg
, wParam
, lParam
);
1372 if ( nMsg
== WM_GETDLGCODE
)
1374 // we always want the chars and the arrows: the arrows for navigation
1375 // and the chars because we want Ctrl-C to work even in a read only
1377 long lDlgCode
= DLGC_WANTCHARS
| DLGC_WANTARROWS
;
1381 // we may have several different cases:
1382 // 1. normal case: both TAB and ENTER are used for dlg navigation
1383 // 2. ctrl which wants TAB for itself: ENTER is used to pass to the
1384 // next control in the dialog
1385 // 3. ctrl which wants ENTER for itself: TAB is used for dialog
1387 // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go
1388 // to the next control
1390 // the multiline edit control should always get <Return> for itself
1391 if ( HasFlag(wxTE_PROCESS_ENTER
) || HasFlag(wxTE_MULTILINE
) )
1392 lDlgCode
|= DLGC_WANTMESSAGE
;
1394 if ( HasFlag(wxTE_PROCESS_TAB
) )
1395 lDlgCode
|= DLGC_WANTTAB
;
1401 // NB: use "=", not "|=" as the base class version returns the
1402 // same flags is this state as usual (i.e. including
1403 // DLGC_WANTMESSAGE). This is strange (how does it work in the
1404 // native Win32 apps?) but for now live with it.
1412 // ----------------------------------------------------------------------------
1413 // text control event processing
1414 // ----------------------------------------------------------------------------
1416 bool wxTextCtrl::SendUpdateEvent()
1418 // is event reporting suspended?
1419 if ( m_suppressNextUpdate
)
1421 // do process the next one
1422 m_suppressNextUpdate
= FALSE
;
1427 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, GetId());
1428 InitCommandEvent(event
);
1429 event
.SetString(GetValue());
1431 return ProcessCommand(event
);
1434 bool wxTextCtrl::MSWCommand(WXUINT param
, WXWORD
WXUNUSED(id
))
1441 wxFocusEvent
event(param
== EN_KILLFOCUS
? wxEVT_KILL_FOCUS
1444 event
.SetEventObject(this);
1445 GetEventHandler()->ProcessEvent(event
);
1454 // the text size limit has been hit -- try to increase it
1455 if ( !AdjustSpaceLimit() )
1457 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, m_windowId
);
1458 InitCommandEvent(event
);
1459 event
.SetString(GetValue());
1460 ProcessCommand(event
);
1464 // the other edit notification messages are not processed
1473 WXHBRUSH
wxTextCtrl::OnCtlColor(WXHDC pDC
, WXHWND
WXUNUSED(pWnd
), WXUINT
WXUNUSED(nCtlColor
),
1479 WXUINT
WXUNUSED(message
),
1480 WXWPARAM
WXUNUSED(wParam
),
1481 WXLPARAM
WXUNUSED(lParam
)
1488 HBRUSH hbrush
= Ctl3dCtlColorEx(message
, wParam
, lParam
);
1489 return (WXHBRUSH
) hbrush
;
1491 #endif // wxUSE_CTL3D
1494 if (GetParent()->GetTransparentBackground())
1495 SetBkMode(hdc
, TRANSPARENT
);
1497 SetBkMode(hdc
, OPAQUE
);
1499 wxColour colBack
= GetBackgroundColour();
1501 if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE
) == 0)
1502 colBack
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
1504 ::SetBkColor(hdc
, wxColourToRGB(colBack
));
1505 ::SetTextColor(hdc
, wxColourToRGB(GetForegroundColour()));
1507 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(colBack
, wxSOLID
);
1509 return (WXHBRUSH
)brush
->GetResourceHandle();
1512 // In WIN16, need to override normal erasing because
1513 // Ctl3D doesn't use the wxWindows background colour.
1515 void wxTextCtrl::OnEraseBackground(wxEraseEvent
& event
)
1517 wxColour
col(m_backgroundColour
);
1521 col
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1525 ::GetClientRect(GetHwnd(), &rect
);
1527 COLORREF ref
= wxColourToRGB(col
);
1528 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
1530 wxLogLastError(wxT("CreateSolidBrush"));
1532 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
1534 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
1536 ::FillRect(hdc
, &rect
, hBrush
);
1537 ::DeleteObject(hBrush
);
1538 ::SetMapMode(hdc
, mode
);
1543 bool wxTextCtrl::AdjustSpaceLimit()
1546 unsigned int limit
= ::SendMessage(GetHwnd(), EM_GETLIMITTEXT
, 0, 0);
1548 // HACK: we try to automatically extend the limit for the amount of text
1549 // to allow (interactively) entering more than 64Kb of text under
1550 // Win9x but we shouldn't reset the text limit which was previously
1551 // set explicitly with SetMaxLength()
1553 // we could solve this by storing the limit we set in wxTextCtrl but
1554 // to save space we prefer to simply test here the actual limit
1555 // value: we consider that SetMaxLength() can only be called for
1557 if ( limit
< 0x8000 )
1559 // we've got more text than limit set by SetMaxLength()
1563 unsigned int len
= ::GetWindowTextLength(GetHwnd());
1566 limit
= len
+ 0x8000; // 32Kb
1571 // as a nice side effect, this also allows passing limit > 64Kb
1572 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT
, 0, limit
);
1575 #endif // wxUSE_RICHEDIT
1577 if ( limit
> 0xffff )
1579 // this will set it to a platform-dependent maximum (much more
1580 // than 64Kb under NT)
1584 ::SendMessage(GetHwnd(), EM_LIMITTEXT
, limit
, 0);
1589 // we changed the limit
1593 bool wxTextCtrl::AcceptsFocus() const
1595 // we don't want focus if we can't be edited unless we're a multiline
1596 // control because then it might be still nice to get focus from keyboard
1597 // to be able to scroll it without mouse
1598 return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus();
1601 wxSize
wxTextCtrl::DoGetBestSize() const
1604 wxGetCharSize(GetHWND(), &cx
, &cy
, &GetFont());
1606 int wText
= DEFAULT_ITEM_WIDTH
;
1608 int hText
= EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy
);
1609 if ( m_windowStyle
& wxTE_MULTILINE
)
1611 hText
*= wxMax(GetNumberOfLines(), 5);
1613 //else: for single line control everything is ok
1615 return wxSize(wText
, hText
);
1618 // ----------------------------------------------------------------------------
1619 // standard handlers for standard edit menu events
1620 // ----------------------------------------------------------------------------
1622 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1627 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1632 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1637 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1642 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1647 void wxTextCtrl::OnDelete(wxCommandEvent
& event
)
1650 GetSelection(& from
, & to
);
1651 if (from
!= -1 && to
!= -1)
1655 void wxTextCtrl::OnSelectAll(wxCommandEvent
& event
)
1657 SetSelection(-1, -1);
1660 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1662 event
.Enable( CanCut() );
1665 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1667 event
.Enable( CanCopy() );
1670 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1672 event
.Enable( CanPaste() );
1675 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1677 event
.Enable( CanUndo() );
1680 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1682 event
.Enable( CanRedo() );
1685 void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent
& event
)
1688 GetSelection(& from
, & to
);
1689 event
.Enable(from
!= -1 && to
!= -1 && from
!= to
&& IsEditable()) ;
1692 void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent
& event
)
1694 event
.Enable(GetLastPosition() > 0);
1697 void wxTextCtrl::OnRightClick(wxMouseEvent
& event
)
1702 if (!m_privateContextMenu
)
1704 m_privateContextMenu
= new wxMenu
;
1705 m_privateContextMenu
->Append(wxID_UNDO
, _("&Undo"));
1706 m_privateContextMenu
->Append(wxID_REDO
, _("&Redo"));
1707 m_privateContextMenu
->AppendSeparator();
1708 m_privateContextMenu
->Append(wxID_CUT
, _("Cu&t"));
1709 m_privateContextMenu
->Append(wxID_COPY
, _("&Copy"));
1710 m_privateContextMenu
->Append(wxID_PASTE
, _("&Paste"));
1711 m_privateContextMenu
->Append(wxID_CLEAR
, _("&Delete"));
1712 m_privateContextMenu
->AppendSeparator();
1713 m_privateContextMenu
->Append(wxID_SELECTALL
, _("Select &All"));
1715 PopupMenu(m_privateContextMenu
, event
.GetPosition());
1723 // the rest of the file only deals with the rich edit controls
1726 // ----------------------------------------------------------------------------
1727 // EN_LINK processing
1728 // ----------------------------------------------------------------------------
1730 bool wxTextCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1732 NMHDR
*hdr
= (NMHDR
* )lParam
;
1733 switch ( hdr
->code
)
1737 const MSGFILTER
*msgf
= (MSGFILTER
*)lParam
;
1738 UINT msg
= msgf
->msg
;
1740 // this is a bit crazy but richedit 1.0 sends us all mouse
1741 // events _except_ WM_LBUTTONUP (don't ask me why) so we have
1742 // generate the wxWin events for this message manually
1744 // NB: in fact, this is still not totally correct as it does
1745 // send us WM_LBUTTONUP if the selection was cleared by the
1746 // last click -- so currently we get 2 events in this case,
1747 // but as I don't see any obvious way to check for this I
1748 // leave this code in place because it's still better than
1749 // not getting left up events at all
1750 if ( msg
== WM_LBUTTONUP
)
1752 WXUINT flags
= msgf
->wParam
;
1753 int x
= GET_X_LPARAM(msgf
->lParam
),
1754 y
= GET_Y_LPARAM(msgf
->lParam
);
1756 HandleMouseEvent(msg
, x
, y
, flags
);
1760 // return TRUE to process the event (and FALSE to ignore it)
1765 const ENLINK
*enlink
= (ENLINK
*)hdr
;
1767 switch ( enlink
->msg
)
1770 // ok, so it is hardcoded - do we really nee to
1772 ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND
)));
1777 case WM_LBUTTONDOWN
:
1779 case WM_LBUTTONDBLCLK
:
1780 case WM_RBUTTONDOWN
:
1782 case WM_RBUTTONDBLCLK
:
1783 // send a mouse event
1785 static const wxEventType eventsMouse
[] =
1796 // the event ids are consecutive
1798 evtMouse(eventsMouse
[enlink
->msg
- WM_MOUSEMOVE
]);
1800 InitMouseEvent(evtMouse
,
1801 GET_X_LPARAM(enlink
->lParam
),
1802 GET_Y_LPARAM(enlink
->lParam
),
1805 wxTextUrlEvent
event(m_windowId
, evtMouse
,
1807 enlink
->chrg
.cpMax
);
1809 InitCommandEvent(event
);
1811 *result
= ProcessCommand(event
);
1819 // not processed, leave it to the base class
1820 return wxTextCtrlBase::MSWOnNotify(idCtrl
, lParam
, result
);
1823 // ----------------------------------------------------------------------------
1824 // colour setting for the rich edit controls
1825 // ----------------------------------------------------------------------------
1827 bool wxTextCtrl::SetBackgroundColour(const wxColour
& colour
)
1829 if ( !wxTextCtrlBase::SetBackgroundColour(colour
) )
1831 // colour didn't really change
1837 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
1838 // EM_SETBKGNDCOLOR additionally
1839 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR
, 0, wxColourToRGB(colour
));
1845 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1847 if ( !wxTextCtrlBase::SetForegroundColour(colour
) )
1849 // colour didn't really change
1855 // change the colour of everything
1858 cf
.cbSize
= sizeof(cf
);
1859 cf
.dwMask
= CFM_COLOR
;
1860 cf
.crTextColor
= wxColourToRGB(colour
);
1861 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
, SCF_ALL
, (LPARAM
)&cf
);
1867 // ----------------------------------------------------------------------------
1868 // styling support for rich edit controls
1869 // ----------------------------------------------------------------------------
1873 bool wxTextCtrl::SetStyle(long start
, long end
, const wxTextAttr
& style
)
1877 // can't do it with normal text control
1881 // the richedit 1.0 doesn't handle setting background colour, so don't
1882 // even try to do anything if it's the only thing we want to change
1883 if ( m_verRichEdit
== 1 && !style
.HasFont() && !style
.HasTextColour() &&
1884 !style
.HasLeftIndent() && !style
.HasRightIndent() && !style
.HasAlignment() &&
1887 // nothing to do: return TRUE if there was really nothing to do and
1888 // FALSE if we failed to set bg colour
1889 return !style
.HasBackgroundColour();
1892 // order the range if needed
1900 // we can only change the format of the selection, so select the range we
1901 // want and restore the old selection later
1902 long startOld
, endOld
;
1903 GetSelection(&startOld
, &endOld
);
1905 // but do we really have to change the selection?
1906 bool changeSel
= start
!= startOld
|| end
!= endOld
;
1910 DoSetSelection(start
, end
, FALSE
/* don't scroll caret into view */);
1913 // initialize CHARFORMAT struct
1922 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
1923 // CHARFORMAT in that case
1925 if ( m_verRichEdit
== 1 )
1927 // this is the only thing the control is going to grok
1928 cf
.cbSize
= sizeof(CHARFORMAT
);
1933 // CHARFORMAT or CHARFORMAT2
1934 cf
.cbSize
= sizeof(cf
);
1937 if ( style
.HasFont() )
1939 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
1940 // but using it doesn't seem to hurt neither so leaving it for now
1942 cf
.dwMask
|= CFM_FACE
| CFM_SIZE
| CFM_CHARSET
|
1943 CFM_ITALIC
| CFM_BOLD
| CFM_UNDERLINE
;
1945 // fill in data from LOGFONT but recalculate lfHeight because we need
1946 // the real height in twips and not the negative number which
1947 // wxFillLogFont() returns (this is correct in general and works with
1948 // the Windows font mapper, but not here)
1950 wxFillLogFont(&lf
, &style
.GetFont());
1951 cf
.yHeight
= 20*style
.GetFont().GetPointSize(); // 1 pt = 20 twips
1952 cf
.bCharSet
= lf
.lfCharSet
;
1953 cf
.bPitchAndFamily
= lf
.lfPitchAndFamily
;
1954 wxStrncpy( cf
.szFaceName
, lf
.lfFaceName
, WXSIZEOF(cf
.szFaceName
) );
1956 // also deal with underline/italic/bold attributes: note that we must
1957 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
1958 // style to allow clearing it
1961 cf
.dwEffects
|= CFE_ITALIC
;
1964 if ( lf
.lfWeight
== FW_BOLD
)
1966 cf
.dwEffects
|= CFE_BOLD
;
1969 if ( lf
.lfUnderline
)
1971 cf
.dwEffects
|= CFE_UNDERLINE
;
1974 // strikeout fonts are not supported by wxWindows
1977 if ( style
.HasTextColour() )
1979 cf
.dwMask
|= CFM_COLOR
;
1980 cf
.crTextColor
= wxColourToRGB(style
.GetTextColour());
1984 if ( m_verRichEdit
!= 1 && style
.HasBackgroundColour() )
1986 cf
.dwMask
|= CFM_BACKCOLOR
;
1987 cf
.crBackColor
= wxColourToRGB(style
.GetBackgroundColour());
1989 #endif // wxUSE_RICHEDIT2
1991 // do format the selection
1992 bool ok
= ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
,
1993 SCF_SELECTION
, (LPARAM
)&cf
) != 0;
1996 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
1999 // now do the paragraph formatting
2002 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2003 // PARAFORMAT in that case
2005 if ( m_verRichEdit
== 1 )
2007 // this is the only thing the control is going to grok
2008 pf
.cbSize
= sizeof(PARAFORMAT
);
2013 // PARAFORMAT or PARAFORMAT2
2014 pf
.cbSize
= sizeof(pf
);
2017 if (style
.HasAlignment())
2019 pf
.dwMask
|= PFM_ALIGNMENT
;
2020 if (style
.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT
)
2021 pf
.wAlignment
= PFA_RIGHT
;
2022 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE
)
2023 pf
.wAlignment
= PFA_CENTER
;
2024 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED
)
2025 pf
.wAlignment
= PFA_JUSTIFY
;
2027 pf
.wAlignment
= PFA_LEFT
;
2030 if (style
.HasLeftIndent())
2032 pf
.dwMask
|= PFM_STARTINDENT
;
2034 // Convert from 1/10 mm to TWIPS
2035 pf
.dxStartIndent
= (int) (((double) style
.GetLeftIndent()) * mm2twips
/ 10.0) ;
2037 // TODO: do we need to specify dxOffset?
2040 if (style
.HasRightIndent())
2042 pf
.dwMask
|= PFM_RIGHTINDENT
;
2044 // Convert from 1/10 mm to TWIPS
2045 pf
.dxRightIndent
= (int) (((double) style
.GetRightIndent()) * mm2twips
/ 10.0) ;
2048 if (style
.HasTabs())
2050 pf
.dwMask
|= PFM_TABSTOPS
;
2052 const wxArrayInt
& tabs
= style
.GetTabs();
2054 pf
.cTabCount
= wxMin(tabs
.GetCount(), MAX_TAB_STOPS
);
2056 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2058 // Convert from 1/10 mm to TWIPS
2059 pf
.rgxTabs
[i
] = (int) (((double) tabs
[i
]) * mm2twips
/ 10.0) ;
2065 // do format the selection
2066 bool ok
= ::SendMessage(GetHwnd(), EM_SETPARAFORMAT
,
2067 0, (LPARAM
) &pf
) != 0;
2070 wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed"));
2076 // restore the original selection
2077 DoSetSelection(startOld
, endOld
, FALSE
);
2083 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr
& style
)
2085 if ( !wxTextCtrlBase::SetDefaultStyle(style
) )
2088 // we have to do this or the style wouldn't apply for the text typed by the
2090 long posLast
= GetLastPosition();
2091 SetStyle(posLast
, posLast
, m_defaultStyle
);
2096 bool wxTextCtrl::GetStyle(long position
, wxTextAttr
& style
)
2100 // can't do it with normal text control
2104 // initialize CHARFORMAT struct
2113 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2114 // CHARFORMAT in that case
2116 if ( m_verRichEdit
== 1 )
2118 // this is the only thing the control is going to grok
2119 cf
.cbSize
= sizeof(CHARFORMAT
);
2124 // CHARFORMAT or CHARFORMAT2
2125 cf
.cbSize
= sizeof(cf
);
2127 // we can only change the format of the selection, so select the range we
2128 // want and restore the old selection later
2129 long startOld
, endOld
;
2130 GetSelection(&startOld
, &endOld
);
2132 // but do we really have to change the selection?
2133 bool changeSel
= position
!= startOld
|| position
!= endOld
;
2137 DoSetSelection(position
, position
, FALSE
/* don't scroll caret into view */);
2140 // get the selection formatting
2141 (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT
,
2142 SCF_SELECTION
, (LPARAM
)&cf
) ;
2145 lf
.lfHeight
= cf
.yHeight
;
2147 lf
.lfCharSet
= ANSI_CHARSET
; // FIXME: how to get correct charset?
2148 lf
.lfClipPrecision
= 0;
2149 lf
.lfEscapement
= 0;
2150 wxStrcpy(lf
.lfFaceName
, cf
.szFaceName
);
2151 if (cf
.dwEffects
& CFE_ITALIC
)
2153 lf
.lfOrientation
= 0;
2154 lf
.lfPitchAndFamily
= cf
.bPitchAndFamily
;
2156 if (cf
.dwEffects
& CFE_STRIKEOUT
)
2157 lf
.lfStrikeOut
= TRUE
;
2158 if (cf
.dwEffects
& CFE_UNDERLINE
)
2159 lf
.lfUnderline
= TRUE
;
2160 if (cf
.dwEffects
& CFE_BOLD
)
2161 lf
.lfWeight
= FW_BOLD
;
2163 wxFont font
= wxCreateFontFromLogFont(& lf
);
2166 style
.SetFont(font
);
2168 style
.SetTextColour(wxColour(cf
.crTextColor
));
2171 if ( m_verRichEdit
!= 1 )
2173 // cf.dwMask |= CFM_BACKCOLOR;
2174 style
.SetBackgroundColour(wxColour(cf
.crBackColor
));
2176 #endif // wxUSE_RICHEDIT2
2178 // now get the paragraph formatting
2181 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2182 // PARAFORMAT in that case
2184 if ( m_verRichEdit
== 1 )
2186 // this is the only thing the control is going to grok
2187 pf
.cbSize
= sizeof(PARAFORMAT
);
2192 // PARAFORMAT or PARAFORMAT2
2193 pf
.cbSize
= sizeof(pf
);
2196 // do format the selection
2197 (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT
, 0, (LPARAM
) &pf
) ;
2199 style
.SetLeftIndent( (int) ((double) pf
.dxStartIndent
* twips2mm
* 10.0) );
2200 style
.SetRightIndent( (int) ((double) pf
.dxRightIndent
* twips2mm
* 10.0) );
2202 if (pf
.wAlignment
== PFA_CENTER
)
2203 style
.SetAlignment(wxTEXT_ALIGNMENT_CENTRE
);
2204 else if (pf
.wAlignment
== PFA_RIGHT
)
2205 style
.SetAlignment(wxTEXT_ALIGNMENT_RIGHT
);
2206 else if (pf
.wAlignment
== PFA_JUSTIFY
)
2207 style
.SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED
);
2209 style
.SetAlignment(wxTEXT_ALIGNMENT_LEFT
);
2211 wxArrayInt tabStops
;
2213 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2215 tabStops
[i
] = (int) ((double) (pf
.rgxTabs
[i
] & 0xFFFF) * twips2mm
* 10.0) ;
2220 // restore the original selection
2221 DoSetSelection(startOld
, endOld
, FALSE
);
2229 // ----------------------------------------------------------------------------
2231 // ----------------------------------------------------------------------------
2233 bool wxRichEditModule::OnInit()
2235 // don't do anything - we will load it when needed
2239 void wxRichEditModule::OnExit()
2241 for ( size_t i
= 0; i
< WXSIZEOF(ms_hRichEdit
); i
++ )
2243 if ( ms_hRichEdit
[i
] )
2245 ::FreeLibrary(ms_hRichEdit
[i
]);
2251 bool wxRichEditModule::Load(int version
)
2253 // we don't support loading richedit 3.0 as I don't know how to distinguish
2254 // it from 2.0 anyhow
2255 wxCHECK_MSG( version
== 1 || version
== 2, FALSE
,
2256 _T("incorrect richedit control version requested") );
2258 // make it the index in the array
2261 if ( ms_hRichEdit
[version
] == (HINSTANCE
)-1 )
2263 // we had already tried to load it and failed
2267 if ( ms_hRichEdit
[version
] )
2269 // we've already got this one
2273 wxString dllname
= version
? _T("riched20") : _T("riched32");
2274 dllname
+= _T(".dll");
2276 ms_hRichEdit
[version
] = ::LoadLibrary(dllname
);
2278 if ( !ms_hRichEdit
[version
] )
2280 wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname
.c_str());
2282 ms_hRichEdit
[version
] = (HINSTANCE
)-1;
2290 #endif // wxUSE_RICHEDIT
2292 #endif // wxUSE_TEXTCTRL