1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/textctrl.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #if wxUSE_TEXTCTRL && !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
30 #include "wx/textctrl.h"
31 #include "wx/settings.h"
39 #include "wx/module.h"
40 #include "wx/wxcrtvararg.h"
43 #include "wx/sysopt.h"
46 #include "wx/clipbrd.h"
49 #include "wx/textfile.h"
53 #include "wx/msw/private.h"
54 #include "wx/msw/winundef.h"
55 #include "wx/msw/mslu.h"
61 #include <sys/types.h>
67 #include "wx/dynlib.h"
70 // old mingw32 has richedit stuff directly in windows.h and doesn't have
72 #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
76 #endif // wxUSE_RICHEDIT
78 #include "wx/msw/missing.h"
80 #if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
82 // dummy value used for m_dropTarget, different from any valid pointer value
83 // (which are all even under Windows) and NULL
85 wxRICHTEXT_DEFAULT_DROPTARGET
= wx_reinterpret_cast(wxDropTarget
*, 1);
87 #endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
89 // ----------------------------------------------------------------------------
91 // ----------------------------------------------------------------------------
95 // this module initializes RichEdit DLL(s) if needed
96 class wxRichEditModule
: public wxModule
101 Version_1
, // riched32.dll
102 Version_2or3
, // both use riched20.dll
103 Version_41
, // msftedit.dll (XP SP1 and Windows 2003)
107 virtual bool OnInit();
108 virtual void OnExit();
110 // load the richedit DLL for the specified version of rich edit
111 static bool Load(Version version
);
114 // load the InkEdit library
115 static bool LoadInkEdit();
119 // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
120 static HINSTANCE ms_hRichEdit
[Version_Max
];
123 static wxDynamicLibrary ms_inkEditLib
;
124 static bool ms_inkEditLibLoadAttemped
;
127 DECLARE_DYNAMIC_CLASS(wxRichEditModule
)
130 HINSTANCE
wxRichEditModule::ms_hRichEdit
[Version_Max
] = { NULL
, NULL
, NULL
};
133 wxDynamicLibrary
wxRichEditModule::ms_inkEditLib
;
134 bool wxRichEditModule::ms_inkEditLibLoadAttemped
= false;
137 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule
, wxModule
)
139 #endif // wxUSE_RICHEDIT
141 // a small class used to set m_updatesCount to 0 (to filter duplicate events if
142 // necessary) and to reset it back to -1 afterwards
143 class UpdatesCountFilter
146 UpdatesCountFilter(int& count
)
149 wxASSERT_MSG( m_count
== -1 || m_count
== -2,
150 _T("wrong initial m_updatesCount value") );
154 //else: we don't want to count how many update events we get as we're going
155 // to ignore all of them
158 ~UpdatesCountFilter()
163 // return true if an event has been received
164 bool GotUpdate() const
172 DECLARE_NO_COPY_CLASS(UpdatesCountFilter
)
175 // ----------------------------------------------------------------------------
176 // event tables and other macros
177 // ----------------------------------------------------------------------------
179 #if wxUSE_EXTENDED_RTTI
180 WX_DEFINE_FLAGS( wxTextCtrlStyle
)
182 wxBEGIN_FLAGS( wxTextCtrlStyle
)
183 // new style border flags, we put them first to
184 // use them for streaming out
185 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
186 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
187 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
188 wxFLAGS_MEMBER(wxBORDER_RAISED
)
189 wxFLAGS_MEMBER(wxBORDER_STATIC
)
190 wxFLAGS_MEMBER(wxBORDER_NONE
)
192 // old style border flags
193 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
194 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
195 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
196 wxFLAGS_MEMBER(wxRAISED_BORDER
)
197 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
198 wxFLAGS_MEMBER(wxBORDER
)
200 // standard window styles
201 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
202 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
203 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
204 wxFLAGS_MEMBER(wxWANTS_CHARS
)
205 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
206 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
207 wxFLAGS_MEMBER(wxVSCROLL
)
208 wxFLAGS_MEMBER(wxHSCROLL
)
210 wxFLAGS_MEMBER(wxTE_PROCESS_ENTER
)
211 wxFLAGS_MEMBER(wxTE_PROCESS_TAB
)
212 wxFLAGS_MEMBER(wxTE_MULTILINE
)
213 wxFLAGS_MEMBER(wxTE_PASSWORD
)
214 wxFLAGS_MEMBER(wxTE_READONLY
)
215 wxFLAGS_MEMBER(wxHSCROLL
)
216 wxFLAGS_MEMBER(wxTE_RICH
)
217 wxFLAGS_MEMBER(wxTE_RICH2
)
218 wxFLAGS_MEMBER(wxTE_AUTO_URL
)
219 wxFLAGS_MEMBER(wxTE_NOHIDESEL
)
220 wxFLAGS_MEMBER(wxTE_LEFT
)
221 wxFLAGS_MEMBER(wxTE_CENTRE
)
222 wxFLAGS_MEMBER(wxTE_RIGHT
)
223 wxFLAGS_MEMBER(wxTE_DONTWRAP
)
224 wxFLAGS_MEMBER(wxTE_CHARWRAP
)
225 wxFLAGS_MEMBER(wxTE_WORDWRAP
)
227 wxEND_FLAGS( wxTextCtrlStyle
)
229 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTextCtrl
, wxControl
,"wx/textctrl.h")
231 wxBEGIN_PROPERTIES_TABLE(wxTextCtrl
)
232 wxEVENT_PROPERTY( TextUpdated
, wxEVT_COMMAND_TEXT_UPDATED
, wxCommandEvent
)
233 wxEVENT_PROPERTY( TextEnter
, wxEVT_COMMAND_TEXT_ENTER
, wxCommandEvent
)
235 wxPROPERTY( Font
, wxFont
, SetFont
, GetFont
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
236 wxPROPERTY( Value
, wxString
, SetValue
, GetValue
, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
237 wxPROPERTY_FLAGS( WindowStyle
, wxTextCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
238 wxEND_PROPERTIES_TABLE()
240 wxBEGIN_HANDLERS_TABLE(wxTextCtrl
)
241 wxEND_HANDLERS_TABLE()
243 wxCONSTRUCTOR_6( wxTextCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxString
, Value
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
245 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxTextCtrlBase
)
249 BEGIN_EVENT_TABLE(wxTextCtrl
, wxTextCtrlBase
)
250 EVT_CHAR(wxTextCtrl::OnChar
)
251 EVT_KEY_DOWN(wxTextCtrl::OnKeyDown
)
252 EVT_DROP_FILES(wxTextCtrl::OnDropFiles
)
255 EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu
)
258 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
259 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
260 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
261 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
262 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
263 EVT_MENU(wxID_CLEAR
, wxTextCtrl::OnDelete
)
264 EVT_MENU(wxID_SELECTALL
, wxTextCtrl::OnSelectAll
)
266 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
267 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
268 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
269 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
270 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
271 EVT_UPDATE_UI(wxID_CLEAR
, wxTextCtrl::OnUpdateDelete
)
272 EVT_UPDATE_UI(wxID_SELECTALL
, wxTextCtrl::OnUpdateSelectAll
)
274 EVT_SET_FOCUS(wxTextCtrl::OnSetFocus
)
277 // ============================================================================
279 // ============================================================================
281 // ----------------------------------------------------------------------------
283 // ----------------------------------------------------------------------------
285 void wxTextCtrl::Init()
289 #endif // wxUSE_RICHEDIT
291 #if wxUSE_INKEDIT && wxUSE_RICHEDIT
295 m_privateContextMenu
= NULL
;
297 m_isNativeCaretShown
= true;
300 wxTextCtrl::~wxTextCtrl()
302 #if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
303 if ( m_dropTarget
== wxRICHTEXT_DEFAULT_DROPTARGET
)
305 // don't try to destroy this dummy pointer in the base class dtor
308 #endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
310 delete m_privateContextMenu
;
313 bool wxTextCtrl::Create(wxWindow
*parent
,
315 const wxString
& value
,
319 const wxValidator
& validator
,
320 const wxString
& name
)
322 // base initialization
323 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
326 if ( !MSWCreateText(value
, pos
, size
) )
329 #if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
332 // rich text controls have a default associated drop target which
333 // allows them to receive (rich) text dropped on them, which is nice,
334 // but prevents us from associating a user-defined drop target with
335 // them as we need to unregister the old one first
337 // to make it work, we set m_dropTarget to this special value initially
338 // and check for it in our SetDropTarget()
339 m_dropTarget
= wxRICHTEXT_DEFAULT_DROPTARGET
;
341 #endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
346 // returns true if the platform should explicitly apply a theme border
347 bool wxTextCtrl::CanApplyThemeBorder() const
352 // Standard text control already handles theming
353 return ((GetWindowStyle() & (wxTE_RICH
|wxTE_RICH2
)) != 0);
357 bool wxTextCtrl::MSWCreateText(const wxString
& value
,
361 // translate wxWin style flags to MSW ones
362 WXDWORD msStyle
= MSWGetCreateWindowFlags();
364 // do create the control - either an EDIT or RICHEDIT
365 wxString windowClass
= wxT("EDIT");
367 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
368 // A control that capitalizes the first letter
369 if ( HasFlag(wxTE_CAPITALIZE
) )
370 windowClass
= wxT("CAPEDIT");
374 if ( m_windowStyle
& wxTE_AUTO_URL
)
376 // automatic URL detection only works in RichEdit 2.0+
377 m_windowStyle
|= wxTE_RICH2
;
380 if ( m_windowStyle
& wxTE_RICH2
)
382 // using richedit 2.0 implies using wxTE_RICH
383 m_windowStyle
|= wxTE_RICH
;
386 // we need to load the richedit DLL before creating the rich edit control
387 if ( m_windowStyle
& wxTE_RICH
)
389 // versions 2.0, 3.0 and 4.1 of rich edit are mostly compatible with
390 // each other but not with version 1.0, so we have separate flags for
391 // the version 1.0 and the others (and so m_verRichEdit may be 0 (plain
392 // EDIT control), 1 for version 1.0 or 2 for any higher version)
394 // notice that 1.0 has no Unicode support at all so in Unicode build we
395 // must use another version
399 #else // !wxUSE_UNICODE
400 m_verRichEdit
= m_windowStyle
& wxTE_RICH2
? 2 : 1;
401 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
404 // First test if we can load an ink edit control. Normally, all edit
405 // controls will be made ink edit controls if a tablet environment is
406 // found (or if msw.inkedit != 0 and the InkEd.dll is present).
407 // However, an application can veto ink edit controls by either specifying
408 // msw.inkedit = 0 or by removing wxTE_RICH[2] from the style.
410 if ((wxSystemSettings::HasFeature(wxSYS_TABLET_PRESENT
) || wxSystemOptions::GetOptionInt(wxT("msw.inkedit")) != 0) &&
411 !(wxSystemOptions::HasOption(wxT("msw.inkedit")) && wxSystemOptions::GetOptionInt(wxT("msw.inkedit")) == 0))
413 if (wxRichEditModule::LoadInkEdit())
415 windowClass
= INKEDIT_CLASS
;
417 #if wxUSE_INKEDIT && wxUSE_RICHEDIT
421 // Fake rich text version for other calls
429 if ( m_verRichEdit
== 2 )
431 if ( wxRichEditModule::Load(wxRichEditModule::Version_41
) )
433 // yes, class name for version 4.1 really is 5.0
434 windowClass
= _T("RICHEDIT50W");
436 else if ( wxRichEditModule::Load(wxRichEditModule::Version_2or3
) )
438 windowClass
= _T("RichEdit20")
443 #endif // Unicode/ANSI
445 else // failed to load msftedit.dll and riched20.dll
451 if ( m_verRichEdit
== 1 )
453 if ( wxRichEditModule::Load(wxRichEditModule::Version_1
) )
455 windowClass
= _T("RICHEDIT");
457 else // failed to load any richedit control DLL
459 // only give the error msg once if the DLL can't be loaded
460 static bool s_errorGiven
= false; // MT ok as only used by GUI
464 wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
474 #endif // wxUSE_RICHEDIT
476 // we need to turn '\n's into "\r\n"s for the multiline controls
478 if ( m_windowStyle
& wxTE_MULTILINE
)
480 valueWin
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
487 // suppress events sent during control creation: we're called either from
488 // the ctor and then we shouldn't generate any events for compatibility
489 // with the other ports, or from SetWindowStyleFlag() and then we shouldn't
490 // generate the events because our text doesn't really change, the fact
491 // that we (sometimes) need to recreate the control is just an
492 // implementation detail
495 if ( !MSWCreateControl(windowClass
.wx_str(), msStyle
, pos
, size
, valueWin
) )
506 // Pass IEM_InsertText (0) as wParam, in order to have the ink always
507 // converted to text.
508 ::SendMessage(GetHwnd(), EM_SETINKINSERTMODE
, 0, 0);
510 // Make sure the mouse can be used for input
511 ::SendMessage(GetHwnd(), EM_SETUSEMOUSEFORINPUT
, 1, 0);
515 // enable the events we're interested in: we want to get EN_CHANGE as
516 // for the normal controls
517 LPARAM mask
= ENM_CHANGE
;
519 if (GetRichVersion() == 1 && !IsInkEdit())
521 // we also need EN_MSGFILTER for richedit 1.0 for the reasons
522 // explained in its handler
523 mask
|= ENM_MOUSEEVENTS
;
525 // we also need to force the appearance of the vertical scrollbar
526 // initially as otherwise the control doesn't refresh correctly
527 // after resize: but once the vertical scrollbar had been shown
528 // (even if it's subsequently hidden) it does
530 // this is clearly a bug and for now it has been only noticed under
531 // Windows XP, so if we're sure it works correctly under other
532 // systems we could do this only for XP
533 SetSize(-1, 1); // 1 is small enough to force vert scrollbar
534 SetInitialSize(size
);
536 else if ( m_windowStyle
& wxTE_AUTO_URL
)
540 ::SendMessage(GetHwnd(), EM_AUTOURLDETECT
, TRUE
, 0);
543 ::SendMessage(GetHwnd(), EM_SETEVENTMASK
, 0, mask
);
545 #endif // wxUSE_RICHEDIT
548 // Without this, if we pass the size in the constructor and then don't change it,
549 // the themed borders will be drawn incorrectly.
550 SetWindowPos(GetHwnd(), NULL
, 0, 0, 0, 0,
551 SWP_NOZORDER
|SWP_NOMOVE
|SWP_NOSIZE
|SWP_NOACTIVATE
|
558 // Make sure the window style (etc.) reflects the HWND style (roughly)
559 void wxTextCtrl::AdoptAttributesFromHWND()
561 wxWindow::AdoptAttributesFromHWND();
563 HWND hWnd
= GetHwnd();
564 long style
= ::GetWindowLong(hWnd
, GWL_STYLE
);
566 // retrieve the style to see whether this is an edit or richedit ctrl
568 wxString classname
= wxGetWindowClass(GetHWND());
570 if ( classname
.IsSameAs(_T("EDIT"), false /* no case */) )
577 if ( wxSscanf(classname
, _T("RichEdit%d0%c"), &m_verRichEdit
, &c
) != 2 )
579 wxLogDebug(_T("Unknown edit control '%s'."), classname
.c_str());
584 #endif // wxUSE_RICHEDIT
586 if (style
& ES_MULTILINE
)
587 m_windowStyle
|= wxTE_MULTILINE
;
588 if (style
& ES_PASSWORD
)
589 m_windowStyle
|= wxTE_PASSWORD
;
590 if (style
& ES_READONLY
)
591 m_windowStyle
|= wxTE_READONLY
;
592 if (style
& ES_WANTRETURN
)
593 m_windowStyle
|= wxTE_PROCESS_ENTER
;
594 if (style
& ES_CENTER
)
595 m_windowStyle
|= wxTE_CENTRE
;
596 if (style
& ES_RIGHT
)
597 m_windowStyle
|= wxTE_RIGHT
;
600 WXDWORD
wxTextCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
602 long msStyle
= wxControl::MSWGetStyle(style
, exstyle
);
604 // styles which we always add by default
605 if ( style
& wxTE_MULTILINE
)
607 msStyle
|= ES_MULTILINE
| ES_WANTRETURN
;
608 if ( !(style
& wxTE_NO_VSCROLL
) )
610 // always adjust the vertical scrollbar automatically if we have it
611 msStyle
|= WS_VSCROLL
| ES_AUTOVSCROLL
;
614 // we have to use this style for the rich edit controls because
615 // without it the vertical scrollbar never appears at all in
616 // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it)
617 if ( style
& wxTE_RICH2
)
619 msStyle
|= ES_DISABLENOSCROLL
;
621 #endif // wxUSE_RICHEDIT
624 style
|= wxTE_PROCESS_ENTER
;
628 // there is really no reason to not have this style for single line
630 msStyle
|= ES_AUTOHSCROLL
;
633 // note that wxTE_DONTWRAP is the same as wxHSCROLL so if we have a horz
634 // scrollbar, there is no wrapping -- which makes sense
635 if ( style
& wxTE_DONTWRAP
)
637 // automatically scroll the control horizontally as necessary
639 // NB: ES_AUTOHSCROLL is needed for richedit controls or they don't
640 // show horz scrollbar at all, even in spite of WS_HSCROLL, and as
641 // it doesn't seem to do any harm for plain edit controls, add it
643 msStyle
|= WS_HSCROLL
| ES_AUTOHSCROLL
;
646 if ( style
& wxTE_READONLY
)
647 msStyle
|= ES_READONLY
;
649 if ( style
& wxTE_PASSWORD
)
650 msStyle
|= ES_PASSWORD
;
652 if ( style
& wxTE_NOHIDESEL
)
653 msStyle
|= ES_NOHIDESEL
;
655 // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0
656 if ( style
& wxTE_CENTRE
)
657 msStyle
|= ES_CENTER
;
658 else if ( style
& wxTE_RIGHT
)
661 msStyle
|= ES_LEFT
; // ES_LEFT is 0 as well but for consistency...
666 void wxTextCtrl::SetWindowStyleFlag(long style
)
668 // changing the alignment of the control dynamically works under Win2003
669 // (but not older Windows version: it seems to work under some versions of
670 // XP but not other ones, and we have no way to determine it so be
671 // conservative here) and only for plain EDIT controls (not RICH ones) and
672 // we have to recreate the control to make it always work
673 if ( IsRich() || wxGetWinVersion() < wxWinVersion_2003
)
675 const long alignMask
= wxTE_LEFT
| wxTE_CENTRE
| wxTE_RIGHT
;
676 if ( (style
& alignMask
) != (GetWindowStyle() & alignMask
) )
678 const wxString value
= GetValue();
679 const wxPoint pos
= GetPosition();
680 const wxSize size
= GetSize();
682 // delete the old window
683 HWND hwnd
= GetHwnd();
685 ::DestroyWindow(hwnd
);
687 // create the new one with the updated flags
688 m_windowStyle
= style
;
689 MSWCreateText(value
, pos
, size
);
691 // and make sure it has the same attributes as before
694 // calling SetFont(m_font) would do nothing as the code would
695 // notice that the font didn't change, so force it to believe
697 wxFont font
= m_font
;
704 wxColour colFg
= m_foregroundColour
;
705 m_foregroundColour
= wxNullColour
;
706 SetForegroundColour(colFg
);
711 wxColour colBg
= m_backgroundColour
;
712 m_backgroundColour
= wxNullColour
;
713 SetBackgroundColour(colBg
);
716 // note that text styles are lost but this is probably not a big
717 // problem: if you use styles, you probably don't use nor change
718 // alignment flags anyhow
725 // we have to deal with some styles separately because they can't be
726 // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
727 // using richedit-specific EM_SETOPTIONS
729 ((style
& wxTE_NOHIDESEL
) != (GetWindowStyle() & wxTE_NOHIDESEL
)) )
731 bool set
= (style
& wxTE_NOHIDESEL
) != 0;
733 ::SendMessage(GetHwnd(), EM_SETOPTIONS
, set
? ECOOP_OR
: ECOOP_AND
,
734 set
? ECO_NOHIDESEL
: ~ECO_NOHIDESEL
);
736 #endif // wxUSE_RICHEDIT
738 wxControl::SetWindowStyleFlag(style
);
741 // ----------------------------------------------------------------------------
742 // set/get the controls text
743 // ----------------------------------------------------------------------------
745 bool wxTextCtrl::IsEmpty() const
747 // this is an optimization for multiline controls containing a lot of text
748 if ( IsMultiLine() && GetNumberOfLines() != 1 )
751 return wxTextCtrlBase::IsEmpty();
754 wxString
wxTextCtrl::GetValue() const
756 // range 0..-1 is special for GetRange() and means to retrieve all text
757 return GetRange(0, -1);
760 wxString
wxTextCtrl::GetRange(long from
, long to
) const
764 if ( from
>= to
&& to
!= -1 )
766 // nothing to retrieve
773 int len
= GetWindowTextLength(GetHwnd());
780 // we must use EM_STREAMOUT if we don't want to lose all characters
781 // not representable in the current character set (EM_GETTEXTRANGE
782 // simply replaces them with question marks...)
783 if ( GetRichVersion() > 1 )
785 // we must have some encoding, otherwise any 8bit chars in the
786 // control are simply *lost* (replaced by '?')
787 wxFontEncoding encoding
= wxFONTENCODING_SYSTEM
;
789 wxFont font
= m_defaultStyle
.GetFont();
795 encoding
= font
.GetEncoding();
799 if ( encoding
== wxFONTENCODING_SYSTEM
)
801 encoding
= wxLocale::GetSystemEncoding();
805 if ( encoding
== wxFONTENCODING_SYSTEM
)
807 encoding
= wxFONTENCODING_ISO8859_1
;
810 str
= StreamOut(encoding
);
814 // we have to manually extract the required part, luckily
815 // this is easy in this case as EOL characters in str are
816 // just LFs because we remove CRs in wxRichEditStreamOut
817 str
= str
.Mid(from
, to
- from
);
821 // StreamOut() wasn't used or failed, try to do it in normal way
823 #endif // !wxUSE_UNICODE
825 // alloc one extra WORD as needed by the control
826 wxStringBuffer
tmp(str
, ++len
);
830 textRange
.chrg
.cpMin
= from
;
831 textRange
.chrg
.cpMax
= to
;
832 textRange
.lpstrText
= p
;
834 (void)::SendMessage(GetHwnd(), EM_GETTEXTRANGE
,
835 0, (LPARAM
)&textRange
);
837 if ( m_verRichEdit
> 1 )
839 // RichEdit 2.0 uses just CR ('\r') for the
840 // newlines which is neither Unix nor Windows
841 // style - convert it to something reasonable
844 if ( *p
== _T('\r') )
850 if ( m_verRichEdit
== 1 )
852 // convert to the canonical form - see comment below
853 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
856 //else: no text at all, leave the string empty
859 #endif // wxUSE_RICHEDIT
862 str
= wxGetWindowText(GetHWND());
864 // need only a range?
867 str
= str
.Mid(from
, to
- from
);
870 // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
871 // canonical one (same one as above) for consistency with the other kinds
872 // of controls and, more importantly, with the other ports
873 str
= wxTextFile::Translate(str
, wxTextFileType_Unix
);
879 void wxTextCtrl::DoSetValue(const wxString
& value
, int flags
)
881 // if the text is long enough, it's faster to just set it instead of first
882 // comparing it with the old one (chances are that it will be different
883 // anyhow, this comparison is there to avoid flicker for small single-line
884 // edit controls mostly)
885 if ( (value
.length() > 0x400) || (value
!= GetValue()) )
887 DoWriteText(value
, flags
/* doesn't include SelectionOnly here */);
889 // mark the control as being not dirty - we changed its text, not the
893 // for compatibility, don't move the cursor when doing SetValue()
894 SetInsertionPoint(0);
898 // still reset the modified flag even if the value didn't really change
899 // because now it comes from the program and not the user (and do it
900 // before generating the event so that the event handler could get the
901 // expected value from IsModified())
904 // still send an event for consistency
905 if (flags
& SetValue_SendEvent
)
910 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
912 // TODO: using memcpy() would improve performance a lot for big amounts of text
915 wxRichEditStreamIn(DWORD dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
919 const wchar_t ** const ppws
= (const wchar_t **)dwCookie
;
921 wchar_t *wbuf
= (wchar_t *)buf
;
922 const wchar_t *wpc
= *ppws
;
927 cb
-= sizeof(wchar_t);
928 (*pcb
) += sizeof(wchar_t);
936 // helper struct used to pass parameters from wxTextCtrl to wxRichEditStreamOut
937 struct wxStreamOutData
944 wxRichEditStreamOut(DWORD_PTR dwCookie
, BYTE
*buf
, LONG cb
, LONG
*pcb
)
948 wxStreamOutData
*data
= (wxStreamOutData
*)dwCookie
;
950 const wchar_t *wbuf
= (const wchar_t *)buf
;
951 wchar_t *wpc
= data
->wpc
;
954 wchar_t wch
= *wbuf
++;
956 // turn "\r\n" into "\n" on the fly
962 cb
-= sizeof(wchar_t);
963 (*pcb
) += sizeof(wchar_t);
972 #if wxUSE_UNICODE_MSLU
973 #define UNUSED_IF_MSLU(param)
975 #define UNUSED_IF_MSLU(param) param
979 wxTextCtrl::StreamIn(const wxString
& value
,
980 wxFontEncoding
UNUSED_IF_MSLU(encoding
),
983 #if wxUSE_UNICODE_MSLU
984 const wchar_t *wpc
= value
.c_str();
985 #else // !wxUSE_UNICODE_MSLU
986 wxCSConv
conv(encoding
);
988 const size_t len
= conv
.MB2WC(NULL
, value
.mb_str(), value
.length());
990 if (len
== wxCONV_FAILED
)
994 wxWCharBuffer
wchBuf(len
);
995 wchar_t *wpc
= wchBuf
.data();
997 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
998 wchar_t *wpc
= wchBuf
;
1001 conv
.MB2WC(wpc
, value
.mb_str(), value
.length());
1002 #endif // wxUSE_UNICODE_MSLU
1004 // finally, stream it in the control
1007 eds
.dwCookie
= (DWORD
)&wpc
;
1008 // the cast below is needed for broken (very) old mingw32 headers
1009 eds
.pfnCallback
= (EDITSTREAMCALLBACK
)wxRichEditStreamIn
;
1011 // same problem as in DoWriteText(): we can get multiple events here
1012 UpdatesCountFilter
ucf(m_updatesCount
);
1014 ::SendMessage(GetHwnd(), EM_STREAMIN
,
1017 (selectionOnly
? SFF_SELECTION
: 0),
1020 // It's okay for EN_UPDATE to not be sent if the selection is empty and
1021 // the text is empty, otherwise warn the programmer about it.
1022 wxASSERT_MSG( ucf
.GotUpdate() || ( !HasSelection() && value
.empty() ),
1023 _T("EM_STREAMIN didn't send EN_UPDATE?") );
1027 wxLogLastError(_T("EM_STREAMIN"));
1032 #endif // !wxUSE_WCHAR_T
1037 #if !wxUSE_UNICODE_MSLU
1040 wxTextCtrl::StreamOut(wxFontEncoding encoding
, bool selectionOnly
) const
1044 const int len
= GetWindowTextLength(GetHwnd());
1047 wxWCharBuffer
wchBuf(len
);
1048 wchar_t *wpc
= wchBuf
.data();
1050 wchar_t *wchBuf
= (wchar_t *)malloc((len
+ 1)*sizeof(wchar_t));
1051 wchar_t *wpc
= wchBuf
;
1054 wxStreamOutData data
;
1060 eds
.dwCookie
= (DWORD
)&data
;
1061 eds
.pfnCallback
= wxRichEditStreamOut
;
1067 SF_TEXT
| SF_UNICODE
| (selectionOnly
? SFF_SELECTION
: 0),
1073 wxLogLastError(_T("EM_STREAMOUT"));
1075 else // streamed out ok
1077 // NUL-terminate the string because its length could have been
1078 // decreased by wxRichEditStreamOut
1079 *(wchBuf
.data() + data
.len
) = L
'\0';
1081 // now convert to the given encoding (this is a possibly lossful
1082 // conversion but what else can we do)
1083 wxCSConv
conv(encoding
);
1084 size_t lenNeeded
= conv
.WC2MB(NULL
, wchBuf
, 0);
1086 if ( lenNeeded
!= wxCONV_FAILED
&& lenNeeded
++ )
1088 conv
.WC2MB(wxStringBuffer(out
, lenNeeded
), wchBuf
, lenNeeded
);
1094 #endif // !wxUSE_WCHAR_T
1099 #endif // !wxUSE_UNICODE_MSLU
1101 #endif // wxUSE_RICHEDIT
1103 void wxTextCtrl::WriteText(const wxString
& value
)
1108 void wxTextCtrl::DoWriteText(const wxString
& value
, int flags
)
1110 bool selectionOnly
= (flags
& SetValue_SelectionOnly
) != 0;
1112 if ( m_windowStyle
& wxTE_MULTILINE
)
1113 valueDos
= wxTextFile::Translate(value
, wxTextFileType_Dos
);
1118 // there are several complications with the rich edit controls here
1122 // first, ensure that the new text will be in the default style
1123 if ( !m_defaultStyle
.IsDefault() )
1126 GetSelection(&start
, &end
);
1127 SetStyle(start
, end
, m_defaultStyle
);
1130 #if wxUSE_UNICODE_MSLU
1131 // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
1132 // but EM_STREAMIN works
1133 if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
1135 done
= StreamIn(valueDos
, wxFONTENCODING_SYSTEM
, selectionOnly
);
1137 #endif // wxUSE_UNICODE_MSLU
1140 // next check if the text we're inserting must be shown in a non
1141 // default charset -- this only works for RichEdit > 1.0
1142 if ( GetRichVersion() > 1 )
1144 wxFont font
= m_defaultStyle
.GetFont();
1150 wxFontEncoding encoding
= font
.GetEncoding();
1151 if ( encoding
!= wxFONTENCODING_SYSTEM
)
1153 // we have to use EM_STREAMIN to force richedit control 2.0+
1154 // to show any text in the non default charset -- otherwise
1155 // it thinks it knows better than we do and always shows it
1156 // in the default one
1157 done
= StreamIn(valueDos
, encoding
, selectionOnly
);
1161 #endif // !wxUSE_UNICODE
1165 #endif // wxUSE_RICHEDIT
1167 // in some cases we get 2 EN_CHANGE notifications after the SendMessage
1168 // call (this happens for plain EDITs with EM_REPLACESEL and under some
1169 // -- undetermined -- conditions with rich edit) and sometimes we don't
1170 // get any events at all (plain EDIT with WM_SETTEXT), so ensure that
1171 // we generate exactly one of them by ignoring all but the first one in
1172 // SendUpdateEvent() and generating one ourselves if we hadn't got any
1173 // notifications from Windows
1174 if ( !(flags
& SetValue_SendEvent
) )
1175 m_updatesCount
= -2; // suppress any update event
1177 UpdatesCountFilter
ucf(m_updatesCount
);
1179 ::SendMessage(GetHwnd(), selectionOnly
? EM_REPLACESEL
: WM_SETTEXT
,
1180 // EM_REPLACESEL takes 1 to indicate the operation should be redoable
1181 selectionOnly
? 1 : 0, (LPARAM
)valueDos
.wx_str());
1183 if ( !ucf
.GotUpdate() && (flags
& SetValue_SendEvent
) )
1190 void wxTextCtrl::AppendText(const wxString
& text
)
1192 wxTextEntry::AppendText(text
);
1195 // don't do this if we're frozen, saves some time
1196 if ( !IsFrozen() && IsMultiLine() && GetRichVersion() > 1 )
1198 // setting the caret to the end and showing it simply doesn't work for
1199 // RichEdit 2.0 -- force it to still do what we want
1200 ::SendMessage(GetHwnd(), EM_LINESCROLL
, 0, GetNumberOfLines());
1202 #endif // wxUSE_RICHEDIT
1205 void wxTextCtrl::Clear()
1207 ::SetWindowText(GetHwnd(), wxEmptyString
);
1209 if ( IsMultiLine() && !IsRich() )
1211 // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves
1212 // but the normal ones don't -- make Clear() behaviour consistent by
1213 // always sending this event
1220 bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent
& event
)
1224 size_t lenOld
= GetValue().length();
1226 wxUint32 code
= event
.GetRawKeyCode();
1227 ::keybd_event((BYTE
)code
, 0, 0 /* key press */, 0);
1228 ::keybd_event((BYTE
)code
, 0, KEYEVENTF_KEYUP
, 0);
1230 // assume that any alphanumeric key changes the total number of characters
1231 // in the control - this should work in 99% of cases
1232 return GetValue().length() != lenOld
;
1237 // ----------------------------------------------------------------------------
1239 // ----------------------------------------------------------------------------
1241 void wxTextCtrl::SetInsertionPointEnd()
1243 // we must not do anything if the caret is already there because calling
1244 // SetInsertionPoint() thaws the controls if Freeze() had been called even
1245 // if it doesn't actually move the caret anywhere and so the simple fact of
1246 // doing it results in horrible flicker when appending big amounts of text
1247 // to the control in a few chunks (see DoAddText() test in the text sample)
1248 const wxTextPos lastPosition
= GetLastPosition();
1249 if ( GetInsertionPoint() == lastPosition
)
1254 SetInsertionPoint(lastPosition
);
1257 long wxTextCtrl::GetInsertionPoint() const
1265 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &range
);
1268 #endif // wxUSE_RICHEDIT
1270 return wxTextEntry::GetInsertionPoint();
1273 wxTextPos
wxTextCtrl::GetLastPosition() const
1275 if ( IsMultiLine() )
1277 int numLines
= GetNumberOfLines();
1278 long posStartLastLine
= XYToPosition(0, numLines
- 1);
1280 long lenLastLine
= GetLengthOfLineContainingPos(posStartLastLine
);
1282 return posStartLastLine
+ lenLastLine
;
1285 return wxTextEntry::GetLastPosition();
1288 // If the return values from and to are the same, there is no
1290 void wxTextCtrl::GetSelection(long *from
, long *to
) const
1295 CHARRANGE charRange
;
1296 ::SendMessage(GetHwnd(), EM_EXGETSEL
, 0, (LPARAM
) &charRange
);
1298 *from
= charRange
.cpMin
;
1299 *to
= charRange
.cpMax
;
1302 #endif // !wxUSE_RICHEDIT
1304 wxTextEntry::GetSelection(from
, to
);
1308 // ----------------------------------------------------------------------------
1310 // ----------------------------------------------------------------------------
1312 void wxTextCtrl::DoSetSelection(long from
, long to
, int flags
)
1314 HWND hWnd
= GetHwnd();
1319 // if from and to are both -1, it means (in wxWidgets) that all text
1320 // should be selected, translate this into Windows convention
1321 if ( (from
== -1) && (to
== -1) )
1329 ::SendMessage(hWnd
, EM_EXSETSEL
, 0, (LPARAM
)&range
);
1332 #endif // wxUSE_RICHEDIT
1334 wxTextEntry::DoSetSelection(from
, to
, flags
);
1337 if ( (flags
& SetSel_Scroll
) && !IsFrozen() )
1340 // richedit 3.0 (i.e. the version living in riched20.dll distributed
1341 // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when
1342 // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL
1343 // option is set (but it does work ok in richedit 1.0 mode...)
1345 // so to make it work we either need to give focus to it here which
1346 // will probably create many problems (dummy focus events; window
1347 // containing the text control being brought to foreground
1348 // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may
1349 // create other problems too -- and in fact it does because if we turn
1350 // on/off this style while appending the text to the control, the
1351 // vertical scrollbar never appears in it even if we append tons of
1352 // text and to work around this the only solution I found was to use
1353 // ES_DISABLENOSCROLL
1355 // this is very ugly but I don't see any other way to make this work
1357 if ( GetRichVersion() > 1 )
1359 if ( !HasFlag(wxTE_NOHIDESEL
) )
1361 // setting ECO_NOHIDESEL also sets WS_VISIBLE and possibly
1362 // others, remember the style so we can reset it later if needed
1363 style
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1364 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1365 ECOOP_OR
, ECO_NOHIDESEL
);
1367 //else: everything is already ok
1369 #endif // wxUSE_RICHEDIT
1371 ::SendMessage(hWnd
, EM_SCROLLCARET
, 0, (LPARAM
)0);
1374 // restore ECO_NOHIDESEL if we changed it
1375 if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL
) )
1377 ::SendMessage(GetHwnd(), EM_SETOPTIONS
,
1378 ECOOP_AND
, ~ECO_NOHIDESEL
);
1379 if ( style
!= ::GetWindowLong(GetHwnd(), GWL_STYLE
) )
1380 ::SetWindowLong(GetHwnd(), GWL_STYLE
, style
);
1382 #endif // wxUSE_RICHEDIT
1386 // ----------------------------------------------------------------------------
1387 // Working with files
1388 // ----------------------------------------------------------------------------
1390 bool wxTextCtrl::DoLoadFile(const wxString
& file
, int fileType
)
1392 if ( wxTextCtrlBase::DoLoadFile(file
, fileType
) )
1394 // update the size limit if needed
1403 // ----------------------------------------------------------------------------
1405 // ----------------------------------------------------------------------------
1407 bool wxTextCtrl::IsModified() const
1409 return ::SendMessage(GetHwnd(), EM_GETMODIFY
, 0, 0) != 0;
1412 void wxTextCtrl::MarkDirty()
1414 ::SendMessage(GetHwnd(), EM_SETMODIFY
, TRUE
, 0);
1417 void wxTextCtrl::DiscardEdits()
1419 ::SendMessage(GetHwnd(), EM_SETMODIFY
, FALSE
, 0);
1422 // ----------------------------------------------------------------------------
1423 // Positions <-> coords
1424 // ----------------------------------------------------------------------------
1426 int wxTextCtrl::GetNumberOfLines() const
1428 return (int)::SendMessage(GetHwnd(), EM_GETLINECOUNT
, 0, 0);
1431 long wxTextCtrl::XYToPosition(long x
, long y
) const
1433 // This gets the char index for the _beginning_ of this line
1434 long charIndex
= ::SendMessage(GetHwnd(), EM_LINEINDEX
, y
, 0);
1436 return charIndex
+ x
;
1439 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1441 HWND hWnd
= GetHwnd();
1443 // This gets the line number containing the character
1448 lineNo
= ::SendMessage(hWnd
, EM_EXLINEFROMCHAR
, 0, pos
);
1451 #endif // wxUSE_RICHEDIT
1453 lineNo
= ::SendMessage(hWnd
, EM_LINEFROMCHAR
, pos
, 0);
1462 // This gets the char index for the _beginning_ of this line
1463 long charIndex
= ::SendMessage(hWnd
, EM_LINEINDEX
, lineNo
, 0);
1464 if ( charIndex
== -1 )
1469 // The X position must therefore be the different between pos and charIndex
1471 *x
= pos
- charIndex
;
1478 wxTextCtrlHitTestResult
1479 wxTextCtrl::HitTest(const wxPoint
& pt
, long *posOut
) const
1481 // first get the position from Windows
1488 // for rich edit controls the position is passed iva the struct fields
1491 lParam
= (LPARAM
)&ptl
;
1494 #endif // wxUSE_RICHEDIT
1496 // for the plain ones, we are limited to 16 bit positions which are
1497 // combined in a single 32 bit value
1498 lParam
= MAKELPARAM(pt
.x
, pt
.y
);
1501 LRESULT pos
= ::SendMessage(GetHwnd(), EM_CHARFROMPOS
, 0, lParam
);
1505 // this seems to indicate an error...
1506 return wxTE_HT_UNKNOWN
;
1511 #endif // wxUSE_RICHEDIT
1513 // for plain EDIT controls the higher word contains something else
1518 // next determine where it is relatively to our point: EM_CHARFROMPOS
1519 // always returns the closest character but we need to be more precise, so
1520 // double check that we really are where it pretends
1524 // FIXME: we need to distinguish between richedit 2 and 3 here somehow but
1525 // we don't know how to do it
1528 ::SendMessage(GetHwnd(), EM_POSFROMCHAR
, (WPARAM
)&ptReal
, pos
);
1531 #endif // wxUSE_RICHEDIT
1533 LRESULT lRc
= ::SendMessage(GetHwnd(), EM_POSFROMCHAR
, pos
, 0);
1537 // this is apparently returned when pos corresponds to the last
1544 ptReal
.x
= LOWORD(lRc
);
1545 ptReal
.y
= HIWORD(lRc
);
1549 wxTextCtrlHitTestResult rc
;
1551 if ( pt
.y
> ptReal
.y
+ GetCharHeight() )
1553 else if ( pt
.x
> ptReal
.x
+ GetCharWidth() )
1554 rc
= wxTE_HT_BEYOND
;
1556 rc
= wxTE_HT_ON_TEXT
;
1564 // ----------------------------------------------------------------------------
1566 // ----------------------------------------------------------------------------
1568 void wxTextCtrl::ShowPosition(long pos
)
1570 HWND hWnd
= GetHwnd();
1572 // To scroll to a position, we pass the number of lines and characters
1573 // to scroll *by*. This means that we need to:
1574 // (1) Find the line position of the current line.
1575 // (2) Find the line position of pos.
1576 // (3) Scroll by (pos - current).
1577 // For now, ignore the horizontal scrolling.
1579 // Is this where scrolling is relative to - the line containing the caret?
1580 // Or is the first visible line??? Try first visible line.
1581 // int currentLineLineNo1 = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, -1, 0L);
1583 int currentLineLineNo
= (int)::SendMessage(hWnd
, EM_GETFIRSTVISIBLELINE
, 0, 0);
1585 int specifiedLineLineNo
= (int)::SendMessage(hWnd
, EM_LINEFROMCHAR
, pos
, 0);
1587 int linesToScroll
= specifiedLineLineNo
- currentLineLineNo
;
1589 if (linesToScroll
!= 0)
1590 ::SendMessage(hWnd
, EM_LINESCROLL
, 0, linesToScroll
);
1593 long wxTextCtrl::GetLengthOfLineContainingPos(long pos
) const
1595 return ::SendMessage(GetHwnd(), EM_LINELENGTH
, pos
, 0);
1598 int wxTextCtrl::GetLineLength(long lineNo
) const
1600 long pos
= XYToPosition(0, lineNo
);
1602 return GetLengthOfLineContainingPos(pos
);
1605 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1607 size_t len
= (size_t)GetLineLength(lineNo
) + 1;
1609 // there must be at least enough place for the length WORD in the
1611 len
+= sizeof(WORD
);
1615 wxStringBufferLength
tmp(str
, len
);
1618 *(WORD
*)buf
= (WORD
)len
;
1619 len
= (size_t)::SendMessage(GetHwnd(), EM_GETLINE
, lineNo
, (LPARAM
)buf
);
1624 // remove the '\r' returned by the rich edit control, the user code
1625 // should never see it
1626 if ( buf
[len
- 2] == _T('\r') && buf
[len
- 1] == _T('\n') )
1628 // richedit 1.0 uses "\r\n" as line terminator, so remove "\r"
1629 // here and "\n" below
1630 buf
[len
- 2] = _T('\n');
1633 else if ( buf
[len
- 1] == _T('\r') )
1635 // richedit 2.0+ uses only "\r", replace it with "\n"
1636 buf
[len
- 1] = _T('\n');
1639 #endif // wxUSE_RICHEDIT
1641 // remove the '\n' at the end, if any (this is how this function is
1642 // supposed to work according to the docs)
1643 if ( buf
[len
- 1] == _T('\n') )
1655 void wxTextCtrl::SetMaxLength(unsigned long len
)
1660 ::SendMessage(GetHwnd(), EM_EXLIMITTEXT
, 0, len
? len
: 0x7fffffff);
1663 #endif // wxUSE_RICHEDIT
1665 wxTextEntry::SetMaxLength(len
);
1669 // ----------------------------------------------------------------------------
1671 // ----------------------------------------------------------------------------
1673 void wxTextCtrl::Redo()
1676 if ( GetRichVersion() > 1 )
1678 ::SendMessage(GetHwnd(), EM_REDO
, 0, 0);
1681 #endif // wxUSE_RICHEDIT
1683 wxTextEntry::Redo();
1686 bool wxTextCtrl::CanRedo() const
1689 if ( GetRichVersion() > 1 )
1690 return ::SendMessage(GetHwnd(), EM_CANREDO
, 0, 0) != 0;
1691 #endif // wxUSE_RICHEDIT
1693 return wxTextEntry::CanRedo();
1696 // ----------------------------------------------------------------------------
1697 // caret handling (Windows only)
1698 // ----------------------------------------------------------------------------
1700 bool wxTextCtrl::ShowNativeCaret(bool show
)
1702 if ( show
!= m_isNativeCaretShown
)
1704 if ( !(show
? ::ShowCaret(GetHwnd()) : ::HideCaret(GetHwnd())) )
1706 // not an error, may simply indicate that it's not shown/hidden
1707 // yet (i.e. it had been hidden/shown 2 times before)
1711 m_isNativeCaretShown
= show
;
1717 // ----------------------------------------------------------------------------
1718 // implementation details
1719 // ----------------------------------------------------------------------------
1721 void wxTextCtrl::Command(wxCommandEvent
& event
)
1723 SetValue(event
.GetString());
1724 ProcessCommand (event
);
1727 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1729 // By default, load the first file into the text window.
1730 if (event
.GetNumberOfFiles() > 0)
1732 LoadFile(event
.GetFiles()[0]);
1736 // ----------------------------------------------------------------------------
1737 // kbd input processing
1738 // ----------------------------------------------------------------------------
1740 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG
* msg
)
1742 // check for our special keys here: if we don't do it and the parent frame
1743 // uses them as accelerators, they wouldn't work at all, so we disable
1744 // usual preprocessing for them
1745 if ( msg
->message
== WM_KEYDOWN
)
1747 const WPARAM vkey
= msg
->wParam
;
1748 if ( HIWORD(msg
->lParam
) & KF_ALTDOWN
)
1750 // Alt-Backspace is accelerator for "Undo"
1751 if ( vkey
== VK_BACK
)
1756 // we want to process some Ctrl-foo and Shift-bar but no key
1757 // combinations without either Ctrl or Shift nor with both of them
1759 const int ctrl
= wxIsCtrlDown(),
1760 shift
= wxIsShiftDown();
1761 switch ( ctrl
+ shift
)
1764 wxFAIL_MSG( _T("how many modifiers have we got?") );
1768 if ( IsMultiLine() && vkey
== VK_RETURN
)
1775 // either Ctrl or Shift pressed
1790 else // Shift is pressed
1792 if ( vkey
== VK_INSERT
|| vkey
== VK_DELETE
)
1799 return wxControl::MSWShouldPreProcessMessage(msg
);
1802 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1804 switch ( event
.GetKeyCode() )
1808 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1809 InitCommandEvent(event
);
1810 event
.SetString(GetValue());
1811 if ( HandleWindowEvent(event
) )
1812 if ( !HasFlag(wxTE_MULTILINE
) )
1814 //else: multiline controls need Enter for themselves
1819 // ok, so this is getting absolutely ridiculous but I don't see
1820 // any other way to fix this bug: when a multiline text control is
1821 // inside a wxFrame, we need to generate the navigation event as
1822 // otherwise nothing happens at all, but when the same control is
1823 // created inside a dialog, IsDialogMessage() *does* switch focus
1824 // all by itself and so if we do it here as well, it is advanced
1825 // twice and goes to the next control... to prevent this from
1826 // happening we're doing this ugly check, the logic being that if
1827 // we don't have focus then it had been already changed to the next
1830 // the right thing to do would, of course, be to understand what
1831 // the hell is IsDialogMessage() doing but this is beyond my feeble
1832 // forces at the moment unfortunately
1833 if ( !(m_windowStyle
& wxTE_PROCESS_TAB
))
1835 if ( FindFocus() == this )
1838 if (!event
.ShiftDown())
1839 flags
|= wxNavigationKeyEvent::IsForward
;
1840 if (event
.ControlDown())
1841 flags
|= wxNavigationKeyEvent::WinChange
;
1842 if (Navigate(flags
))
1848 // Insert tab since calling the default Windows handler
1849 // doesn't seem to do it
1850 WriteText(wxT("\t"));
1856 // no, we didn't process it
1860 void wxTextCtrl::OnKeyDown(wxKeyEvent
& event
)
1862 // richedit control doesn't send WM_PASTE, WM_CUT and WM_COPY messages
1863 // when Ctrl-V, X or C is pressed and this prevents wxClipboardTextEvent
1864 // from working. So we work around it by intercepting these shortcuts
1865 // ourselves and emitting clipboard events (which richedit will handle,
1866 // so everything works as before, including pasting of rich text):
1867 if ( event
.GetModifiers() == wxMOD_CONTROL
&& IsRich() )
1869 switch ( event
.GetKeyCode() )
1885 // no, we didn't process it
1889 WXLRESULT
wxTextCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1891 WXLRESULT lRc
= wxTextCtrlBase::MSWWindowProc(nMsg
, wParam
, lParam
);
1897 // we always want the chars and the arrows: the arrows for
1898 // navigation and the chars because we want Ctrl-C to work even
1899 // in a read only control
1900 long lDlgCode
= DLGC_WANTCHARS
| DLGC_WANTARROWS
;
1904 // we may have several different cases:
1905 // 1. normal: both TAB and ENTER are used for navigation
1906 // 2. ctrl wants TAB for itself: ENTER is used to pass to
1907 // the next control in the dialog
1908 // 3. ctrl wants ENTER for itself: TAB is used for dialog
1910 // 4. ctrl wants both TAB and ENTER: Ctrl-ENTER is used to
1911 // go to the next control (we need some way to do it)
1913 // multiline controls should always get ENTER for themselves
1914 if ( HasFlag(wxTE_PROCESS_ENTER
) || HasFlag(wxTE_MULTILINE
) )
1915 lDlgCode
|= DLGC_WANTMESSAGE
;
1917 if ( HasFlag(wxTE_PROCESS_TAB
) )
1918 lDlgCode
|= DLGC_WANTTAB
;
1924 // NB: use "=", not "|=" as the base class version returns
1925 // the same flags in the disabled state as usual (i.e.
1926 // including DLGC_WANTMESSAGE). This is strange (how
1927 // does it work in the native Win32 apps?) but for now
1938 // ----------------------------------------------------------------------------
1939 // text control event processing
1940 // ----------------------------------------------------------------------------
1942 bool wxTextCtrl::SendUpdateEvent()
1944 switch ( m_updatesCount
)
1947 // remember that we've got an update
1952 // we had already sent one event since the last control modification
1956 wxFAIL_MSG( _T("unexpected wxTextCtrl::m_updatesCount value") );
1960 // we hadn't updated the control ourselves, this event comes from
1961 // the user, don't need to ignore it nor update the count
1965 // the control was updated programmatically and we do NOT want to
1970 return SendTextUpdatedEvent();
1973 bool wxTextCtrl::MSWCommand(WXUINT param
, WXWORD
WXUNUSED(id
))
1982 // the text size limit has been hit -- try to increase it
1983 if ( !AdjustSpaceLimit() )
1985 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, m_windowId
);
1986 InitCommandEvent(event
);
1987 event
.SetString(GetValue());
1988 ProcessCommand(event
);
1992 // the other edit notification messages are not processed (or, in
1993 // the case of EN_{SET/KILL}FOCUS were already handled at WM_SET/
2003 WXHBRUSH
wxTextCtrl::MSWControlColor(WXHDC hDC
, WXHWND hWnd
)
2005 if ( !IsEnabled() && !HasFlag(wxTE_MULTILINE
) )
2006 return MSWControlColorDisabled(hDC
);
2008 return wxTextCtrlBase::MSWControlColor(hDC
, hWnd
);
2011 bool wxTextCtrl::HasSpaceLimit(unsigned int *len
) const
2013 // HACK: we try to automatically extend the limit for the amount of text
2014 // to allow (interactively) entering more than 64Kb of text under
2015 // Win9x but we shouldn't reset the text limit which was previously
2016 // set explicitly with SetMaxLength()
2018 // Unfortunately there is no EM_GETLIMITTEXTSETBYUSER and so we don't
2019 // know the limit we set (if any). We could solve this by storing the
2020 // limit we set in wxTextCtrl but to save space we prefer to simply
2021 // test here the actual limit value: we consider that SetMaxLength()
2022 // can only be called for small values while EN_MAXTEXT is only sent
2023 // for large values (in practice the default limit seems to be 30000
2024 // but make it smaller just to be on the safe side)
2025 *len
= ::SendMessage(GetHwnd(), EM_GETLIMITTEXT
, 0, 0);
2026 return *len
< 10001;
2030 bool wxTextCtrl::AdjustSpaceLimit()
2033 if ( HasSpaceLimit(&limit
) )
2036 unsigned int len
= ::GetWindowTextLength(GetHwnd());
2039 // increment in 32Kb chunks
2040 SetMaxLength(len
+ 0x8000);
2043 // we changed the limit
2047 bool wxTextCtrl::AcceptsFocusFromKeyboard() const
2049 // we don't want focus if we can't be edited unless we're a multiline
2050 // control because then it might be still nice to get focus from keyboard
2051 // to be able to scroll it without mouse
2052 return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus();
2055 wxSize
wxTextCtrl::DoGetBestSize() const
2058 wxGetCharSize(GetHWND(), &cx
, &cy
, GetFont());
2060 int wText
= DEFAULT_ITEM_WIDTH
;
2063 if ( m_windowStyle
& wxTE_MULTILINE
)
2065 hText
*= wxMax(wxMin(GetNumberOfLines(), 10), 2);
2067 //else: for single line control everything is ok
2069 // we have to add the adjustments for the control height only once, not
2070 // once per line, so do it after multiplication above
2071 hText
+= EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy
) - cy
;
2073 return wxSize(wText
, hText
);
2076 // ----------------------------------------------------------------------------
2077 // standard handlers for standard edit menu events
2078 // ----------------------------------------------------------------------------
2080 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
2085 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
2090 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
2095 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
2100 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
2105 void wxTextCtrl::OnDelete(wxCommandEvent
& WXUNUSED(event
))
2110 void wxTextCtrl::OnSelectAll(wxCommandEvent
& WXUNUSED(event
))
2115 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
2117 event
.Enable( CanCut() );
2120 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
2122 event
.Enable( CanCopy() );
2125 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
2127 event
.Enable( CanPaste() );
2130 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
2132 event
.Enable( CanUndo() );
2135 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
2137 event
.Enable( CanRedo() );
2140 void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent
& event
)
2142 event
.Enable( HasSelection() && IsEditable() );
2145 void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent
& event
)
2147 event
.Enable( !IsEmpty() );
2150 void wxTextCtrl::OnContextMenu(wxContextMenuEvent
& event
)
2155 if (!m_privateContextMenu
)
2157 m_privateContextMenu
= new wxMenu
;
2158 m_privateContextMenu
->Append(wxID_UNDO
, _("&Undo"));
2159 m_privateContextMenu
->Append(wxID_REDO
, _("&Redo"));
2160 m_privateContextMenu
->AppendSeparator();
2161 m_privateContextMenu
->Append(wxID_CUT
, _("Cu&t"));
2162 m_privateContextMenu
->Append(wxID_COPY
, _("&Copy"));
2163 m_privateContextMenu
->Append(wxID_PASTE
, _("&Paste"));
2164 m_privateContextMenu
->Append(wxID_CLEAR
, _("&Delete"));
2165 m_privateContextMenu
->AppendSeparator();
2166 m_privateContextMenu
->Append(wxID_SELECTALL
, _("Select &All"));
2168 PopupMenu(m_privateContextMenu
);
2176 void wxTextCtrl::OnSetFocus(wxFocusEvent
& event
)
2178 // be sure the caret remains invisible if the user had hidden it
2179 if ( !m_isNativeCaretShown
)
2181 ::HideCaret(GetHwnd());
2187 // ----------------------------------------------------------------------------
2188 // Default colors for MSW text control
2190 // Set default background color to the native white instead of
2191 // the default wxSYS_COLOUR_BTNFACE (is triggered with wxNullColour).
2192 // ----------------------------------------------------------------------------
2194 wxVisualAttributes
wxTextCtrl::GetDefaultAttributes() const
2196 wxVisualAttributes attrs
;
2197 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
2198 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
2199 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
); //white
2204 // the rest of the file only deals with the rich edit controls
2207 // ----------------------------------------------------------------------------
2208 // EN_LINK processing
2209 // ----------------------------------------------------------------------------
2211 bool wxTextCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2213 NMHDR
*hdr
= (NMHDR
* )lParam
;
2214 switch ( hdr
->code
)
2218 const MSGFILTER
*msgf
= (MSGFILTER
*)lParam
;
2219 UINT msg
= msgf
->msg
;
2221 // this is a bit crazy but richedit 1.0 sends us all mouse
2222 // events _except_ WM_LBUTTONUP (don't ask me why) so we have
2223 // generate the wxWin events for this message manually
2225 // NB: in fact, this is still not totally correct as it does
2226 // send us WM_LBUTTONUP if the selection was cleared by the
2227 // last click -- so currently we get 2 events in this case,
2228 // but as I don't see any obvious way to check for this I
2229 // leave this code in place because it's still better than
2230 // not getting left up events at all
2231 if ( msg
== WM_LBUTTONUP
)
2233 WXUINT flags
= msgf
->wParam
;
2234 int x
= GET_X_LPARAM(msgf
->lParam
),
2235 y
= GET_Y_LPARAM(msgf
->lParam
);
2237 HandleMouseEvent(msg
, x
, y
, flags
);
2241 // return true to process the event (and false to ignore it)
2246 const ENLINK
*enlink
= (ENLINK
*)hdr
;
2248 switch ( enlink
->msg
)
2251 // ok, so it is hardcoded - do we really nee to
2254 wxCursor
cur(wxCURSOR_HAND
);
2255 ::SetCursor(GetHcursorOf(cur
));
2261 case WM_LBUTTONDOWN
:
2263 case WM_LBUTTONDBLCLK
:
2264 case WM_RBUTTONDOWN
:
2266 case WM_RBUTTONDBLCLK
:
2267 // send a mouse event
2269 static const wxEventType eventsMouse
[] =
2280 // the event ids are consecutive
2282 evtMouse(eventsMouse
[enlink
->msg
- WM_MOUSEMOVE
]);
2284 InitMouseEvent(evtMouse
,
2285 GET_X_LPARAM(enlink
->lParam
),
2286 GET_Y_LPARAM(enlink
->lParam
),
2289 wxTextUrlEvent
event(m_windowId
, evtMouse
,
2291 enlink
->chrg
.cpMax
);
2293 InitCommandEvent(event
);
2295 *result
= ProcessCommand(event
);
2303 // not processed, leave it to the base class
2304 return wxTextCtrlBase::MSWOnNotify(idCtrl
, lParam
, result
);
2307 #if wxUSE_DRAG_AND_DROP
2309 void wxTextCtrl::SetDropTarget(wxDropTarget
*dropTarget
)
2311 if ( m_dropTarget
== wxRICHTEXT_DEFAULT_DROPTARGET
)
2313 // get rid of the built-in drop target
2314 ::RevokeDragDrop(GetHwnd());
2315 m_dropTarget
= NULL
;
2318 wxTextCtrlBase::SetDropTarget(dropTarget
);
2321 #endif // wxUSE_DRAG_AND_DROP
2323 // ----------------------------------------------------------------------------
2324 // colour setting for the rich edit controls
2325 // ----------------------------------------------------------------------------
2327 bool wxTextCtrl::SetBackgroundColour(const wxColour
& colour
)
2329 if ( !wxTextCtrlBase::SetBackgroundColour(colour
) )
2331 // colour didn't really change
2337 // rich edit doesn't use WM_CTLCOLOR, hence we need to send
2338 // EM_SETBKGNDCOLOR additionally
2339 ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR
, 0, wxColourToRGB(colour
));
2345 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
2347 if ( !wxTextCtrlBase::SetForegroundColour(colour
) )
2349 // colour didn't really change
2355 // change the colour of everything
2358 cf
.cbSize
= sizeof(cf
);
2359 cf
.dwMask
= CFM_COLOR
;
2360 cf
.crTextColor
= wxColourToRGB(colour
);
2361 ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
, SCF_ALL
, (LPARAM
)&cf
);
2367 // ----------------------------------------------------------------------------
2368 // styling support for rich edit controls
2369 // ----------------------------------------------------------------------------
2371 bool wxTextCtrl::SetStyle(long start
, long end
, const wxTextAttr
& style
)
2375 // can't do it with normal text control
2379 // the richedit 1.0 doesn't handle setting background colour, so don't
2380 // even try to do anything if it's the only thing we want to change
2381 if ( m_verRichEdit
== 1 && !style
.HasFont() && !style
.HasTextColour() &&
2382 !style
.HasLeftIndent() && !style
.HasRightIndent() && !style
.HasAlignment() &&
2385 // nothing to do: return true if there was really nothing to do and
2386 // false if we failed to set bg colour
2387 return !style
.HasBackgroundColour();
2390 // order the range if needed
2398 // we can only change the format of the selection, so select the range we
2399 // want and restore the old selection later
2400 long startOld
, endOld
;
2401 GetSelection(&startOld
, &endOld
);
2403 // but do we really have to change the selection?
2404 bool changeSel
= start
!= startOld
|| end
!= endOld
;
2408 DoSetSelection(start
, end
, SetSel_NoScroll
);
2411 // initialize CHARFORMAT struct
2420 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2421 // CHARFORMAT in that case
2423 if ( m_verRichEdit
== 1 )
2425 // this is the only thing the control is going to grok
2426 cf
.cbSize
= sizeof(CHARFORMAT
);
2431 // CHARFORMAT or CHARFORMAT2
2432 cf
.cbSize
= sizeof(cf
);
2435 if ( style
.HasFont() )
2437 // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
2438 // but using it doesn't seem to hurt neither so leaving it for now
2440 cf
.dwMask
|= CFM_FACE
| CFM_SIZE
| CFM_CHARSET
|
2441 CFM_ITALIC
| CFM_BOLD
| CFM_UNDERLINE
;
2443 // fill in data from LOGFONT but recalculate lfHeight because we need
2444 // the real height in twips and not the negative number which
2445 // wxFillLogFont() returns (this is correct in general and works with
2446 // the Windows font mapper, but not here)
2448 wxFont
font(style
.GetFont());
2451 wxFillLogFont(&lf
, &font
);
2452 cf
.yHeight
= 20*font
.GetPointSize(); // 1 pt = 20 twips
2453 cf
.bCharSet
= lf
.lfCharSet
;
2454 cf
.bPitchAndFamily
= lf
.lfPitchAndFamily
;
2455 wxStrncpy( cf
.szFaceName
, lf
.lfFaceName
, WXSIZEOF(cf
.szFaceName
) );
2457 // also deal with underline/italic/bold attributes: note that we must
2458 // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
2459 // style to allow clearing it
2462 cf
.dwEffects
|= CFE_ITALIC
;
2465 if ( lf
.lfWeight
== FW_BOLD
)
2467 cf
.dwEffects
|= CFE_BOLD
;
2470 if ( lf
.lfUnderline
)
2472 cf
.dwEffects
|= CFE_UNDERLINE
;
2475 // strikeout fonts are not supported by wxWidgets
2478 if ( style
.HasTextColour() )
2480 cf
.dwMask
|= CFM_COLOR
;
2481 cf
.crTextColor
= wxColourToRGB(style
.GetTextColour());
2485 if ( m_verRichEdit
!= 1 && style
.HasBackgroundColour() )
2487 cf
.dwMask
|= CFM_BACKCOLOR
;
2488 cf
.crBackColor
= wxColourToRGB(style
.GetBackgroundColour());
2490 #endif // wxUSE_RICHEDIT2
2492 // do format the selection
2493 bool ok
= ::SendMessage(GetHwnd(), EM_SETCHARFORMAT
,
2494 SCF_SELECTION
, (LPARAM
)&cf
) != 0;
2497 wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
2500 // now do the paragraph formatting
2503 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2504 // PARAFORMAT in that case
2506 if ( m_verRichEdit
== 1 )
2508 // this is the only thing the control is going to grok
2509 pf
.cbSize
= sizeof(PARAFORMAT
);
2514 // PARAFORMAT or PARAFORMAT2
2515 pf
.cbSize
= sizeof(pf
);
2518 if (style
.HasAlignment())
2520 pf
.dwMask
|= PFM_ALIGNMENT
;
2521 if (style
.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT
)
2522 pf
.wAlignment
= PFA_RIGHT
;
2523 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE
)
2524 pf
.wAlignment
= PFA_CENTER
;
2525 else if (style
.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED
)
2526 pf
.wAlignment
= PFA_JUSTIFY
;
2528 pf
.wAlignment
= PFA_LEFT
;
2531 if (style
.HasLeftIndent())
2533 pf
.dwMask
|= PFM_STARTINDENT
| PFM_OFFSET
;
2535 // Convert from 1/10 mm to TWIPS
2536 pf
.dxStartIndent
= (int) (((double) style
.GetLeftIndent()) * mm2twips
/ 10.0) ;
2537 pf
.dxOffset
= (int) (((double) style
.GetLeftSubIndent()) * mm2twips
/ 10.0) ;
2540 if (style
.HasRightIndent())
2542 pf
.dwMask
|= PFM_RIGHTINDENT
;
2544 // Convert from 1/10 mm to TWIPS
2545 pf
.dxRightIndent
= (int) (((double) style
.GetRightIndent()) * mm2twips
/ 10.0) ;
2548 if (style
.HasTabs())
2550 pf
.dwMask
|= PFM_TABSTOPS
;
2552 const wxArrayInt
& tabs
= style
.GetTabs();
2554 pf
.cTabCount
= (SHORT
)wxMin(tabs
.GetCount(), MAX_TAB_STOPS
);
2556 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2558 // Convert from 1/10 mm to TWIPS
2559 pf
.rgxTabs
[i
] = (int) (((double) tabs
[i
]) * mm2twips
/ 10.0) ;
2564 if ( m_verRichEdit
> 1 )
2566 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
2568 // Use RTL paragraphs in RTL mode to get proper layout
2569 pf
.dwMask
|= PFM_RTLPARA
;
2570 pf
.wEffects
|= PFE_RTLPARA
;
2573 #endif // wxUSE_RICHEDIT2
2577 // do format the selection
2578 bool ok
= ::SendMessage(GetHwnd(), EM_SETPARAFORMAT
,
2579 0, (LPARAM
) &pf
) != 0;
2582 wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed"));
2588 // restore the original selection
2589 DoSetSelection(startOld
, endOld
, SetSel_NoScroll
);
2595 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr
& style
)
2597 if ( !wxTextCtrlBase::SetDefaultStyle(style
) )
2602 // we have to do this or the style wouldn't apply for the text typed by
2604 wxTextPos posLast
= GetLastPosition();
2605 SetStyle(posLast
, posLast
, m_defaultStyle
);
2611 bool wxTextCtrl::GetStyle(long position
, wxTextAttr
& style
)
2615 // can't do it with normal text control
2619 // initialize CHARFORMAT struct
2628 // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2629 // CHARFORMAT in that case
2631 if ( m_verRichEdit
== 1 )
2633 // this is the only thing the control is going to grok
2634 cf
.cbSize
= sizeof(CHARFORMAT
);
2639 // CHARFORMAT or CHARFORMAT2
2640 cf
.cbSize
= sizeof(cf
);
2642 // we can only change the format of the selection, so select the range we
2643 // want and restore the old selection later
2644 long startOld
, endOld
;
2645 GetSelection(&startOld
, &endOld
);
2647 // but do we really have to change the selection?
2648 bool changeSel
= position
!= startOld
|| position
!= endOld
;
2652 DoSetSelection(position
, position
+ 1, SetSel_NoScroll
);
2655 // get the selection formatting
2656 (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT
,
2657 SCF_SELECTION
, (LPARAM
)&cf
) ;
2661 lf
.lfHeight
= cf
.yHeight
;
2663 lf
.lfCharSet
= ANSI_CHARSET
; // FIXME: how to get correct charset?
2664 lf
.lfClipPrecision
= 0;
2665 lf
.lfEscapement
= 0;
2666 wxStrcpy(lf
.lfFaceName
, cf
.szFaceName
);
2668 //NOTE: we _MUST_ set each of these values to _something_ since we
2669 //do not call wxZeroMemory on the LOGFONT lf
2670 if (cf
.dwEffects
& CFE_ITALIC
)
2673 lf
.lfItalic
= FALSE
;
2675 lf
.lfOrientation
= 0;
2676 lf
.lfPitchAndFamily
= cf
.bPitchAndFamily
;
2679 if (cf
.dwEffects
& CFE_STRIKEOUT
)
2680 lf
.lfStrikeOut
= TRUE
;
2682 lf
.lfStrikeOut
= FALSE
;
2684 if (cf
.dwEffects
& CFE_UNDERLINE
)
2685 lf
.lfUnderline
= TRUE
;
2687 lf
.lfUnderline
= FALSE
;
2689 if (cf
.dwEffects
& CFE_BOLD
)
2690 lf
.lfWeight
= FW_BOLD
;
2692 lf
.lfWeight
= FW_NORMAL
;
2694 wxFont font
= wxCreateFontFromLogFont(& lf
);
2697 style
.SetFont(font
);
2699 style
.SetTextColour(wxColour(cf
.crTextColor
));
2702 if ( m_verRichEdit
!= 1 )
2704 // cf.dwMask |= CFM_BACKCOLOR;
2705 style
.SetBackgroundColour(wxColour(cf
.crBackColor
));
2707 #endif // wxUSE_RICHEDIT2
2709 // now get the paragraph formatting
2712 // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2713 // PARAFORMAT in that case
2715 if ( m_verRichEdit
== 1 )
2717 // this is the only thing the control is going to grok
2718 pf
.cbSize
= sizeof(PARAFORMAT
);
2723 // PARAFORMAT or PARAFORMAT2
2724 pf
.cbSize
= sizeof(pf
);
2727 // do format the selection
2728 (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT
, 0, (LPARAM
) &pf
) ;
2730 style
.SetLeftIndent( (int) ((double) pf
.dxStartIndent
* twips2mm
* 10.0), (int) ((double) pf
.dxOffset
* twips2mm
* 10.0) );
2731 style
.SetRightIndent( (int) ((double) pf
.dxRightIndent
* twips2mm
* 10.0) );
2733 if (pf
.wAlignment
== PFA_CENTER
)
2734 style
.SetAlignment(wxTEXT_ALIGNMENT_CENTRE
);
2735 else if (pf
.wAlignment
== PFA_RIGHT
)
2736 style
.SetAlignment(wxTEXT_ALIGNMENT_RIGHT
);
2737 else if (pf
.wAlignment
== PFA_JUSTIFY
)
2738 style
.SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED
);
2740 style
.SetAlignment(wxTEXT_ALIGNMENT_LEFT
);
2742 wxArrayInt tabStops
;
2744 for (i
= 0; i
< (size_t) pf
.cTabCount
; i
++)
2746 tabStops
.Add( (int) ((double) (pf
.rgxTabs
[i
] & 0xFFFF) * twips2mm
* 10.0) );
2751 // restore the original selection
2752 DoSetSelection(startOld
, endOld
, SetSel_NoScroll
);
2758 // ----------------------------------------------------------------------------
2760 // ----------------------------------------------------------------------------
2762 static const HINSTANCE INVALID_HINSTANCE
= (HINSTANCE
)-1;
2764 bool wxRichEditModule::OnInit()
2766 // don't do anything - we will load it when needed
2770 void wxRichEditModule::OnExit()
2772 for ( size_t i
= 0; i
< WXSIZEOF(ms_hRichEdit
); i
++ )
2774 if ( ms_hRichEdit
[i
] && ms_hRichEdit
[i
] != INVALID_HINSTANCE
)
2776 ::FreeLibrary(ms_hRichEdit
[i
]);
2777 ms_hRichEdit
[i
] = NULL
;
2781 if (ms_inkEditLib
.IsLoaded())
2782 ms_inkEditLib
.Unload();
2787 bool wxRichEditModule::Load(Version version
)
2789 if ( ms_hRichEdit
[version
] == INVALID_HINSTANCE
)
2791 // we had already tried to load it and failed
2795 if ( ms_hRichEdit
[version
] )
2797 // we've already got this one
2801 static const wxChar
*dllnames
[] =
2808 wxCOMPILE_TIME_ASSERT( WXSIZEOF(dllnames
) == Version_Max
,
2809 RichEditDllNamesVersionsMismatch
);
2811 ms_hRichEdit
[version
] = ::LoadLibrary(dllnames
[version
]);
2813 if ( !ms_hRichEdit
[version
] )
2815 ms_hRichEdit
[version
] = INVALID_HINSTANCE
;
2824 // load the InkEdit library
2825 bool wxRichEditModule::LoadInkEdit()
2827 static wxDynamicLibrary ms_inkEditLib
;
2828 static bool ms_inkEditLibLoadAttemped
;
2829 if (ms_inkEditLibLoadAttemped
)
2830 ms_inkEditLib
.IsLoaded();
2832 ms_inkEditLibLoadAttemped
= true;
2835 return ms_inkEditLib
.Load(wxT("inked"));
2837 #endif // wxUSE_INKEDIT
2840 #endif // wxUSE_RICHEDIT
2842 #endif // wxUSE_TEXTCTRL && !(__SMARTPHONE__ && __WXWINCE__)