X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0376ed540882131da043250a4341389f18f34bf6..a826202ecf2e58f7bebb7514f3001dd703ddea03:/src/msw/textctrl.cpp diff --git a/src/msw/textctrl.cpp b/src/msw/textctrl.cpp index f70aa21b7c..16a0ef075b 100644 --- a/src/msw/textctrl.cpp +++ b/src/msw/textctrl.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: msw/textctrl.cpp +// Name: src/msw/textctrl.cpp // Purpose: wxTextCtrl // Author: Julian Smart // Modified by: @@ -13,10 +13,6 @@ // declarations // ============================================================================ -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "textctrl.h" -#endif - // ---------------------------------------------------------------------------- // headers // ---------------------------------------------------------------------------- @@ -28,7 +24,7 @@ #pragma hdrstop #endif -#if wxUSE_TEXTCTRL +#if wxUSE_TEXTCTRL && !(defined(__SMARTPHONE__) && defined(__WXWINCE__)) #ifndef WX_PRECOMP #include "wx/textctrl.h" @@ -39,9 +35,12 @@ #include "wx/log.h" #include "wx/app.h" #include "wx/menu.h" + #include "wx/math.h" + #include "wx/module.h" + #include "wx/wxcrtvararg.h" #endif -#include "wx/module.h" +#include "wx/sysopt.h" #if wxUSE_CLIPBOARD #include "wx/clipbrd.h" @@ -53,6 +52,7 @@ #include "wx/msw/private.h" #include "wx/msw/winundef.h" +#include "wx/msw/mslu.h" #include #include @@ -63,25 +63,28 @@ #if wxUSE_RICHEDIT +#if wxUSE_INKEDIT +#include "wx/dynlib.h" +#endif + // old mingw32 has richedit stuff directly in windows.h and doesn't have // richedit.h at all #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__) #include #endif -#include "wx/msw/missing.h" - #endif // wxUSE_RICHEDIT -// ---------------------------------------------------------------------------- -// private functions -// ---------------------------------------------------------------------------- +#include "wx/msw/missing.h" -#if wxUSE_RICHEDIT +#if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT -DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb); +// dummy value used for m_dropTarget, different from any valid pointer value +// (which are all even under Windows) and NULL +static wxDropTarget * + wxRICHTEXT_DEFAULT_DROPTARGET = wx_reinterpret_cast(wxDropTarget *, 1); -#endif // wxUSE_RICHEDIT +#endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT // ---------------------------------------------------------------------------- // private classes @@ -93,25 +96,82 @@ DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) class wxRichEditModule : public wxModule { public: + enum Version + { + Version_1, // riched32.dll + Version_2or3, // both use riched20.dll + Version_41, // msftedit.dll (XP SP1 and Windows 2003) + Version_Max + }; + virtual bool OnInit(); virtual void OnExit(); - // load the richedit DLL of at least of required version - static bool Load(int version = 1); + // load the richedit DLL for the specified version of rich edit + static bool Load(Version version); + +#if wxUSE_INKEDIT + // load the InkEdit library + static bool LoadInkEdit(); +#endif private: // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs - static HINSTANCE ms_hRichEdit[2]; + static HINSTANCE ms_hRichEdit[Version_Max]; + +#if wxUSE_INKEDIT + static wxDynamicLibrary ms_inkEditLib; + static bool ms_inkEditLibLoadAttemped; +#endif DECLARE_DYNAMIC_CLASS(wxRichEditModule) }; -HINSTANCE wxRichEditModule::ms_hRichEdit[2] = { NULL, NULL }; +HINSTANCE wxRichEditModule::ms_hRichEdit[Version_Max] = { NULL, NULL, NULL }; + +#if wxUSE_INKEDIT +wxDynamicLibrary wxRichEditModule::ms_inkEditLib; +bool wxRichEditModule::ms_inkEditLibLoadAttemped = false; +#endif IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule) #endif // wxUSE_RICHEDIT +// a small class used to set m_updatesCount to 0 (to filter duplicate events if +// necessary) and to reset it back to -1 afterwards +class UpdatesCountFilter +{ +public: + UpdatesCountFilter(int& count) + : m_count(count) + { + wxASSERT_MSG( m_count == -1 || m_count == -2, + _T("wrong initial m_updatesCount value") ); + + if (m_count != -2) + m_count = 0; + //else: we don't want to count how many update events we get as we're going + // to ignore all of them + } + + ~UpdatesCountFilter() + { + m_count = -1; + } + + // return true if an event has been received + bool GotUpdate() const + { + return m_count == 1; + } + +private: + int& m_count; + + DECLARE_NO_COPY_CLASS(UpdatesCountFilter) +}; + // ---------------------------------------------------------------------------- // event tables and other macros // ---------------------------------------------------------------------------- @@ -128,21 +188,21 @@ wxBEGIN_FLAGS( wxTextCtrlStyle ) wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_NONE) - + // old style border flags wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER) - wxFLAGS_MEMBER(wxNO_BORDER) + wxFLAGS_MEMBER(wxBORDER) // standard window styles wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxWANTS_CHARS) - wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE) + wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxHSCROLL) @@ -161,7 +221,7 @@ wxBEGIN_FLAGS( wxTextCtrlStyle ) wxFLAGS_MEMBER(wxTE_CENTRE) wxFLAGS_MEMBER(wxTE_RIGHT) wxFLAGS_MEMBER(wxTE_DONTWRAP) - wxFLAGS_MEMBER(wxTE_LINEWRAP) + wxFLAGS_MEMBER(wxTE_CHARWRAP) wxFLAGS_MEMBER(wxTE_WORDWRAP) wxEND_FLAGS( wxTextCtrlStyle ) @@ -169,12 +229,12 @@ wxEND_FLAGS( wxTextCtrlStyle ) IMPLEMENT_DYNAMIC_CLASS_XTI(wxTextCtrl, wxControl,"wx/textctrl.h") wxBEGIN_PROPERTIES_TABLE(wxTextCtrl) - wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent ) + wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent ) wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent ) - wxPROPERTY( Font , wxFont , SetFont , GetFont ,, 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( Value , wxString , SetValue, GetValue, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) - wxPROPERTY_FLAGS( WindowStyle , wxTextCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style + wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) + wxPROPERTY( Value , wxString , SetValue, GetValue, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY_FLAGS( WindowStyle , wxTextCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style wxEND_PROPERTIES_TABLE() wxBEGIN_HANDLERS_TABLE(wxTextCtrl) @@ -182,16 +242,16 @@ wxEND_HANDLERS_TABLE() wxCONSTRUCTOR_6( wxTextCtrl , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size , long , WindowStyle) #else -IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) +IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxTextCtrlBase) #endif -BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) +BEGIN_EVENT_TABLE(wxTextCtrl, wxTextCtrlBase) EVT_CHAR(wxTextCtrl::OnChar) EVT_DROP_FILES(wxTextCtrl::OnDropFiles) #if wxUSE_RICHEDIT - EVT_RIGHT_UP(wxTextCtrl::OnRightClick) + EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu) #endif EVT_MENU(wxID_CUT, wxTextCtrl::OnCut) @@ -209,9 +269,6 @@ BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo) EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete) EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll) -#ifdef __WIN16__ - EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground) -#endif EVT_SET_FOCUS(wxTextCtrl::OnSetFocus) END_EVENT_TABLE() @@ -230,21 +287,30 @@ void wxTextCtrl::Init() m_verRichEdit = 0; #endif // wxUSE_RICHEDIT +#if wxUSE_INKEDIT && wxUSE_RICHEDIT + m_isInkEdit = 0; +#endif + m_privateContextMenu = NULL; - m_suppressNextUpdate = FALSE; + m_updatesCount = -1; m_isNativeCaretShown = true; } wxTextCtrl::~wxTextCtrl() { - if (m_privateContextMenu) +#if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT + if ( m_dropTarget == wxRICHTEXT_DEFAULT_DROPTARGET ) { - delete m_privateContextMenu; - m_privateContextMenu = NULL; + // don't try to destroy this dummy pointer in the base class dtor + m_dropTarget = NULL; } +#endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT + + delete m_privateContextMenu; } -bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, +bool wxTextCtrl::Create(wxWindow *parent, + wxWindowID id, const wxString& value, const wxPoint& pos, const wxSize& size, @@ -253,18 +319,56 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, const wxString& name) { // base initialization - if ( !CreateBase(parent, id, pos, size, style, validator, name) ) - return FALSE; + if ( !CreateControl(parent, id, pos, size, style, validator, name) ) + return false; + + if ( !MSWCreateText(value, pos, size) ) + return false; + +#if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT + if ( IsRich() ) + { + // rich text controls have a default associated drop target which + // allows them to receive (rich) text dropped on them, which is nice, + // but prevents us from associating a user-defined drop target with + // them as we need to unregister the old one first + // + // to make it work, we set m_dropTarget to this special value initially + // and check for it in our SetDropTarget() + m_dropTarget = wxRICHTEXT_DEFAULT_DROPTARGET; + } +#endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT - if ( parent ) - parent->AddChild(this); + return true; +} +// returns true if the platform should explicitly apply a theme border +bool wxTextCtrl::CanApplyThemeBorder() const +{ +#ifdef __WXWINCE__ + return false; +#else + // Standard text control already handles theming + return ((GetWindowStyle() & (wxTE_RICH|wxTE_RICH2)) != 0); +#endif +} + +bool wxTextCtrl::MSWCreateText(const wxString& value, + const wxPoint& pos, + const wxSize& size) +{ // translate wxWin style flags to MSW ones WXDWORD msStyle = MSWGetCreateWindowFlags(); // do create the control - either an EDIT or RICHEDIT wxString windowClass = wxT("EDIT"); +#if defined(__POCKETPC__) || defined(__SMARTPHONE__) + // A control that capitalizes the first letter + if ( HasFlag(wxTE_CAPITALIZE) ) + windowClass = wxT("CAPEDIT"); +#endif + #if wxUSE_RICHEDIT if ( m_windowStyle & wxTE_AUTO_URL ) { @@ -281,65 +385,90 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, // we need to load the richedit DLL before creating the rich edit control if ( m_windowStyle & wxTE_RICH ) { - static bool s_errorGiven = FALSE;// MT-FIXME - - // Which version do we need? Use 1.0 by default because it is much more - // like the the standard EDIT or 2.0 if explicitly requested, but use - // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all + // versions 2.0, 3.0 and 4.1 of rich edit are mostly compatible with + // each other but not with version 1.0, so we have separate flags for + // the version 1.0 and the others (and so m_verRichEdit may be 0 (plain + // EDIT control), 1 for version 1.0 or 2 for any higher version) // - // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0 - // (and thus EDIT) much better than RichEdit 2.0 so we probably - // should use 3.0 if available as it is the best of both worlds - - // but as I can't test it right now I don't do it (VZ) + // notice that 1.0 has no Unicode support at all so in Unicode build we + // must use another version + #if wxUSE_UNICODE - const int verRichEdit = 2; + m_verRichEdit = 2; #else // !wxUSE_UNICODE - int verRichEdit = m_windowStyle & wxTE_RICH2 ? 2 : 1; + m_verRichEdit = m_windowStyle & wxTE_RICH2 ? 2 : 1; #endif // wxUSE_UNICODE/!wxUSE_UNICODE - // only give the error msg once if the DLL can't be loaded - if ( !s_errorGiven ) +#if wxUSE_INKEDIT + // First test if we can load an ink edit control. Normally, all edit + // controls will be made ink edit controls if a tablet environment is + // found (or if msw.inkedit != 0 and the InkEd.dll is present). + // However, an application can veto ink edit controls by either specifying + // msw.inkedit = 0 or by removing wxTE_RICH[2] from the style. + // + if ((wxSystemSettings::HasFeature(wxSYS_TABLET_PRESENT) || wxSystemOptions::GetOptionInt(wxT("msw.inkedit")) != 0) && + !(wxSystemOptions::HasOption(wxT("msw.inkedit")) && wxSystemOptions::GetOptionInt(wxT("msw.inkedit")) == 0)) { - // try to load the RichEdit DLL (will do nothing if already done) - if ( !wxRichEditModule::Load(verRichEdit) ) + if (wxRichEditModule::LoadInkEdit()) { -#if !wxUSE_UNICODE - // try another version? - verRichEdit = 3 - verRichEdit; // 1 <-> 2 + windowClass = INKEDIT_CLASS; - if ( !wxRichEditModule::Load(verRichEdit) ) -#endif // wxUSE_UNICODE - { - wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll")); +#if wxUSE_INKEDIT && wxUSE_RICHEDIT + m_isInkEdit = 1; +#endif - s_errorGiven = TRUE; - } + // Fake rich text version for other calls + m_verRichEdit = 2; } } +#endif - // have we managed to load any richedit version? - if ( !s_errorGiven ) + if (!IsInkEdit()) { - m_verRichEdit = verRichEdit; - if ( m_verRichEdit == 1 ) - { - windowClass = wxT("RICHEDIT"); - } - else + if ( m_verRichEdit == 2 ) { -#ifndef RICHEDIT_CLASS - wxString RICHEDIT_CLASS; - RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), m_verRichEdit); + if ( wxRichEditModule::Load(wxRichEditModule::Version_41) ) + { + // yes, class name for version 4.1 really is 5.0 + windowClass = _T("RICHEDIT50W"); + } + else if ( wxRichEditModule::Load(wxRichEditModule::Version_2or3) ) + { + windowClass = _T("RichEdit20") #if wxUSE_UNICODE - RICHEDIT_CLASS += _T('W'); + _T("W"); #else // ANSI - RICHEDIT_CLASS += _T('A'); + _T("A"); #endif // Unicode/ANSI -#endif // !RICHEDIT_CLASS + } + else // failed to load msftedit.dll and riched20.dll + { + m_verRichEdit = 1; + } + } + + if ( m_verRichEdit == 1 ) + { + if ( wxRichEditModule::Load(wxRichEditModule::Version_1) ) + { + windowClass = _T("RICHEDIT"); + } + else // failed to load any richedit control DLL + { + // only give the error msg once if the DLL can't be loaded + static bool s_errorGiven = false; // MT ok as only used by GUI - windowClass = RICHEDIT_CLASS; + if ( !s_errorGiven ) + { + wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll")); + + s_errorGiven = true; + } + + m_verRichEdit = 0; + } } - } + } // !useInkEdit } #endif // wxUSE_RICHEDIT @@ -354,23 +483,44 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, valueWin = value; } - if ( !MSWCreateControl(windowClass, msStyle, pos, size, valueWin) ) - return FALSE; - - SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)); + if ( !MSWCreateControl(windowClass.wx_str(), msStyle, pos, size, valueWin) ) + return false; #if wxUSE_RICHEDIT - if ( IsRich() ) + if (IsRich()) { +#if wxUSE_INKEDIT + if (IsInkEdit()) + { + // Pass IEM_InsertText (0) as wParam, in order to have the ink always + // converted to text. + ::SendMessage(GetHwnd(), EM_SETINKINSERTMODE, 0, 0); + + // Make sure the mouse can be used for input + ::SendMessage(GetHwnd(), EM_SETUSEMOUSEFORINPUT, 1, 0); + } +#endif + // enable the events we're interested in: we want to get EN_CHANGE as // for the normal controls LPARAM mask = ENM_CHANGE; - if ( GetRichVersion() == 1 ) + if (GetRichVersion() == 1 && !IsInkEdit()) { // we also need EN_MSGFILTER for richedit 1.0 for the reasons // explained in its handler mask |= ENM_MOUSEEVENTS; + + // we also need to force the appearance of the vertical scrollbar + // initially as otherwise the control doesn't refresh correctly + // after resize: but once the vertical scrollbar had been shown + // (even if it's subsequently hidden) it does + // + // this is clearly a bug and for now it has been only noticed under + // Windows XP, so if we're sure it works correctly under other + // systems we could do this only for XP + SetSize(-1, 1); // 1 is small enough to force vert scrollbar + SetInitialSize(size); } else if ( m_windowStyle & wxTE_AUTO_URL ) { @@ -383,7 +533,15 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, } #endif // wxUSE_RICHEDIT - return TRUE; +#ifndef __WXWINCE__ + // Without this, if we pass the size in the constructor and then don't change it, + // the themed borders will be drawn incorrectly. + SetWindowPos(GetHwnd(), NULL, 0, 0, 0, 0, + SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE| + SWP_FRAMECHANGED); +#endif + + return true; } // Make sure the window style (etc.) reflects the HWND style (roughly) @@ -398,7 +556,7 @@ void wxTextCtrl::AdoptAttributesFromHWND() #if wxUSE_RICHEDIT wxString classname = wxGetWindowClass(GetHWND()); - if ( classname.IsSameAs(_T("EDIT"), FALSE /* no case */) ) + if ( classname.IsSameAs(_T("EDIT"), false /* no case */) ) { m_verRichEdit = 0; } @@ -432,12 +590,9 @@ WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const { long msStyle = wxControl::MSWGetStyle(style, exstyle); - // styles which we alaways add by default + // styles which we always add by default if ( style & wxTE_MULTILINE ) { - wxASSERT_MSG( !(style & wxTE_PROCESS_ENTER), - wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") ); - msStyle |= ES_MULTILINE | ES_WANTRETURN; if ( !(style & wxTE_NO_VSCROLL) ) { @@ -469,7 +624,12 @@ WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const if ( style & wxTE_DONTWRAP ) { // automatically scroll the control horizontally as necessary - msStyle |= WS_HSCROLL; + // + // NB: ES_AUTOHSCROLL is needed for richedit controls or they don't + // show horz scrollbar at all, even in spite of WS_HSCROLL, and as + // it doesn't seem to do any harm for plain edit controls, add it + // always + msStyle |= WS_HSCROLL | ES_AUTOHSCROLL; } if ( style & wxTE_READONLY ) @@ -494,6 +654,62 @@ WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const void wxTextCtrl::SetWindowStyleFlag(long style) { + // changing the alignment of the control dynamically works under Win2003 + // (but not older Windows version: it seems to work under some versions of + // XP but not other ones, and we have no way to determine it so be + // conservative here) and only for plain EDIT controls (not RICH ones) and + // we have to recreate the control to make it always work + if ( IsRich() || wxGetWinVersion() < wxWinVersion_2003 ) + { + const long alignMask = wxTE_LEFT | wxTE_CENTRE | wxTE_RIGHT; + if ( (style & alignMask) != (GetWindowStyle() & alignMask) ) + { + const wxString value = GetValue(); + const wxPoint pos = GetPosition(); + const wxSize size = GetSize(); + + // delete the old window + HWND hwnd = GetHwnd(); + DissociateHandle(); + ::DestroyWindow(hwnd); + + // create the new one with the updated flags + m_windowStyle = style; + MSWCreateText(value, pos, size); + + // and make sure it has the same attributes as before + if ( m_hasFont ) + { + // calling SetFont(m_font) would do nothing as the code would + // notice that the font didn't change, so force it to believe + // that it did + wxFont font = m_font; + m_font = wxNullFont; + SetFont(font); + } + + if ( m_hasFgCol ) + { + wxColour colFg = m_foregroundColour; + m_foregroundColour = wxNullColour; + SetForegroundColour(colFg); + } + + if ( m_hasBgCol ) + { + wxColour colBg = m_backgroundColour; + m_backgroundColour = wxNullColour; + SetBackgroundColour(colBg); + } + + // note that text styles are lost but this is probably not a big + // problem: if you use styles, you probably don't use nor change + // alignment flags anyhow + + return; + } + } + #if wxUSE_RICHEDIT // we have to deal with some styles separately because they can't be // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed @@ -515,6 +731,15 @@ void wxTextCtrl::SetWindowStyleFlag(long style) // set/get the controls text // ---------------------------------------------------------------------------- +bool wxTextCtrl::IsEmpty() const +{ + // this is an optimization for multiline controls containing a lot of text + if ( IsMultiLine() && GetNumberOfLines() != 1 ) + return false; + + return wxTextCtrlBase::IsEmpty(); +} + wxString wxTextCtrl::GetValue() const { // range 0..-1 is special for GetRange() and means to retrieve all text @@ -537,6 +762,52 @@ wxString wxTextCtrl::GetRange(long from, long to) const int len = GetWindowTextLength(GetHwnd()); if ( len > from ) { + if ( to == -1 ) + to = len; + +#if !wxUSE_UNICODE + // we must use EM_STREAMOUT if we don't want to lose all characters + // not representable in the current character set (EM_GETTEXTRANGE + // simply replaces them with question marks...) + if ( GetRichVersion() > 1 ) + { + // we must have some encoding, otherwise any 8bit chars in the + // control are simply *lost* (replaced by '?') + wxFontEncoding encoding = wxFONTENCODING_SYSTEM; + + wxFont font = m_defaultStyle.GetFont(); + if ( !font.Ok() ) + font = GetFont(); + + if ( font.Ok() ) + { + encoding = font.GetEncoding(); + } + + if ( encoding == wxFONTENCODING_SYSTEM ) + { + encoding = wxLocale::GetSystemEncoding(); + } + + if ( encoding == wxFONTENCODING_SYSTEM ) + { + encoding = wxFONTENCODING_ISO8859_1; + } + + str = StreamOut(encoding); + + if ( !str.empty() ) + { + // we have to manually extract the required part, luckily + // this is easy in this case as EOL characters in str are + // just LFs because we remove CRs in wxRichEditStreamOut + str = str.Mid(from, to - from); + } + } + + // StreamOut() wasn't used or failed, try to do it in normal way + if ( str.empty() ) +#endif // !wxUSE_UNICODE { // alloc one extra WORD as needed by the control wxStringBuffer tmp(str, ++len); @@ -544,11 +815,11 @@ wxString wxTextCtrl::GetRange(long from, long to) const TEXTRANGE textRange; textRange.chrg.cpMin = from; - textRange.chrg.cpMax = to == -1 ? len : to; + textRange.chrg.cpMax = to; textRange.lpstrText = p; - (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE, - 0, (LPARAM)&textRange); + (void)::SendMessage(GetHwnd(), EM_GETTEXTRANGE, + 0, (LPARAM)&textRange); if ( m_verRichEdit > 1 ) { @@ -592,7 +863,7 @@ wxString wxTextCtrl::GetRange(long from, long to) const return str; } -void wxTextCtrl::SetValue(const wxString& value) +void wxTextCtrl::DoSetValue(const wxString& value, int flags) { // if the text is long enough, it's faster to just set it instead of first // comparing it with the old one (chances are that it will be different @@ -600,32 +871,42 @@ void wxTextCtrl::SetValue(const wxString& value) // edit controls mostly) if ( (value.length() > 0x400) || (value != GetValue()) ) { - DoWriteText(value, FALSE /* not selection only */); + DoWriteText(value, flags /* doesn't include SelectionOnly here */); + + // mark the control as being not dirty - we changed its text, not the + // user + DiscardEdits(); + + // for compatibility, don't move the cursor when doing SetValue() + SetInsertionPoint(0); } else // same text { + // still reset the modified flag even if the value didn't really change + // because now it comes from the program and not the user (and do it + // before generating the event so that the event handler could get the + // expected value from IsModified()) + DiscardEdits(); + // still send an event for consistency - SendUpdateEvent(); + if (flags & SetValue_SendEvent) + SendUpdateEvent(); } - - // we should reset the modified flag even if the value didn't really change - - // mark the control as being not dirty - we changed its text, not the - // user - DiscardEdits(); - - // for compatibility, don't move the cursor when doing SetValue() - SetInsertionPoint(0); } #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU) -DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) +// TODO: using memcpy() would improve performance a lot for big amounts of text + +DWORD CALLBACK +wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) { *pcb = 0; + const wchar_t ** const ppws = (const wchar_t **)dwCookie; + wchar_t *wbuf = (wchar_t *)buf; - const wchar_t *wpc = *(const wchar_t **)dwCookie; + const wchar_t *wpc = *ppws; while ( cb && *wpc ) { *wbuf++ = *wpc++; @@ -634,69 +915,85 @@ DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) (*pcb) += sizeof(wchar_t); } - *(const wchar_t **)dwCookie = wpc; + *ppws = wpc; return 0; } -// from utils.cpp -extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding); - -#if wxUSE_UNICODE_MSLU -bool wxTextCtrl::StreamIn(const wxString& value, - wxFontEncoding WXUNUSED(encoding), - bool selectionOnly) +// helper struct used to pass parameters from wxTextCtrl to wxRichEditStreamOut +struct wxStreamOutData { - const wchar_t *wpc = value.c_str(); -#else // !wxUSE_UNICODE_MSLU -bool wxTextCtrl::StreamIn(const wxString& value, - wxFontEncoding encoding, - bool selectionOnly) + wchar_t *wpc; + size_t len; +}; + +DWORD CALLBACK +wxRichEditStreamOut(DWORD_PTR dwCookie, BYTE *buf, LONG cb, LONG *pcb) { - // we have to use EM_STREAMIN to force richedit control 2.0+ to show any - // text in the non default charset -- otherwise it thinks it knows better - // than we do and always shows it in the default one + *pcb = 0; + + wxStreamOutData *data = (wxStreamOutData *)dwCookie; - // first get the Windows code page for this encoding - long codepage = wxEncodingToCodepage(encoding); - if ( codepage == -1 ) + const wchar_t *wbuf = (const wchar_t *)buf; + wchar_t *wpc = data->wpc; + while ( cb ) { - // unknown encoding - return FALSE; + wchar_t wch = *wbuf++; + + // turn "\r\n" into "\n" on the fly + if ( wch != L'\r' ) + *wpc++ = wch; + else + data->len--; + + cb -= sizeof(wchar_t); + (*pcb) += sizeof(wchar_t); } - // next translate to Unicode using this code page - int len = ::MultiByteToWideChar(codepage, 0, value, -1, NULL, 0); + data->wpc = wpc; + + return 0; +} + + +#if wxUSE_UNICODE_MSLU + #define UNUSED_IF_MSLU(param) +#else + #define UNUSED_IF_MSLU(param) param +#endif + +bool +wxTextCtrl::StreamIn(const wxString& value, + wxFontEncoding UNUSED_IF_MSLU(encoding), + bool selectionOnly) +{ +#if wxUSE_UNICODE_MSLU + const wchar_t *wpc = value.c_str(); +#else // !wxUSE_UNICODE_MSLU + wxCSConv conv(encoding); + + const size_t len = conv.MB2WC(NULL, value.mb_str(), value.length()); #if wxUSE_WCHAR_T wxWCharBuffer wchBuf(len); + wchar_t *wpc = wchBuf.data(); #else wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t)); + wchar_t *wpc = wchBuf; #endif - if ( !::MultiByteToWideChar(codepage, 0, value, -1, - (wchar_t *)(const wchar_t *)wchBuf, len) ) - { - wxLogLastError(_T("MultiByteToWideChar")); - } - - // finally, stream it in the control - const wchar_t *wpc = wchBuf; + conv.MB2WC(wpc, value.mb_str(), value.length()); #endif // wxUSE_UNICODE_MSLU + // finally, stream it in the control EDITSTREAM eds; wxZeroMemory(eds); eds.dwCookie = (DWORD)&wpc; // the cast below is needed for broken (very) old mingw32 headers eds.pfnCallback = (EDITSTREAMCALLBACK)wxRichEditStreamIn; - // we're going to receive 2 EN_CHANGE notifications if we got any selection - // (same problem as in DoWriteText()) - if ( selectionOnly && HasSelection() ) - { - // so suppress one of them - m_suppressNextUpdate = TRUE; - } + // same problem as in DoWriteText(): we can get multiple events here + UpdatesCountFilter ucf(m_updatesCount); ::SendMessage(GetHwnd(), EM_STREAMIN, SF_TEXT | @@ -704,6 +1001,11 @@ bool wxTextCtrl::StreamIn(const wxString& value, (selectionOnly ? SFF_SELECTION : 0), (LPARAM)&eds); + // It's okay for EN_UPDATE to not be sent if the selection is empty and + // the text is empty, otherwise warn the programmer about it. + wxASSERT_MSG( ucf.GotUpdate() || ( !HasSelection() && value.empty() ), + _T("EM_STREAMIN didn't send EN_UPDATE?") ); + if ( eds.dwError ) { wxLogLastError(_T("EM_STREAMIN")); @@ -713,9 +1015,72 @@ bool wxTextCtrl::StreamIn(const wxString& value, free(wchBuf); #endif // !wxUSE_WCHAR_T - return TRUE; + return true; +} + +#if !wxUSE_UNICODE_MSLU + +wxString +wxTextCtrl::StreamOut(wxFontEncoding encoding, bool selectionOnly) const +{ + wxString out; + + const int len = GetWindowTextLength(GetHwnd()); + +#if wxUSE_WCHAR_T + wxWCharBuffer wchBuf(len); + wchar_t *wpc = wchBuf.data(); +#else + wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t)); + wchar_t *wpc = wchBuf; +#endif + + wxStreamOutData data; + data.wpc = wpc; + data.len = len; + + EDITSTREAM eds; + wxZeroMemory(eds); + eds.dwCookie = (DWORD)&data; + eds.pfnCallback = wxRichEditStreamOut; + + ::SendMessage + ( + GetHwnd(), + EM_STREAMOUT, + SF_TEXT | SF_UNICODE | (selectionOnly ? SFF_SELECTION : 0), + (LPARAM)&eds + ); + + if ( eds.dwError ) + { + wxLogLastError(_T("EM_STREAMOUT")); + } + else // streamed out ok + { + // NUL-terminate the string because its length could have been + // decreased by wxRichEditStreamOut + *(wchBuf.data() + data.len) = L'\0'; + + // now convert to the given encoding (this is a possibly lossful + // conversion but what else can we do) + wxCSConv conv(encoding); + size_t lenNeeded = conv.WC2MB(NULL, wchBuf, 0); + if ( lenNeeded++ ) + { + conv.WC2MB(wxStringBuffer(out, lenNeeded), wchBuf, lenNeeded); + } + } + +#if !wxUSE_WCHAR_T + free(wchBuf); +#endif // !wxUSE_WCHAR_T + + return out; } +#endif // !wxUSE_UNICODE_MSLU + #endif // wxUSE_RICHEDIT void wxTextCtrl::WriteText(const wxString& value) @@ -723,8 +1088,9 @@ void wxTextCtrl::WriteText(const wxString& value) DoWriteText(value); } -void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) +void wxTextCtrl::DoWriteText(const wxString& value, int flags) { + bool selectionOnly = (flags & SetValue_SelectionOnly) != 0; wxString valueDos; if ( m_windowStyle & wxTE_MULTILINE ) valueDos = wxTextFile::Translate(value, wxTextFileType_Dos); @@ -733,7 +1099,7 @@ void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) #if wxUSE_RICHEDIT // there are several complications with the rich edit controls here - bool done = FALSE; + bool done = false; if ( IsRich() ) { // first, ensure that the new text will be in the default style @@ -767,6 +1133,10 @@ void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) wxFontEncoding encoding = font.GetEncoding(); if ( encoding != wxFONTENCODING_SYSTEM ) { + // we have to use EM_STREAMIN to force richedit control 2.0+ + // to show any text in the non default charset -- otherwise + // it thinks it knows better than we do and always shows it + // in the default one done = StreamIn(valueDos, encoding, selectionOnly); } } @@ -778,50 +1148,35 @@ void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) #endif // wxUSE_RICHEDIT { // in some cases we get 2 EN_CHANGE notifications after the SendMessage - // call below which is confusing for the client code and so should be - // avoided - // - // these cases are: (a) plain EDIT controls if EM_REPLACESEL is used - // and there is a non empty selection currently and (b) rich text - // controls in any case - if ( -#if wxUSE_RICHEDIT - IsRich() || -#endif // wxUSE_RICHEDIT - (selectionOnly && HasSelection()) ) - { - m_suppressNextUpdate = TRUE; - } + // call (this happens for plain EDITs with EM_REPLACESEL and under some + // -- undetermined -- conditions with rich edit) and sometimes we don't + // get any events at all (plain EDIT with WM_SETTEXT), so ensure that + // we generate exactly one of them by ignoring all but the first one in + // SendUpdateEvent() and generating one ourselves if we hadn't got any + // notifications from Windows + if ( !(flags & SetValue_SendEvent) ) + m_updatesCount = -2; // suppress any update event + + UpdatesCountFilter ucf(m_updatesCount); ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL : WM_SETTEXT, - 0, (LPARAM)valueDos.c_str()); + // EM_REPLACESEL takes 1 to indicate the operation should be redoable + selectionOnly ? 1 : 0, (LPARAM)valueDos.wx_str()); - // OTOH, non rich text controls don't generate any events at all when - // we use WM_SETTEXT -- have to emulate them here - if ( !selectionOnly -#if wxUSE_RICHEDIT - && !IsRich() -#endif // wxUSE_RICHEDIT - ) + if ( !ucf.GotUpdate() && (flags & SetValue_SendEvent) ) { - // Windows already sends an update event for single-line - // controls. - if ( m_windowStyle & wxTE_MULTILINE ) - SendUpdateEvent(); + SendUpdateEvent(); } } - - AdjustSpaceLimit(); } void wxTextCtrl::AppendText(const wxString& text) { - SetInsertionPointEnd(); - - WriteText(text); + wxTextEntry::AppendText(text); #if wxUSE_RICHEDIT - if ( IsMultiLine() && GetRichVersion() > 1 ) + // don't do this if we're frozen, saves some time + if ( !IsFrozen() && IsMultiLine() && GetRichVersion() > 1 ) { // setting the caret to the end and showing it simply doesn't work for // RichEdit 2.0 -- force it to still do what we want @@ -834,18 +1189,12 @@ void wxTextCtrl::Clear() { ::SetWindowText(GetHwnd(), wxEmptyString); -#if wxUSE_RICHEDIT - if ( !IsRich() ) -#endif // wxUSE_RICHEDIT + if ( IsMultiLine() && !IsRich() ) { // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves // but the normal ones don't -- make Clear() behaviour consistent by // always sending this event - - // Windows already sends an update event for single-line - // controls. - if ( m_windowStyle & wxTE_MULTILINE ) - SendUpdateEvent(); + SendUpdateEvent(); } } @@ -858,8 +1207,8 @@ bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent& event) size_t lenOld = GetValue().length(); wxUint32 code = event.GetRawKeyCode(); - ::keybd_event(code, 0, 0 /* key press */, 0); - ::keybd_event(code, 0, KEYEVENTF_KEYUP, 0); + ::keybd_event((BYTE)code, 0, 0 /* key press */, 0); + ::keybd_event((BYTE)code, 0, KEYEVENTF_KEYUP, 0); // assume that any alphanumeric key changes the total number of characters // in the control - this should work in 99% of cases @@ -869,89 +1218,8 @@ bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent& event) #endif // __WIN32__ // ---------------------------------------------------------------------------- -// Clipboard operations -// ---------------------------------------------------------------------------- - -void wxTextCtrl::Copy() -{ - if (CanCopy()) - { - ::SendMessage(GetHwnd(), WM_COPY, 0, 0L); - } -} - -void wxTextCtrl::Cut() -{ - if (CanCut()) - { - ::SendMessage(GetHwnd(), WM_CUT, 0, 0L); - } -} - -void wxTextCtrl::Paste() -{ - if (CanPaste()) - { - ::SendMessage(GetHwnd(), WM_PASTE, 0, 0L); - } -} - -bool wxTextCtrl::HasSelection() const -{ - long from, to; - GetSelection(&from, &to); - return from != to; -} - -bool wxTextCtrl::CanCopy() const -{ - // Can copy if there's a selection - return HasSelection(); -} - -bool wxTextCtrl::CanCut() const -{ - return CanCopy() && IsEditable(); -} - -bool wxTextCtrl::CanPaste() const -{ - if ( !IsEditable() ) - return FALSE; - -#if wxUSE_RICHEDIT - if ( IsRich() ) - { - UINT cf = 0; // 0 == any format - - return ::SendMessage(GetHwnd(), EM_CANPASTE, cf, 0) != 0; - } -#endif // wxUSE_RICHEDIT - - // Standard edit control: check for straight text on clipboard - if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) ) - return FALSE; - - bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0; - ::CloseClipboard(); - - return isTextAvailable; -} - -// ---------------------------------------------------------------------------- -// Accessors -// ---------------------------------------------------------------------------- - -void wxTextCtrl::SetEditable(bool editable) -{ - HWND hWnd = GetHwnd(); - SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L); -} - -void wxTextCtrl::SetInsertionPoint(long pos) -{ - DoSetSelection(pos, pos); -} +// Accessors +// ---------------------------------------------------------------------------- void wxTextCtrl::SetInsertionPointEnd() { @@ -960,24 +1228,13 @@ void wxTextCtrl::SetInsertionPointEnd() // if it doesn't actually move the caret anywhere and so the simple fact of // doing it results in horrible flicker when appending big amounts of text // to the control in a few chunks (see DoAddText() test in the text sample) - if ( GetInsertionPoint() == GetLastPosition() ) - return; - - long pos; - -#if wxUSE_RICHEDIT - if ( m_verRichEdit == 1 ) - { - // we don't have to waste time calling GetLastPosition() in this case - pos = -1; - } - else // !RichEdit 1.0 -#endif // wxUSE_RICHEDIT + const wxTextPos lastPosition = GetLastPosition(); + if ( GetInsertionPoint() == lastPosition ) { - pos = GetLastPosition(); + return; } - SetInsertionPoint(pos); + SetInsertionPoint(lastPosition); } long wxTextCtrl::GetInsertionPoint() const @@ -988,28 +1245,32 @@ long wxTextCtrl::GetInsertionPoint() const CHARRANGE range; range.cpMin = 0; range.cpMax = 0; - SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range); + ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range); return range.cpMin; } #endif // wxUSE_RICHEDIT - DWORD Pos = (DWORD)SendMessage(GetHwnd(), EM_GETSEL, 0, 0L); - return Pos & 0xFFFF; + return wxTextEntry::GetInsertionPoint(); } -long wxTextCtrl::GetLastPosition() const +wxTextPos wxTextCtrl::GetLastPosition() const { - int numLines = GetNumberOfLines(); - long posStartLastLine = XYToPosition(0, numLines - 1); + if ( IsMultiLine() ) + { + int numLines = GetNumberOfLines(); + long posStartLastLine = XYToPosition(0, numLines - 1); - long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine); + long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine); - return posStartLastLine + lenLastLine; + return posStartLastLine + lenLastLine; + } + + return wxTextEntry::GetLastPosition(); } // If the return values from and to are the same, there is no // selection. -void wxTextCtrl::GetSelection(long* from, long* to) const +void wxTextCtrl::GetSelection(long *from, long *to) const { #if wxUSE_RICHEDIT if ( IsRich() ) @@ -1023,64 +1284,33 @@ void wxTextCtrl::GetSelection(long* from, long* to) const else #endif // !wxUSE_RICHEDIT { - DWORD dwStart, dwEnd; - ::SendMessage(GetHwnd(), EM_GETSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd); - - *from = dwStart; - *to = dwEnd; + wxTextEntry::GetSelection(from, to); } } -bool wxTextCtrl::IsEditable() const -{ - // strangely enough, we may be called before the control is created: our - // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls - // us - if ( !m_hWnd ) - return TRUE; - - long style = ::GetWindowLong(GetHwnd(), GWL_STYLE); - - return (style & ES_READONLY) == 0; -} - // ---------------------------------------------------------------------------- // selection // ---------------------------------------------------------------------------- -void wxTextCtrl::SetSelection(long from, long to) -{ - // if from and to are both -1, it means (in wxWindows) that all text should - // be selected - translate into Windows convention - if ( (from == -1) && (to == -1) ) - { - from = 0; - to = -1; - } - - DoSetSelection(from, to); -} - -void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) +void wxTextCtrl::DoSetSelection(long from, long to, int flags) { HWND hWnd = GetHwnd(); -#ifdef __WIN32__ #if wxUSE_RICHEDIT if ( IsRich() ) { CHARRANGE range; range.cpMin = from; range.cpMax = to; - SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range); + ::SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM)&range); } else #endif // wxUSE_RICHEDIT { - SendMessage(hWnd, EM_SETSEL, (WPARAM)from, (LPARAM)to); + ::SendMessage(hWnd, EM_SETSEL, from, to); } - if ( scrollCaret ) + if ( (flags & SetSel_Scroll) && !IsFrozen() ) { #if wxUSE_RICHEDIT // richedit 3.0 (i.e. the version living in riched20.dll distributed @@ -1099,10 +1329,14 @@ void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) // ES_DISABLENOSCROLL // // this is very ugly but I don't see any other way to make this work + long style = 0; if ( GetRichVersion() > 1 ) { if ( !HasFlag(wxTE_NOHIDESEL) ) { + // setting ECO_NOHIDESEL also sets WS_VISIBLE and possibly + // others, remember the style so we can reset it later if needed + style = ::GetWindowLong(GetHwnd(), GWL_STYLE); ::SendMessage(GetHwnd(), EM_SETOPTIONS, ECOOP_OR, ECO_NOHIDESEL); } @@ -1110,7 +1344,7 @@ void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) } #endif // wxUSE_RICHEDIT - SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); + ::SendMessage(hWnd, EM_SCROLLCARET, 0, (LPARAM)0); #if wxUSE_RICHEDIT // restore ECO_NOHIDESEL if we changed it @@ -1118,71 +1352,62 @@ void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) { ::SendMessage(GetHwnd(), EM_SETOPTIONS, ECOOP_AND, ~ECO_NOHIDESEL); + if ( style != ::GetWindowLong(GetHwnd(), GWL_STYLE) ) + ::SetWindowLong(GetHwnd(), GWL_STYLE, style); } #endif // wxUSE_RICHEDIT } -#else // Win16 - // WPARAM is 0: selection is scrolled into view - SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(from, to)); -#endif // Win32/16 } // ---------------------------------------------------------------------------- -// Editing +// Working with files // ---------------------------------------------------------------------------- -void wxTextCtrl::Replace(long from, long to, const wxString& value) -{ - // Set selection and remove it - DoSetSelection(from, to, FALSE /* don't scroll caret into view */); - - SendMessage(GetHwnd(), EM_REPLACESEL, -#ifdef __WIN32__ - TRUE, -#else - FALSE, -#endif - (LPARAM)value.c_str()); -} - -void wxTextCtrl::Remove(long from, long to) -{ - Replace(from, to, wxEmptyString); -} - -bool wxTextCtrl::LoadFile(const wxString& file) +bool wxTextCtrl::DoLoadFile(const wxString& file, int fileType) { - if ( wxTextCtrlBase::LoadFile(file) ) + if ( wxTextCtrlBase::DoLoadFile(file, fileType) ) { // update the size limit if needed AdjustSpaceLimit(); - return TRUE; + return true; } - return FALSE; + return false; } +// ---------------------------------------------------------------------------- +// dirty status +// ---------------------------------------------------------------------------- + bool wxTextCtrl::IsModified() const { - return SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0; + return ::SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0; +} + +void wxTextCtrl::MarkDirty() +{ + ::SendMessage(GetHwnd(), EM_SETMODIFY, TRUE, 0); } -// Makes 'unmodified' void wxTextCtrl::DiscardEdits() { - SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0L); + ::SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0); } +// ---------------------------------------------------------------------------- +// Positions <-> coords +// ---------------------------------------------------------------------------- + int wxTextCtrl::GetNumberOfLines() const { - return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0); + return (int)::SendMessage(GetHwnd(), EM_GETLINECOUNT, 0, 0); } long wxTextCtrl::XYToPosition(long x, long y) const { // This gets the char index for the _beginning_ of this line - long charIndex = SendMessage(GetHwnd(), EM_LINEINDEX, (WPARAM)y, (LPARAM)0); + long charIndex = ::SendMessage(GetHwnd(), EM_LINEINDEX, y, 0); return charIndex + x; } @@ -1196,25 +1421,25 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const #if wxUSE_RICHEDIT if ( IsRich() ) { - lineNo = SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos); + lineNo = ::SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, pos); } else #endif // wxUSE_RICHEDIT { - lineNo = SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0); + lineNo = ::SendMessage(hWnd, EM_LINEFROMCHAR, pos, 0); } if ( lineNo == -1 ) { // no such line - return FALSE; + return false; } // This gets the char index for the _beginning_ of this line - long charIndex = SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0); + long charIndex = ::SendMessage(hWnd, EM_LINEINDEX, lineNo, 0); if ( charIndex == -1 ) { - return FALSE; + return false; } // The X position must therefore be the different between pos and charIndex @@ -1223,9 +1448,99 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const if ( y ) *y = lineNo; - return TRUE; + return true; +} + +wxTextCtrlHitTestResult +wxTextCtrl::HitTest(const wxPoint& pt, long *posOut) const +{ + // first get the position from Windows + LPARAM lParam; + +#if wxUSE_RICHEDIT + POINTL ptl; + if ( IsRich() ) + { + // for rich edit controls the position is passed iva the struct fields + ptl.x = pt.x; + ptl.y = pt.y; + lParam = (LPARAM)&ptl; + } + else +#endif // wxUSE_RICHEDIT + { + // for the plain ones, we are limited to 16 bit positions which are + // combined in a single 32 bit value + lParam = MAKELPARAM(pt.x, pt.y); + } + + LRESULT pos = ::SendMessage(GetHwnd(), EM_CHARFROMPOS, 0, lParam); + + if ( pos == -1 ) + { + // this seems to indicate an error... + return wxTE_HT_UNKNOWN; + } + +#if wxUSE_RICHEDIT + if ( !IsRich() ) +#endif // wxUSE_RICHEDIT + { + // for plain EDIT controls the higher word contains something else + pos = LOWORD(pos); + } + + + // next determine where it is relatively to our point: EM_CHARFROMPOS + // always returns the closest character but we need to be more precise, so + // double check that we really are where it pretends + POINTL ptReal; + +#if wxUSE_RICHEDIT + // FIXME: we need to distinguish between richedit 2 and 3 here somehow but + // we don't know how to do it + if ( IsRich() ) + { + ::SendMessage(GetHwnd(), EM_POSFROMCHAR, (WPARAM)&ptReal, pos); + } + else +#endif // wxUSE_RICHEDIT + { + LRESULT lRc = ::SendMessage(GetHwnd(), EM_POSFROMCHAR, pos, 0); + + if ( lRc == -1 ) + { + // this is apparently returned when pos corresponds to the last + // position + ptReal.x = + ptReal.y = 0; + } + else + { + ptReal.x = LOWORD(lRc); + ptReal.y = HIWORD(lRc); + } + } + + wxTextCtrlHitTestResult rc; + + if ( pt.y > ptReal.y + GetCharHeight() ) + rc = wxTE_HT_BELOW; + else if ( pt.x > ptReal.x + GetCharWidth() ) + rc = wxTE_HT_BEYOND; + else + rc = wxTE_HT_ON_TEXT; + + if ( posOut ) + *posOut = pos; + + return rc; } +// ---------------------------------------------------------------------------- +// +// ---------------------------------------------------------------------------- + void wxTextCtrl::ShowPosition(long pos) { HWND hWnd = GetHwnd(); @@ -1239,21 +1554,21 @@ void wxTextCtrl::ShowPosition(long pos) // Is this where scrolling is relative to - the line containing the caret? // Or is the first visible line??? Try first visible line. -// int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L); +// int currentLineLineNo1 = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, -1, 0L); - int currentLineLineNo = (int)SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L); + int currentLineLineNo = (int)::SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, 0, 0); - int specifiedLineLineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L); + int specifiedLineLineNo = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, pos, 0); int linesToScroll = specifiedLineLineNo - currentLineLineNo; if (linesToScroll != 0) - (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll); + ::SendMessage(hWnd, EM_LINESCROLL, 0, linesToScroll); } long wxTextCtrl::GetLengthOfLineContainingPos(long pos) const { - return ::SendMessage(GetHwnd(), EM_LINELENGTH, (WPARAM)pos, 0); + return ::SendMessage(GetHwnd(), EM_LINELENGTH, pos, 0); } int wxTextCtrl::GetLineLength(long lineNo) const @@ -1286,9 +1601,16 @@ wxString wxTextCtrl::GetLineText(long lineNo) const // should never see it if ( buf[len - 2] == _T('\r') && buf[len - 1] == _T('\n') ) { + // richedit 1.0 uses "\r\n" as line terminator, so remove "\r" + // here and "\n" below buf[len - 2] = _T('\n'); len--; } + else if ( buf[len - 1] == _T('\r') ) + { + // richedit 2.0+ uses only "\r", replace it with "\n" + buf[len - 1] = _T('\n'); + } } #endif // wxUSE_RICHEDIT @@ -1308,38 +1630,43 @@ wxString wxTextCtrl::GetLineText(long lineNo) const void wxTextCtrl::SetMaxLength(unsigned long len) { - ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0); +#if wxUSE_RICHEDIT + if ( IsRich() ) + { + ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, len ? len : 0x7fffffff); + } + else +#endif // wxUSE_RICHEDIT + { + wxTextEntry::SetMaxLength(len); + } } // ---------------------------------------------------------------------------- // Undo/redo // ---------------------------------------------------------------------------- -void wxTextCtrl::Undo() -{ - if (CanUndo()) - { - ::SendMessage(GetHwnd(), EM_UNDO, 0, 0); - } -} - void wxTextCtrl::Redo() { - if (CanRedo()) +#if wxUSE_RICHEDIT + if ( GetRichVersion() > 1 ) { - // Same as Undo, since Undo undoes the undo, i.e. a redo. - ::SendMessage(GetHwnd(), EM_UNDO, 0, 0); + ::SendMessage(GetHwnd(), EM_REDO, 0, 0); + return; } -} +#endif // wxUSE_RICHEDIT -bool wxTextCtrl::CanUndo() const -{ - return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; + wxTextEntry::Redo(); } bool wxTextCtrl::CanRedo() const { - return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; +#if wxUSE_RICHEDIT + if ( GetRichVersion() > 1 ) + return ::SendMessage(GetHwnd(), EM_CANREDO, 0, 0) != 0; +#endif // wxUSE_RICHEDIT + + return wxTextEntry::CanRedo(); } // ---------------------------------------------------------------------------- @@ -1353,7 +1680,7 @@ bool wxTextCtrl::ShowNativeCaret(bool show) if ( !(show ? ::ShowCaret(GetHwnd()) : ::HideCaret(GetHwnd())) ) { // not an error, may simply indicate that it's not shown/hidden - // yet (i.e. it had been hidden/showh 2 times before) + // yet (i.e. it had been hidden/shown 2 times before) return false; } @@ -1364,7 +1691,7 @@ bool wxTextCtrl::ShowNativeCaret(bool show) } // ---------------------------------------------------------------------------- -// implemenation details +// implementation details // ---------------------------------------------------------------------------- void wxTextCtrl::Command(wxCommandEvent & event) @@ -1386,20 +1713,19 @@ void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event) // kbd input processing // ---------------------------------------------------------------------------- -bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) +bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* msg) { - MSG *msg = (MSG *)pMsg; - // check for our special keys here: if we don't do it and the parent frame // uses them as accelerators, they wouldn't work at all, so we disable // usual preprocessing for them if ( msg->message == WM_KEYDOWN ) { - WORD vkey = (WORD) msg->wParam; - if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN ) + const WPARAM vkey = msg->wParam; + if ( HIWORD(msg->lParam) & KF_ALTDOWN ) { + // Alt-Backspace is accelerator for "Undo" if ( vkey == VK_BACK ) - return FALSE; + return false; } else // no Alt { @@ -1415,6 +1741,9 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) // fall through case 0: + if ( IsMultiLine() && vkey == VK_RETURN ) + return false; + // fall through case 2: break; @@ -1431,19 +1760,19 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) case VK_DELETE: case VK_HOME: case VK_END: - return FALSE; + return false; } } else // Shift is pressed { if ( vkey == VK_INSERT || vkey == VK_DELETE ) - return FALSE; + return false; } } } } - return wxControl::MSWShouldPreProcessMessage(pMsg); + return wxControl::MSWShouldPreProcessMessage(msg); } void wxTextCtrl::OnChar(wxKeyEvent& event) @@ -1451,31 +1780,51 @@ void wxTextCtrl::OnChar(wxKeyEvent& event) switch ( event.GetKeyCode() ) { case WXK_RETURN: - if ( !(m_windowStyle & wxTE_MULTILINE) ) { wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId); InitCommandEvent(event); event.SetString(GetValue()); if ( GetEventHandler()->ProcessEvent(event) ) + if ( !HasFlag(wxTE_MULTILINE) ) return; + //else: multiline controls need Enter for themselves } - //else: multiline controls need Enter for themselves - break; case WXK_TAB: - // always produce navigation event - even if we process TAB - // ourselves the fact that we got here means that the user code - // decided to skip processing of this TAB - probably to let it - // do its default job. + // ok, so this is getting absolutely ridiculous but I don't see + // any other way to fix this bug: when a multiline text control is + // inside a wxFrame, we need to generate the navigation event as + // otherwise nothing happens at all, but when the same control is + // created inside a dialog, IsDialogMessage() *does* switch focus + // all by itself and so if we do it here as well, it is advanced + // twice and goes to the next control... to prevent this from + // happening we're doing this ugly check, the logic being that if + // we don't have focus then it had been already changed to the next + // control + // + // the right thing to do would, of course, be to understand what + // the hell is IsDialogMessage() doing but this is beyond my feeble + // forces at the moment unfortunately + if ( !(m_windowStyle & wxTE_PROCESS_TAB)) { - wxNavigationKeyEvent eventNav; - eventNav.SetDirection(!event.ShiftDown()); - eventNav.SetWindowChange(event.ControlDown()); - eventNav.SetEventObject(this); - - if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) ) - return; + if ( FindFocus() == this ) + { + int flags = 0; + if (!event.ShiftDown()) + flags |= wxNavigationKeyEvent::IsForward ; + if (event.ControlDown()) + flags |= wxNavigationKeyEvent::WinChange ; + if (Navigate(flags)) + return; + } + } + else + { + // Insert tab since calling the default Windows handler + // doesn't seem to do it + WriteText(wxT("\t")); + return; } break; } @@ -1484,45 +1833,57 @@ void wxTextCtrl::OnChar(wxKeyEvent& event) event.Skip(); } -long wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +WXLRESULT wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) { - long lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam); + WXLRESULT lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam); - if ( nMsg == WM_GETDLGCODE ) + switch ( nMsg ) { - // we always want the chars and the arrows: the arrows for navigation - // and the chars because we want Ctrl-C to work even in a read only - // control - long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS; + case WM_GETDLGCODE: + { + // we always want the chars and the arrows: the arrows for + // navigation and the chars because we want Ctrl-C to work even + // in a read only control + long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS; - if ( IsEditable() ) - { - // we may have several different cases: - // 1. normal case: both TAB and ENTER are used for dlg navigation - // 2. ctrl which wants TAB for itself: ENTER is used to pass to the - // next control in the dialog - // 3. ctrl which wants ENTER for itself: TAB is used for dialog - // navigation - // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go - // to the next control - - // the multiline edit control should always get for itself - if ( HasFlag(wxTE_PROCESS_ENTER) || HasFlag(wxTE_MULTILINE) ) - lDlgCode |= DLGC_WANTMESSAGE; - - if ( HasFlag(wxTE_PROCESS_TAB) ) - lDlgCode |= DLGC_WANTTAB; - - lRc |= lDlgCode; - } - else // !editable - { - // NB: use "=", not "|=" as the base class version returns the - // same flags is this state as usual (i.e. including - // DLGC_WANTMESSAGE). This is strange (how does it work in the - // native Win32 apps?) but for now live with it. - lRc = lDlgCode; - } + if ( IsEditable() ) + { + // we may have several different cases: + // 1. normal: both TAB and ENTER are used for navigation + // 2. ctrl wants TAB for itself: ENTER is used to pass to + // the next control in the dialog + // 3. ctrl wants ENTER for itself: TAB is used for dialog + // navigation + // 4. ctrl wants both TAB and ENTER: Ctrl-ENTER is used to + // go to the next control (we need some way to do it) + + // multiline controls should always get ENTER for themselves + if ( HasFlag(wxTE_PROCESS_ENTER) || HasFlag(wxTE_MULTILINE) ) + lDlgCode |= DLGC_WANTMESSAGE; + + if ( HasFlag(wxTE_PROCESS_TAB) ) + lDlgCode |= DLGC_WANTTAB; + + lRc |= lDlgCode; + } + else // !editable + { + // NB: use "=", not "|=" as the base class version returns + // the same flags is this state as usual (i.e. + // including DLGC_WANTMESSAGE). This is strange (how + // does it work in the native Win32 apps?) but for now + // live with it. + lRc = lDlgCode; + } + } + break; + + case WM_CUT: + case WM_COPY: + case WM_PASTE: + if ( HandleClipboardEvent(nMsg) ) + lRc = 0; + break; } return lRc; @@ -1534,20 +1895,33 @@ long wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) bool wxTextCtrl::SendUpdateEvent() { - // is event reporting suspended? - if ( m_suppressNextUpdate ) + switch ( m_updatesCount ) { - // do process the next one - m_suppressNextUpdate = FALSE; + case 0: + // remember that we've got an update + m_updatesCount++; + break; - return FALSE; - } + case 1: + // we had already sent one event since the last control modification + return false; + + default: + wxFAIL_MSG( _T("unexpected wxTextCtrl::m_updatesCount value") ); + // fall through + + case -1: + // we hadn't updated the control ourselves, this event comes from + // the user, don't need to ignore it nor update the count + break; - wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId()); - InitCommandEvent(event); - event.SetString(GetValue()); + case -2: + // the control was updated programmatically and we do NOT want to + // send events + return false; + } - return ProcessCommand(event); + return SendTextUpdatedEvent(); } bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) @@ -1582,129 +1956,58 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) // the other edit notification messages are not processed default: - return FALSE; + return false; } // processed - return TRUE; -} - -WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSED(nCtlColor), -#if wxUSE_CTL3D - WXUINT message, - WXWPARAM wParam, - WXLPARAM lParam -#else - WXUINT WXUNUSED(message), - WXWPARAM WXUNUSED(wParam), - WXLPARAM WXUNUSED(lParam) -#endif - ) -{ -#if wxUSE_CTL3D - if ( m_useCtl3D ) - { - HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam); - return (WXHBRUSH) hbrush; - } -#endif // wxUSE_CTL3D - - HDC hdc = (HDC)pDC; - wxColour colBack = GetBackgroundColour(); - - if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0) - colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); - - ::SetBkColor(hdc, wxColourToRGB(colBack)); - ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour())); - - wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID); - - return (WXHBRUSH)brush->GetResourceHandle(); + return true; } -// In WIN16, need to override normal erasing because -// Ctl3D doesn't use the wxWindows background colour. -#ifdef __WIN16__ -void wxTextCtrl::OnEraseBackground(wxEraseEvent& event) +WXHBRUSH wxTextCtrl::MSWControlColor(WXHDC hDC, WXHWND hWnd) { - wxColour col(m_backgroundColour); - -#if wxUSE_CTL3D - if (m_useCtl3D) - col = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); -#endif - - RECT rect; - ::GetClientRect(GetHwnd(), &rect); - - COLORREF ref = wxColourToRGB(col); - HBRUSH hBrush = ::CreateSolidBrush(ref); - if ( !hBrush ) - wxLogLastError(wxT("CreateSolidBrush")); - - HDC hdc = (HDC)event.GetDC()->GetHDC(); - - int mode = ::SetMapMode(hdc, MM_TEXT); - - ::FillRect(hdc, &rect, hBrush); - ::DeleteObject(hBrush); - ::SetMapMode(hdc, mode); + if ( !IsEnabled() && !HasFlag(wxTE_MULTILINE) ) + return MSWControlColorDisabled(hDC); + return wxTextCtrlBase::MSWControlColor(hDC, hWnd); } -#endif // Win16 -bool wxTextCtrl::AdjustSpaceLimit() +bool wxTextCtrl::HasSpaceLimit(unsigned int *len) const { -#ifndef __WIN16__ - unsigned int limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0); - // HACK: we try to automatically extend the limit for the amount of text // to allow (interactively) entering more than 64Kb of text under // Win9x but we shouldn't reset the text limit which was previously // set explicitly with SetMaxLength() // - // we could solve this by storing the limit we set in wxTextCtrl but - // to save space we prefer to simply test here the actual limit - // value: we consider that SetMaxLength() can only be called for - // values < 32Kb - if ( limit < 0x8000 ) - { - // we've got more text than limit set by SetMaxLength() - return FALSE; - } + // Unfortunately there is no EM_GETLIMITTEXTSETBYUSER and so we don't + // know the limit we set (if any). We could solve this by storing the + // limit we set in wxTextCtrl but to save space we prefer to simply + // test here the actual limit value: we consider that SetMaxLength() + // can only be called for small values while EN_MAXTEXT is only sent + // for large values (in practice the default limit seems to be 30000 + // but make it smaller just to be on the safe side) + *len = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0); + return *len < 10001; + +} + +bool wxTextCtrl::AdjustSpaceLimit() +{ + unsigned int limit; + if ( HasSpaceLimit(&limit) ) + return false; unsigned int len = ::GetWindowTextLength(GetHwnd()); if ( len >= limit ) { - limit = len + 0x8000; // 32Kb - -#if wxUSE_RICHEDIT - if ( IsRich() ) - { - // as a nice side effect, this also allows passing limit > 64Kb - ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit); - } - else -#endif // wxUSE_RICHEDIT - { - if ( limit > 0xffff ) - { - // this will set it to a platform-dependent maximum (much more - // than 64Kb under NT) - limit = 0; - } - - ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0); - } + // increment in 32Kb chunks + SetMaxLength(len + 0x8000); } -#endif // !Win16 // we changed the limit - return TRUE; + return true; } -bool wxTextCtrl::AcceptsFocus() const +bool wxTextCtrl::AcceptsFocusFromKeyboard() const { // we don't want focus if we can't be edited unless we're a multiline // control because then it might be still nice to get focus from keyboard @@ -1715,17 +2018,21 @@ bool wxTextCtrl::AcceptsFocus() const wxSize wxTextCtrl::DoGetBestSize() const { int cx, cy; - wxGetCharSize(GetHWND(), &cx, &cy, &GetFont()); + wxGetCharSize(GetHWND(), &cx, &cy, GetFont()); int wText = DEFAULT_ITEM_WIDTH; - int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy); + int hText = cy; if ( m_windowStyle & wxTE_MULTILINE ) { - hText *= wxMax(GetNumberOfLines(), 5); + hText *= wxMax(wxMin(GetNumberOfLines(), 10), 2); } //else: for single line control everything is ok + // we have to add the adjustments for the control height only once, not + // once per line, so do it after multiplication above + hText += EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) - cy; + return wxSize(wText, hText); } @@ -1808,7 +2115,7 @@ void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event) event.Enable(GetLastPosition() > 0); } -void wxTextCtrl::OnRightClick(wxMouseEvent& event) +void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event) { #if wxUSE_RICHEDIT if (IsRich()) @@ -1826,7 +2133,7 @@ void wxTextCtrl::OnRightClick(wxMouseEvent& event) m_privateContextMenu->AppendSeparator(); m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All")); } - PopupMenu(m_privateContextMenu, event.GetPosition()); + PopupMenu(m_privateContextMenu); return; } else @@ -1843,6 +2150,23 @@ void wxTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event)) } } +// ---------------------------------------------------------------------------- +// Default colors for MSW text control +// +// Set default background color to the native white instead of +// the default wxSYS_COLOUR_BTNFACE (is triggered with wxNullColour). +// ---------------------------------------------------------------------------- + +wxVisualAttributes wxTextCtrl::GetDefaultAttributes() const +{ + wxVisualAttributes attrs; + attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); + attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); + attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); //white + + return attrs; +} + // the rest of the file only deals with the rich edit controls #if wxUSE_RICHEDIT @@ -1880,8 +2204,8 @@ bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) } } - // return TRUE to process the event (and FALSE to ignore it) - return TRUE; + // return true to process the event (and false to ignore it) + return true; case EN_LINK: { @@ -1892,9 +2216,12 @@ bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) case WM_SETCURSOR: // ok, so it is hardcoded - do we really nee to // customize it? - ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND))); - *result = TRUE; - break; + { + wxCursor cur(wxCURSOR_HAND); + ::SetCursor(GetHcursorOf(cur)); + *result = TRUE; + break; + } case WM_MOUSEMOVE: case WM_LBUTTONDOWN: @@ -1936,13 +2263,29 @@ bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) break; } } - return TRUE; + return true; } // not processed, leave it to the base class return wxTextCtrlBase::MSWOnNotify(idCtrl, lParam, result); } +#if wxUSE_DRAG_AND_DROP + +void wxTextCtrl::SetDropTarget(wxDropTarget *dropTarget) +{ + if ( m_dropTarget == wxRICHTEXT_DEFAULT_DROPTARGET ) + { + // get rid of the built-in drop target + ::RevokeDragDrop(GetHwnd()); + m_dropTarget = NULL; + } + + wxTextCtrlBase::SetDropTarget(dropTarget); +} + +#endif // wxUSE_DRAG_AND_DROP + // ---------------------------------------------------------------------------- // colour setting for the rich edit controls // ---------------------------------------------------------------------------- @@ -1952,7 +2295,7 @@ bool wxTextCtrl::SetBackgroundColour(const wxColour& colour) if ( !wxTextCtrlBase::SetBackgroundColour(colour) ) { // colour didn't really change - return FALSE; + return false; } if ( IsRich() ) @@ -1962,7 +2305,7 @@ bool wxTextCtrl::SetBackgroundColour(const wxColour& colour) ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR, 0, wxColourToRGB(colour)); } - return TRUE; + return true; } bool wxTextCtrl::SetForegroundColour(const wxColour& colour) @@ -1970,7 +2313,7 @@ bool wxTextCtrl::SetForegroundColour(const wxColour& colour) if ( !wxTextCtrlBase::SetForegroundColour(colour) ) { // colour didn't really change - return FALSE; + return false; } if ( IsRich() ) @@ -1984,21 +2327,19 @@ bool wxTextCtrl::SetForegroundColour(const wxColour& colour) ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- // styling support for rich edit controls // ---------------------------------------------------------------------------- -#if wxUSE_RICHEDIT - bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) { if ( !IsRich() ) { // can't do it with normal text control - return FALSE; + return false; } // the richedit 1.0 doesn't handle setting background colour, so don't @@ -2007,8 +2348,8 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) !style.HasLeftIndent() && !style.HasRightIndent() && !style.HasAlignment() && !style.HasTabs() ) { - // nothing to do: return TRUE if there was really nothing to do and - // FALSE if we failed to set bg colour + // nothing to do: return true if there was really nothing to do and + // false if we failed to set bg colour return !style.HasBackgroundColour(); } @@ -2030,7 +2371,7 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) if ( changeSel ) { - DoSetSelection(start, end, FALSE /* don't scroll caret into view */); + DoSetSelection(start, end, SetSel_NoScroll); } // initialize CHARFORMAT struct @@ -2069,9 +2410,12 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) // the real height in twips and not the negative number which // wxFillLogFont() returns (this is correct in general and works with // the Windows font mapper, but not here) + + wxFont font(style.GetFont()); + LOGFONT lf; - wxFillLogFont(&lf, &style.GetFont()); - cf.yHeight = 20*style.GetFont().GetPointSize(); // 1 pt = 20 twips + wxFillLogFont(&lf, &font); + cf.yHeight = 20*font.GetPointSize(); // 1 pt = 20 twips cf.bCharSet = lf.lfCharSet; cf.bPitchAndFamily = lf.lfPitchAndFamily; wxStrncpy( cf.szFaceName, lf.lfFaceName, WXSIZEOF(cf.szFaceName) ); @@ -2094,7 +2438,7 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) cf.dwEffects |= CFE_UNDERLINE; } - // strikeout fonts are not supported by wxWindows + // strikeout fonts are not supported by wxWidgets } if ( style.HasTextColour() ) @@ -2152,12 +2496,11 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) if (style.HasLeftIndent()) { - pf.dwMask |= PFM_STARTINDENT; + pf.dwMask |= PFM_STARTINDENT | PFM_OFFSET; // Convert from 1/10 mm to TWIPS pf.dxStartIndent = (int) (((double) style.GetLeftIndent()) * mm2twips / 10.0) ; - - // TODO: do we need to specify dxOffset? + pf.dxOffset = (int) (((double) style.GetLeftSubIndent()) * mm2twips / 10.0) ; } if (style.HasRightIndent()) @@ -2174,7 +2517,7 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) const wxArrayInt& tabs = style.GetTabs(); - pf.cTabCount = wxMin(tabs.GetCount(), MAX_TAB_STOPS); + pf.cTabCount = (SHORT)wxMin(tabs.GetCount(), MAX_TAB_STOPS); size_t i; for (i = 0; i < (size_t) pf.cTabCount; i++) { @@ -2183,11 +2526,23 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) } } - if (pf.dwMask != 0) +#if wxUSE_RICHEDIT2 + if ( m_verRichEdit > 1 ) + { + if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft ) + { + // Use RTL paragraphs in RTL mode to get proper layout + pf.dwMask |= PFM_RTLPARA; + pf.wEffects |= PFE_RTLPARA; + } + } +#endif // wxUSE_RICHEDIT2 + + if ( pf.dwMask ) { // do format the selection bool ok = ::SendMessage(GetHwnd(), EM_SETPARAFORMAT, - 0, (LPARAM) &pf) != 0; + 0, (LPARAM) &pf) != 0; if ( !ok ) { wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed")); @@ -2197,7 +2552,7 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) if ( changeSel ) { // restore the original selection - DoSetSelection(startOld, endOld, FALSE); + DoSetSelection(startOld, endOld, SetSel_NoScroll); } return ok; @@ -2206,14 +2561,17 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style) { if ( !wxTextCtrlBase::SetDefaultStyle(style) ) - return FALSE; + return false; - // we have to do this or the style wouldn't apply for the text typed by the - // user - long posLast = GetLastPosition(); - SetStyle(posLast, posLast, m_defaultStyle); + if ( IsEditable() ) + { + // we have to do this or the style wouldn't apply for the text typed by + // the user + wxTextPos posLast = GetLastPosition(); + SetStyle(posLast, posLast, m_defaultStyle); + } - return TRUE; + return true; } bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) @@ -2221,7 +2579,7 @@ bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) if ( !IsRich() ) { // can't do it with normal text control - return FALSE; + return false; } // initialize CHARFORMAT struct @@ -2257,13 +2615,14 @@ bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) if ( changeSel ) { - DoSetSelection(position, position, FALSE /* don't scroll caret into view */); + DoSetSelection(position, position + 1, SetSel_NoScroll); } // get the selection formatting (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf) ; + LOGFONT lf; lf.lfHeight = cf.yHeight; lf.lfWidth = 0; @@ -2271,17 +2630,32 @@ bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) lf.lfClipPrecision = 0; lf.lfEscapement = 0; wxStrcpy(lf.lfFaceName, cf.szFaceName); + + //NOTE: we _MUST_ set each of these values to _something_ since we + //do not call wxZeroMemory on the LOGFONT lf if (cf.dwEffects & CFE_ITALIC) lf.lfItalic = TRUE; + else + lf.lfItalic = FALSE; + lf.lfOrientation = 0; lf.lfPitchAndFamily = cf.bPitchAndFamily; lf.lfQuality = 0; + if (cf.dwEffects & CFE_STRIKEOUT) lf.lfStrikeOut = TRUE; + else + lf.lfStrikeOut = FALSE; + if (cf.dwEffects & CFE_UNDERLINE) lf.lfUnderline = TRUE; + else + lf.lfUnderline = FALSE; + if (cf.dwEffects & CFE_BOLD) lf.lfWeight = FW_BOLD; + else + lf.lfWeight = FW_NORMAL; wxFont font = wxCreateFontFromLogFont(& lf); if (font.Ok()) @@ -2319,7 +2693,7 @@ bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) // do format the selection (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT, 0, (LPARAM) &pf) ; - style.SetLeftIndent( (int) ((double) pf.dxStartIndent * twips2mm * 10.0) ); + style.SetLeftIndent( (int) ((double) pf.dxStartIndent * twips2mm * 10.0), (int) ((double) pf.dxOffset * twips2mm * 10.0) ); style.SetRightIndent( (int) ((double) pf.dxRightIndent * twips2mm * 10.0) ); if (pf.wAlignment == PFA_CENTER) @@ -2335,82 +2709,100 @@ bool wxTextCtrl::GetStyle(long position, wxTextAttr& style) size_t i; for (i = 0; i < (size_t) pf.cTabCount; i++) { - tabStops[i] = (int) ((double) (pf.rgxTabs[i] & 0xFFFF) * twips2mm * 10.0) ; + tabStops.Add( (int) ((double) (pf.rgxTabs[i] & 0xFFFF) * twips2mm * 10.0) ); } if ( changeSel ) { // restore the original selection - DoSetSelection(startOld, endOld, FALSE); + DoSetSelection(startOld, endOld, SetSel_NoScroll); } - return TRUE; + return true; } -#endif - // ---------------------------------------------------------------------------- // wxRichEditModule // ---------------------------------------------------------------------------- +static const HINSTANCE INVALID_HINSTANCE = (HINSTANCE)-1; + bool wxRichEditModule::OnInit() { // don't do anything - we will load it when needed - return TRUE; + return true; } void wxRichEditModule::OnExit() { for ( size_t i = 0; i < WXSIZEOF(ms_hRichEdit); i++ ) { - if ( ms_hRichEdit[i] ) + if ( ms_hRichEdit[i] && ms_hRichEdit[i] != INVALID_HINSTANCE ) { ::FreeLibrary(ms_hRichEdit[i]); ms_hRichEdit[i] = NULL; } } +#if wxUSE_INKEDIT + if (ms_inkEditLib.IsLoaded()) + ms_inkEditLib.Unload(); +#endif } /* static */ -bool wxRichEditModule::Load(int version) +bool wxRichEditModule::Load(Version version) { - // we don't support loading richedit 3.0 as I don't know how to distinguish - // it from 2.0 anyhow - wxCHECK_MSG( version == 1 || version == 2, FALSE, - _T("incorrect richedit control version requested") ); - - // make it the index in the array - version--; - - if ( ms_hRichEdit[version] == (HINSTANCE)-1 ) + if ( ms_hRichEdit[version] == INVALID_HINSTANCE ) { // we had already tried to load it and failed - return FALSE; + return false; } if ( ms_hRichEdit[version] ) { // we've already got this one - return TRUE; + return true; } - wxString dllname = version ? _T("riched20") : _T("riched32"); - dllname += _T(".dll"); + static const wxChar *dllnames[] = + { + _T("riched32"), + _T("riched20"), + _T("msftedit"), + }; + + wxCOMPILE_TIME_ASSERT( WXSIZEOF(dllnames) == Version_Max, + RichEditDllNamesVersionsMismatch ); - ms_hRichEdit[version] = ::LoadLibrary(dllname); + ms_hRichEdit[version] = ::LoadLibrary(dllnames[version]); if ( !ms_hRichEdit[version] ) { - wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str()); + ms_hRichEdit[version] = INVALID_HINSTANCE; - ms_hRichEdit[version] = (HINSTANCE)-1; - - return FALSE; + return false; } - return TRUE; + return true; +} + +#if wxUSE_INKEDIT +// load the InkEdit library +bool wxRichEditModule::LoadInkEdit() +{ + static wxDynamicLibrary ms_inkEditLib; + static bool ms_inkEditLibLoadAttemped; + if (ms_inkEditLibLoadAttemped) + ms_inkEditLib.IsLoaded(); + + ms_inkEditLibLoadAttemped = true; + + wxLogNull logNull; + return ms_inkEditLib.Load(wxT("inked")); } +#endif // wxUSE_INKEDIT + #endif // wxUSE_RICHEDIT -#endif // wxUSE_TEXTCTRL +#endif // wxUSE_TEXTCTRL && !(__SMARTPHONE__ && __WXWINCE__)