X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a37d422a667124e4cb9c7413deda637d3b1926ec..83911a5a4d3be63141419b4401259093514794a3:/src/msw/textctrl.cpp?ds=inline diff --git a/src/msw/textctrl.cpp b/src/msw/textctrl.cpp index c6beb418d7..77ad90c6d3 100644 --- a/src/msw/textctrl.cpp +++ b/src/msw/textctrl.cpp @@ -38,6 +38,7 @@ #include "wx/intl.h" #include "wx/log.h" #include "wx/app.h" + #include "wx/menu.h" #endif #include "wx/module.h" @@ -56,7 +57,11 @@ #include #include -#if wxUSE_RICHEDIT && (!defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)) +#if wxUSE_RICHEDIT + +// 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 @@ -91,37 +96,51 @@ } ENLINK; #endif // ENLINK +#ifndef SF_UNICODE + #define SF_UNICODE 0x0010 +#endif + +// Watcom C++ doesn't define this +#ifndef SCF_ALL + #define SCF_ALL 0x0004 +#endif + +#endif // wxUSE_RICHEDIT + +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +#if wxUSE_RICHEDIT + +DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb); + +#endif // wxUSE_RICHEDIT + // ---------------------------------------------------------------------------- // private classes // ---------------------------------------------------------------------------- #if wxUSE_RICHEDIT -// this module initializes RichEdit DLL if needed +// this module initializes RichEdit DLL(s) if needed class wxRichEditModule : public wxModule { public: virtual bool OnInit(); virtual void OnExit(); - // get the version currently loaded, -1 if none - static int GetLoadedVersion() { return ms_verRichEdit; } - // load the richedit DLL of at least of required version static bool Load(int version = 1); private: - // the handle to richedit DLL and the version of the DLL loaded - static HINSTANCE ms_hRichEdit; - - // the DLL version loaded or -1 if none - static int ms_verRichEdit; + // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs + static HINSTANCE ms_hRichEdit[2]; DECLARE_DYNAMIC_CLASS(wxRichEditModule) }; -HINSTANCE wxRichEditModule::ms_hRichEdit = (HINSTANCE)NULL; -int wxRichEditModule::ms_verRichEdit = -1; +HINSTANCE wxRichEditModule::ms_hRichEdit[2] = { NULL, NULL }; IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule) @@ -137,17 +156,25 @@ BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) EVT_CHAR(wxTextCtrl::OnChar) EVT_DROP_FILES(wxTextCtrl::OnDropFiles) +#if wxUSE_RICHEDIT + EVT_RIGHT_UP(wxTextCtrl::OnRightClick) +#endif + EVT_MENU(wxID_CUT, wxTextCtrl::OnCut) EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy) EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste) EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo) EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo) + EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete) + EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll) EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut) EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy) EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste) EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo) 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 @@ -161,11 +188,23 @@ END_EVENT_TABLE() // creation // ---------------------------------------------------------------------------- -wxTextCtrl::wxTextCtrl() +void wxTextCtrl::Init() { #if wxUSE_RICHEDIT - m_isRich = FALSE; -#endif + m_verRichEdit = 0; +#endif // wxUSE_RICHEDIT + + m_privateContextMenu = NULL; + m_suppressNextUpdate = FALSE; +} + +wxTextCtrl::~wxTextCtrl() +{ + if (m_privateContextMenu) + { + delete m_privateContextMenu; + m_privateContextMenu = NULL; + } } bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, @@ -183,86 +222,69 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, if ( parent ) parent->AddChild(this); - // translate wxWin style flags to MSW ones, checking for consistency while - // doing it - long msStyle = ES_LEFT | WS_VISIBLE | WS_CHILD | WS_TABSTOP; + // translate wxWin style flags to MSW ones + WXDWORD msStyle = MSWGetCreateWindowFlags(); - if ( m_windowStyle & wxCLIP_SIBLINGS ) - msStyle |= WS_CLIPSIBLINGS; + // do create the control - either an EDIT or RICHEDIT + wxString windowClass = wxT("EDIT"); - if ( m_windowStyle & wxTE_MULTILINE ) +#if wxUSE_RICHEDIT + if ( m_windowStyle & wxTE_AUTO_URL ) { - wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER), - wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") ); - - msStyle |= ES_MULTILINE | ES_WANTRETURN; - if ((m_windowStyle & wxTE_NO_VSCROLL) == 0) - msStyle |= WS_VSCROLL; - m_windowStyle |= wxTE_PROCESS_ENTER; + // automatic URL detection only works in RichEdit 2.0+ + m_windowStyle |= wxTE_RICH2; } - else - msStyle |= ES_AUTOHSCROLL; - - if (m_windowStyle & wxHSCROLL) - msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL); - - if (m_windowStyle & wxTE_READONLY) - msStyle |= ES_READONLY; - - if (m_windowStyle & wxTE_PASSWORD) // hidden input - msStyle |= ES_PASSWORD; - if (m_windowStyle & wxTE_AUTO_SCROLL) - msStyle |= ES_AUTOHSCROLL; - - - // we always want the characters and the arrows - m_lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS; - - // we may have several different cases: - // 1. normal case: both TAB and ENTER are used for dialog 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 pass to - // the next control - if ( m_windowStyle & wxTE_PROCESS_ENTER ) - m_lDlgCode |= DLGC_WANTMESSAGE; - if ( m_windowStyle & wxTE_PROCESS_TAB ) - m_lDlgCode |= DLGC_WANTTAB; - - // do create the control - either an EDIT or RICHEDIT - wxString windowClass = wxT("EDIT"); + if ( m_windowStyle & wxTE_RICH2 ) + { + // using richedit 2.0 implies using wxTE_RICH + m_windowStyle |= wxTE_RICH; + } -#if wxUSE_RICHEDIT + // 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 + 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 + // + // 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) +#if wxUSE_UNICODE + const int verRichEdit = 2; +#else // !wxUSE_UNICODE + int 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 ) { - // first try to load the RichEdit DLL (will do nothing if already - // done) - if ( !wxRichEditModule::Load() ) + // try to load the RichEdit DLL (will do nothing if already done) + if ( !wxRichEditModule::Load(verRichEdit) ) { - wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll")); +#if !wxUSE_UNICODE + // try another version? + verRichEdit = 3 - verRichEdit; // 1 <-> 2 + + if ( !wxRichEditModule::Load(verRichEdit) ) +#endif // wxUSE_UNICODE + { + wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll")); - s_errorGiven = TRUE; + s_errorGiven = TRUE; + } } } - if ( s_errorGiven ) - { - m_isRich = FALSE; - } - else + // have we managed to load any richedit version? + if ( !s_errorGiven ) { - msStyle |= ES_AUTOVSCROLL; - m_isRich = TRUE; - - int ver = wxRichEditModule::GetLoadedVersion(); - if ( ver == 1 ) + m_verRichEdit = verRichEdit; + if ( m_verRichEdit == 1 ) { windowClass = wxT("RICHEDIT"); } @@ -270,7 +292,7 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, { #ifndef RICHEDIT_CLASS wxString RICHEDIT_CLASS; - RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), ver); + RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), m_verRichEdit); #if wxUSE_UNICODE RICHEDIT_CLASS += _T('W'); #else // ANSI @@ -282,48 +304,38 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, } } } - else - m_isRich = FALSE; #endif // wxUSE_RICHEDIT - bool want3D; - WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D); - - // Even with extended styles, need to combine with WS_BORDER for them to - // look right. - if ( want3D || wxStyleHasBorder(m_windowStyle) ) - msStyle |= WS_BORDER; - - // NB: don't use pos and size as CreateWindowEx arguments because they - // might be -1 in which case we should use the default values (and - // SetSize called below takes care of it) - m_hWnd = (WXHWND)::CreateWindowEx(exStyle, - windowClass.c_str(), - NULL, - msStyle, - 0, 0, 0, 0, - GetHwndOf(parent), - (HMENU)m_windowId, - wxGetInstance(), - NULL); - - wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create text ctrl") ); - -#if wxUSE_CTL3D - if ( want3D ) + // we need to turn '\n's into "\r\n"s for the multiline controls + wxString valueWin; + if ( m_windowStyle & wxTE_MULTILINE ) { - Ctl3dSubclassCtl(GetHwnd()); - m_useCtl3D = TRUE; + valueWin = wxTextFile::Translate(value, wxTextFileType_Dos); } -#endif + else // single line + { + valueWin = value; + } + + if ( !MSWCreateControl(windowClass, msStyle, pos, size, valueWin) ) + return FALSE; + + SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)); #if wxUSE_RICHEDIT - if (m_isRich) + if ( IsRich() ) { - // have to enable events manually - LPARAM mask = ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE; + // enable the events we're interested in: we want to get EN_CHANGE as + // for the normal controls + LPARAM mask = ENM_CHANGE; - if ( m_windowStyle & wxTE_AUTO_URL ) + if ( GetRichVersion() == 1 ) + { + // we also need EN_MSGFILTER for richedit 1.0 for the reasons + // explained in its handler + mask |= ENM_MOUSEEVENTS; + } + else if ( m_windowStyle & wxTE_AUTO_URL ) { mask |= ENM_LINK; @@ -334,75 +346,138 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, } #endif // wxUSE_RICHEDIT - SubclassWin(GetHWND()); + return TRUE; +} + +// Make sure the window style (etc.) reflects the HWND style (roughly) +void wxTextCtrl::AdoptAttributesFromHWND() +{ + wxWindow::AdoptAttributesFromHWND(); + + HWND hWnd = GetHwnd(); + long style = ::GetWindowLong(hWnd, GWL_STYLE); - // set font, position, size and initial value - wxFont& fontParent = parent->GetFont(); - if ( fontParent.Ok() ) + // retrieve the style to see whether this is an edit or richedit ctrl +#if wxUSE_RICHEDIT + wxString classname = wxGetWindowClass(GetHWND()); + + if ( classname.IsSameAs(_T("EDIT"), FALSE /* no case */) ) { - SetFont(fontParent); + m_verRichEdit = 0; } - else + else // rich edit? { - SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT)); + wxChar c; + if ( wxSscanf(classname, _T("RichEdit%d0%c"), &m_verRichEdit, &c) != 2 ) + { + wxLogDebug(_T("Unknown edit control '%s'."), classname.c_str()); + + m_verRichEdit = 0; + } } +#endif // wxUSE_RICHEDIT - // Causes a crash for Symantec C++ and WIN32 for some reason -#if !(defined(__SC__) && defined(__WIN32__)) - if ( !value.IsEmpty() ) + if (style & ES_MULTILINE) + m_windowStyle |= wxTE_MULTILINE; + if (style & ES_PASSWORD) + m_windowStyle |= wxTE_PASSWORD; + if (style & ES_READONLY) + m_windowStyle |= wxTE_READONLY; + if (style & ES_WANTRETURN) + m_windowStyle |= wxTE_PROCESS_ENTER; + if (style & ES_CENTER) + m_windowStyle |= wxTE_CENTRE; + if (style & ES_RIGHT) + m_windowStyle |= wxTE_RIGHT; +} + +WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const +{ + // default border for the text controls is the sunken one + if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT ) { - SetValue(value); + style |= wxBORDER_SUNKEN; } -#endif - // set colours - SetupColours(); + long msStyle = wxControl::MSWGetStyle(style, exstyle); - SetSize(pos.x, pos.y, size.x, size.y); + // styles which we alaways 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)") ); - return TRUE; -} + msStyle |= ES_MULTILINE | ES_WANTRETURN; + if ( !(style & wxTE_NO_VSCROLL) ) + { + // always adjust the vertical scrollbar automatically if we have it + msStyle |= WS_VSCROLL | ES_AUTOVSCROLL; -// Make sure the window style (etc.) reflects the HWND style (roughly) -void wxTextCtrl::AdoptAttributesFromHWND() -{ - wxWindow::AdoptAttributesFromHWND(); + // we have to use this style for the rich edit controls because + // without it the vertical scrollbar never appears at all in + // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it) + if ( style & wxTE_RICH2 ) + { + msStyle |= ES_DISABLENOSCROLL; + } + } - HWND hWnd = GetHwnd(); - long style = GetWindowLong(hWnd, GWL_STYLE); + style |= wxTE_PROCESS_ENTER; + } + else // !multiline + { + // there is really no reason to not have this style for single line + // text controls + msStyle |= ES_AUTOHSCROLL; + } - // retrieve the style to see whether this is an edit or richedit ctrl -#if wxUSE_RICHEDIT - wxChar buf[256]; + // styles which we add depending on the specified wxWindows styles + if ( style & wxHSCROLL ) + { + // automatically scroll the control horizontally as necessary + msStyle |= WS_HSCROLL;// | ES_AUTOHSCROLL; + } - GetClassName(hWnd, buf, WXSIZEOF(buf)); + if ( style & wxTE_READONLY ) + msStyle |= ES_READONLY; - if ( wxStricmp(buf, wxT("EDIT")) == 0 ) - m_isRich = FALSE; - else - m_isRich = TRUE; -#endif // wxUSE_RICHEDIT + if ( style & wxTE_PASSWORD ) + msStyle |= ES_PASSWORD; + + if ( style & wxTE_NOHIDESEL ) + msStyle |= ES_NOHIDESEL; + + // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0 + if ( style & wxTE_CENTRE ) + msStyle |= ES_CENTER; + else if ( style & wxTE_RIGHT ) + msStyle |= ES_RIGHT; + else + msStyle |= ES_LEFT; // ES_LEFT if 0 as well but for consistency... - if (style & ES_MULTILINE) - m_windowStyle |= wxTE_MULTILINE; - if (style & ES_PASSWORD) - m_windowStyle |= wxTE_PASSWORD; - if (style & ES_READONLY) - m_windowStyle |= wxTE_READONLY; - if (style & ES_WANTRETURN) - m_windowStyle |= wxTE_PROCESS_ENTER; + return msStyle; } -void wxTextCtrl::SetupColours() +void wxTextCtrl::SetWindowStyleFlag(long style) { - wxColour bkgndColour; -// if (IsEditable() || (m_windowStyle & wxTE_MULTILINE)) - bkgndColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW); -// else -// bkgndColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE); + if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT ) + style |= wxBORDER_SUNKEN; - SetBackgroundColour(bkgndColour); - SetForegroundColour(GetParent()->GetForegroundColour()); +#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 + // using richedit-specific EM_SETOPTIONS + if ( IsRich() && + ((style & wxTE_NOHIDESEL) != (GetWindowStyle() & wxTE_NOHIDESEL)) ) + { + bool set = (style & wxTE_NOHIDESEL) != 0; + + ::SendMessage(GetHwnd(), EM_SETOPTIONS, set ? ECOOP_OR : ECOOP_AND, + set ? ECO_NOHIDESEL : ~ECO_NOHIDESEL); + } +#endif // wxUSE_RICHEDIT + + wxControl::SetWindowStyleFlag(style); } // ---------------------------------------------------------------------------- @@ -411,49 +486,77 @@ void wxTextCtrl::SetupColours() wxString wxTextCtrl::GetValue() const { - // we can't use wxGetWindowText() (i.e. WM_GETTEXT internally) for - // retrieving more than 64Kb under Win9x -#if wxUSE_RICHEDIT - if ( m_isRich ) + // range 0..-1 is special for GetRange() and means to retrieve all text + return GetRange(0, -1); +} + +wxString wxTextCtrl::GetRange(long from, long to) const +{ + wxString str; + + if ( from >= to && to != -1 ) { - wxString str; + // nothing to retrieve + return str; + } +#if wxUSE_RICHEDIT + if ( IsRich() ) + { int len = GetWindowTextLength(GetHwnd()); - if ( len ) + if ( len > from ) { // alloc one extra WORD as needed by the control wxChar *p = str.GetWriteBuf(++len); TEXTRANGE textRange; - textRange.chrg.cpMin = 0; - textRange.chrg.cpMax = -1; + textRange.chrg.cpMin = from; + textRange.chrg.cpMax = to == -1 ? len : to; textRange.lpstrText = p; (void)SendMessage(GetHwnd(), EM_GETTEXTRANGE, 0, (LPARAM)&textRange); - // believe it or not, but EM_GETTEXTRANGE uses just CR ('\r') for - // the newlines which is neither Unix nor Windows style (Win95 with - // riched20.dll shows this behaviour) - convert it to something - // reasonable - for ( ; *p; p++ ) + if ( m_verRichEdit > 1 ) { - if ( *p == _T('\r') ) - *p = _T('\n'); + // RichEdit 2.0 uses just CR ('\r') for the newlines which is + // neither Unix nor Windows style - convert it to something + // reasonable + for ( ; *p; p++ ) + { + if ( *p == _T('\r') ) + *p = _T('\n'); + } } str.UngetWriteBuf(); + + if ( m_verRichEdit == 1 ) + { + // convert to the canonical form - see comment below + str = wxTextFile::Translate(str, wxTextFileType_Unix); + } } //else: no text at all, leave the string empty - - return str; } + else #endif // wxUSE_RICHEDIT + { + // retrieve all text + str = wxGetWindowText(GetHWND()); - // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the - // same one as above for consitency - wxString str = wxGetWindowText(GetHWND()); + // need only a range? + if ( from < to ) + { + str = str.Mid(from, to - from); + } + + // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the + // canonical one (same one as above) for consistency with the other kinds + // of controls and, more importantly, with the other ports + str = wxTextFile::Translate(str, wxTextFileType_Unix); + } - return wxTextFile::Translate(str, wxTextFileType_Unix); + return str; } void wxTextCtrl::SetValue(const wxString& value) @@ -464,38 +567,206 @@ void wxTextCtrl::SetValue(const wxString& value) // edit controls mostly) if ( (value.length() > 0x400) || (value != GetValue()) ) { - wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos); + DoWriteText(value, FALSE /* not selection only */); - SetWindowText(GetHwnd(), valueDos.c_str()); + // mark the control as being not dirty - we changed its text, not the + // user + DiscardEdits(); - // for compatibility with the GTK and because it is more logical, we - // move the cursor to the end of the text after SetValue() + // for compatibility, don't move the cursor when doing SetValue() + SetInsertionPoint(0); + } +} - // GRG, Jun/2000: Changed this back after a lot of discussion - // in the lists. wxWindows 2.2 will have a set of flags to - // customize this behaviour. - //SetInsertionPointEnd(); +#if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU) - AdjustSpaceLimit(); +DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb) +{ + *pcb = 0; + + wchar_t *wbuf = (wchar_t *)buf; + const wchar_t *wpc = *(const wchar_t **)dwCookie; + while ( cb && *wpc ) + { + *wbuf++ = *wpc++; + + cb -= sizeof(wchar_t); + (*pcb) += sizeof(wchar_t); + } + + *(const wchar_t **)dwCookie = wpc; + + return 0; +} + +extern long wxEncodingToCodepage(wxFontEncoding encoding); // from utils.cpp + +#if wxUSE_UNICODE_MSLU +bool wxTextCtrl::StreamIn(const wxString& value, + wxFontEncoding WXUNUSED(encoding), + bool selectionOnly) +{ + const wchar_t *wpc = value.c_str(); +#else // !wxUSE_UNICODE_MSLU +bool wxTextCtrl::StreamIn(const wxString& value, + wxFontEncoding encoding, + bool selectionOnly) +{ + // 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 + + // first get the Windows code page for this encoding + long codepage = wxEncodingToCodepage(encoding); + if ( codepage == -1 ) + { + // unknown encoding + return FALSE; + } + + // next translate to Unicode using this code page + int len = ::MultiByteToWideChar(codepage, 0, value, -1, NULL, 0); + +#if wxUSE_WCHAR_T + wxWCharBuffer wchBuf(len); +#else + wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t)); +#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; +#endif // wxUSE_UNICODE_MSLU + + 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; + } + + if ( !::SendMessage(GetHwnd(), EM_STREAMIN, + SF_TEXT | + SF_UNICODE | + (selectionOnly ? SFF_SELECTION : 0), + (LPARAM)&eds) || eds.dwError ) + { + wxLogLastError(_T("EM_STREAMIN")); } + +#if !wxUSE_WCHAR_T + free(wchBuf); +#endif // !wxUSE_WCHAR_T + + return TRUE; } +#endif // wxUSE_RICHEDIT + void wxTextCtrl::WriteText(const wxString& value) { - wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos); + DoWriteText(value); +} + +void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly) +{ + wxString valueDos; + if ( m_windowStyle & wxTE_MULTILINE ) + valueDos = wxTextFile::Translate(value, wxTextFileType_Dos); + else + valueDos = value; #if wxUSE_RICHEDIT - // ensure that the new text will be in the default style - if ( IsRich() && - (m_defaultStyle.HasFont() || m_defaultStyle.HasTextColour()) ) + // there are several complications with the rich edit controls here + bool done = FALSE; + if ( IsRich() ) { - long start, end; - GetSelection(&start, &end); - SetStyle(start, end, m_defaultStyle ); + // first, ensure that the new text will be in the default style + if ( !m_defaultStyle.IsDefault() ) + { + long start, end; + GetSelection(&start, &end); + SetStyle(start, end, m_defaultStyle); + } + +#if wxUSE_UNICODE_MSLU + // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x, + // but EM_STREAMIN works + if ( wxUsingUnicowsDll() && GetRichVersion() > 1 ) + { + done = StreamIn(valueDos, wxFONTENCODING_SYSTEM, selectionOnly); + } +#endif // wxUSE_UNICODE_MSLU + +#if !wxUSE_UNICODE + // next check if the text we're inserting must be shown in a non + // default charset -- this only works for RichEdit > 1.0 + if ( GetRichVersion() > 1 ) + { + wxFont font = m_defaultStyle.GetFont(); + if ( !font.Ok() ) + font = GetFont(); + + if ( font.Ok() ) + { + wxFontEncoding encoding = font.GetEncoding(); + if ( encoding != wxFONTENCODING_SYSTEM ) + { + done = StreamIn(valueDos, encoding, selectionOnly); + } + } + } +#endif // !wxUSE_UNICODE } + + if ( !done ) +#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; + } - SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str()); + ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL : WM_SETTEXT, + 0, (LPARAM)valueDos.c_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 + ) + { + // Windows already sends an update event for single-line + // controls. + if ( m_windowStyle & wxTE_MULTILINE ) + SendUpdateEvent(); + } + } AdjustSpaceLimit(); } @@ -503,14 +774,57 @@ void wxTextCtrl::WriteText(const wxString& value) void wxTextCtrl::AppendText(const wxString& text) { SetInsertionPointEnd(); + WriteText(text); + +#if wxUSE_RICHEDIT + if ( 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 + ::SendMessage(GetHwnd(), EM_LINESCROLL, 0, GetNumberOfLines()); + } +#endif // wxUSE_RICHEDIT } void wxTextCtrl::Clear() { - SetWindowText(GetHwnd(), wxT("")); + ::SetWindowText(GetHwnd(), wxT("")); + +#if wxUSE_RICHEDIT + if ( !IsRich() ) +#endif // wxUSE_RICHEDIT + { + // 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(); + } +} + +#ifdef __WIN32__ + +bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent& event) +{ + SetFocus(); + + size_t lenOld = GetValue().length(); + + wxUint32 code = event.GetRawKeyCode(); + ::keybd_event(code, 0, 0 /* key press */, 0); + ::keybd_event(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 + return GetValue().length() != lenOld; } +#endif // __WIN32__ + // ---------------------------------------------------------------------------- // Clipboard operations // ---------------------------------------------------------------------------- @@ -519,8 +833,7 @@ void wxTextCtrl::Copy() { if (CanCopy()) { - HWND hWnd = GetHwnd(); - SendMessage(hWnd, WM_COPY, 0, 0L); + ::SendMessage(GetHwnd(), WM_COPY, 0, 0L); } } @@ -528,8 +841,7 @@ void wxTextCtrl::Cut() { if (CanCut()) { - HWND hWnd = GetHwnd(); - SendMessage(hWnd, WM_CUT, 0, 0L); + ::SendMessage(GetHwnd(), WM_CUT, 0, 0L); } } @@ -537,46 +849,48 @@ void wxTextCtrl::Paste() { if (CanPaste()) { - HWND hWnd = GetHwnd(); - SendMessage(hWnd, WM_PASTE, 0, 0L); + ::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 - long from, to; - GetSelection(& from, & to); - return (from != to) ; + return HasSelection(); } bool wxTextCtrl::CanCut() const { - // Can cut if there's a selection - long from, to; - GetSelection(& from, & to); - return (from != to) && (IsEditable()); + return CanCopy() && IsEditable(); } bool wxTextCtrl::CanPaste() const { + if ( !IsEditable() ) + return FALSE; + #if wxUSE_RICHEDIT - if (m_isRich) + if ( IsRich() ) { - int dataFormat = 0; // 0 == any format - return (::SendMessage( GetHwnd(), EM_CANPASTE, (WPARAM) (UINT) dataFormat, 0) != 0); + UINT cf = 0; // 0 == any format + + return ::SendMessage(GetHwnd(), EM_CANPASTE, cf, 0) != 0; } -#endif - if (!IsEditable()) - return FALSE; +#endif // wxUSE_RICHEDIT // Standard edit control: check for straight text on clipboard - bool isTextAvailable = FALSE; - if ( ::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) ) - { - isTextAvailable = (::IsClipboardFormatAvailable(CF_TEXT) != 0); - ::CloseClipboard(); - } + if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) ) + return FALSE; + + bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0; + ::CloseClipboard(); return isTextAvailable; } @@ -593,41 +907,32 @@ void wxTextCtrl::SetEditable(bool editable) void wxTextCtrl::SetInsertionPoint(long pos) { - HWND hWnd = GetHwnd(); -#ifdef __WIN32__ + DoSetSelection(pos, pos); +} + +void wxTextCtrl::SetInsertionPointEnd() +{ + long pos; + #if wxUSE_RICHEDIT - if ( m_isRich) + if ( m_verRichEdit == 1 ) { - CHARRANGE range; - range.cpMin = pos; - range.cpMax = pos; - SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range); - SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); + // we don't have to waste time calling GetLastPosition() in this case + pos = -1; } - else + else // !RichEdit 1.0 #endif // wxUSE_RICHEDIT { - SendMessage(hWnd, EM_SETSEL, pos, pos); - SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); + pos = GetLastPosition(); } -#else // Win16 - SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(pos, pos)); -#endif // Win32/16 - - static const wxChar *nothing = _T(""); - SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing); -} -void wxTextCtrl::SetInsertionPointEnd() -{ - long pos = GetLastPosition(); SetInsertionPoint(pos); } long wxTextCtrl::GetInsertionPoint() const { #if wxUSE_RICHEDIT - if (m_isRich) + if ( IsRich() ) { CHARRANGE range; range.cpMin = 0; @@ -635,7 +940,7 @@ long wxTextCtrl::GetInsertionPoint() const SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range); return range.cpMin; } -#endif +#endif // wxUSE_RICHEDIT DWORD Pos = (DWORD)SendMessage(GetHwnd(), EM_GETSEL, 0, 0L); return Pos & 0xFFFF; @@ -643,19 +948,12 @@ long wxTextCtrl::GetInsertionPoint() const long wxTextCtrl::GetLastPosition() const { - HWND hWnd = GetHwnd(); - - // Will always return a number > 0 (according to docs) - int noLines = (int)SendMessage(hWnd, EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0L); + int numLines = GetNumberOfLines(); + long posStartLastLine = XYToPosition(0, numLines - 1); - // This gets the char index for the _beginning_ of the last line - int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)(noLines-1), (LPARAM)0L); + long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine); - // Get number of characters in the last line. We'll add this to the character - // index for the last line, 1st position. - int lineLength = (int)SendMessage(hWnd, EM_LINELENGTH, (WPARAM)charIndex, (LPARAM)0L); - - return (long)(charIndex + lineLength); + return posStartLastLine + lenLastLine; } // If the return values from and to are the same, there is no @@ -663,22 +961,19 @@ long wxTextCtrl::GetLastPosition() const void wxTextCtrl::GetSelection(long* from, long* to) const { #if wxUSE_RICHEDIT - if (m_isRich) + if ( IsRich() ) { CHARRANGE charRange; - ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) (CHARRANGE*) & charRange); + ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &charRange); *from = charRange.cpMin; *to = charRange.cpMax; } else -#endif // rich/!rich +#endif // !wxUSE_RICHEDIT { DWORD dwStart, dwEnd; - WPARAM wParam = (WPARAM) &dwStart; // receives starting position - LPARAM lParam = (LPARAM) &dwEnd; // receives ending position - - ::SendMessage(GetHwnd(), EM_GETSEL, wParam, lParam); + ::SendMessage(GetHwnd(), EM_GETSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd); *from = dwStart; *to = dwEnd; @@ -687,68 +982,121 @@ void wxTextCtrl::GetSelection(long* from, long* to) const 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); + return (style & ES_READONLY) == 0; } // ---------------------------------------------------------------------------- -// Editing +// selection // ---------------------------------------------------------------------------- -void wxTextCtrl::Replace(long from, long to, const wxString& value) +void wxTextCtrl::SetSelection(long from, long to) { - HWND hWnd = GetHwnd(); - long fromChar = from; - long toChar = 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; + } - // Set selection and remove it -#ifdef __WIN32__ - SendMessage(hWnd, EM_SETSEL, fromChar, toChar); - SendMessage(hWnd, EM_REPLACESEL, (WPARAM)TRUE, (LPARAM)value.c_str()); -#else - SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); - SendMessage(hWnd, EM_REPLACESEL, (WPARAM)0, (LPARAM)value.c_str()); -#endif + DoSetSelection(from, to); } -void wxTextCtrl::Remove(long from, long to) +void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret) { HWND hWnd = GetHwnd(); - long fromChar = from; - long toChar = to; - // Cut all selected text #ifdef __WIN32__ - SendMessage(hWnd, EM_SETSEL, fromChar, toChar); - SendMessage(hWnd, EM_REPLACESEL, (WPARAM)TRUE, (LPARAM)""); -#else - SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); - SendMessage(hWnd, EM_REPLACESEL, (WPARAM)0, (LPARAM)""); -#endif -} - -void wxTextCtrl::SetSelection(long from, long to) -{ - HWND hWnd = GetHwnd(); - long fromChar = from; - long toChar = to; +#if wxUSE_RICHEDIT + if ( IsRich() ) + { + CHARRANGE range; + range.cpMin = from; + range.cpMax = to; + SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range); + } + else +#endif // wxUSE_RICHEDIT + { + SendMessage(hWnd, EM_SETSEL, (WPARAM)from, (LPARAM)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)) + if ( scrollCaret ) { - fromChar = 0; - toChar = -1; +#if wxUSE_RICHEDIT + // richedit 3.0 (i.e. the version living in riched20.dll distributed + // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when + // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL + // option is set (but it does work ok in richedit 1.0 mode...) + // + // so to make it work we either need to give focus to it here which + // will probably create many problems (dummy focus events; window + // containing the text control being brought to foreground + // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may + // create other problems too -- and in fact it does because if we turn + // on/off this style while appending the text to the control, the + // vertical scrollbar never appears in it even if we append tons of + // text and to work around this the only solution I found was to use + // ES_DISABLENOSCROLL + // + // this is very ugly but I don't see any other way to make this work + if ( GetRichVersion() > 1 ) + { + if ( !HasFlag(wxTE_NOHIDESEL) ) + { + ::SendMessage(GetHwnd(), EM_SETOPTIONS, + ECOOP_OR, ECO_NOHIDESEL); + } + //else: everything is already ok + } +#endif // wxUSE_RICHEDIT + + SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); + +#if wxUSE_RICHEDIT + // restore ECO_NOHIDESEL if we changed it + if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL) ) + { + ::SendMessage(GetHwnd(), EM_SETOPTIONS, + ECOOP_AND, ~ECO_NOHIDESEL); + } +#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 +// ---------------------------------------------------------------------------- +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__ - SendMessage(hWnd, EM_SETSEL, (WPARAM)fromChar, (LPARAM)toChar); - SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0); + TRUE, #else - // WPARAM is 0: selection is scrolled into view - SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar)); + FALSE, #endif + (LPARAM)value.c_str()); +} + +void wxTextCtrl::Remove(long from, long to) +{ + Replace(from, to, _T("")); } bool wxTextCtrl::LoadFile(const wxString& file) @@ -766,7 +1114,7 @@ bool wxTextCtrl::LoadFile(const wxString& file) bool wxTextCtrl::IsModified() const { - return (SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0); + return SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0; } // Makes 'unmodified' @@ -782,11 +1130,10 @@ int wxTextCtrl::GetNumberOfLines() const long wxTextCtrl::XYToPosition(long x, long y) const { - HWND hWnd = GetHwnd(); - // This gets the char index for the _beginning_ of this line - int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)y, (LPARAM)0); - return (long)(x + charIndex); + long charIndex = SendMessage(GetHwnd(), EM_LINEINDEX, (WPARAM)y, (LPARAM)0); + + return charIndex + x; } bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const @@ -794,15 +1141,17 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const HWND hWnd = GetHwnd(); // This gets the line number containing the character - int lineNo; + long lineNo; #if wxUSE_RICHEDIT - if ( m_isRich ) + if ( IsRich() ) { - lineNo = (int)SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos); + lineNo = SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos); } else #endif // wxUSE_RICHEDIT - lineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0); + { + lineNo = SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0); + } if ( lineNo == -1 ) { @@ -811,7 +1160,7 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const } // This gets the char index for the _beginning_ of this line - int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0); + long charIndex = SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0); if ( charIndex == -1 ) { return FALSE; @@ -819,9 +1168,9 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const // The X position must therefore be the different between pos and charIndex if ( x ) - *x = (long)(pos - charIndex); + *x = pos - charIndex; if ( y ) - *y = (long)lineNo; + *y = lineNo; return TRUE; } @@ -851,11 +1200,16 @@ void wxTextCtrl::ShowPosition(long pos) (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll); } +long wxTextCtrl::GetLengthOfLineContainingPos(long pos) const +{ + return ::SendMessage(GetHwnd(), EM_LINELENGTH, (WPARAM)pos, 0); +} + int wxTextCtrl::GetLineLength(long lineNo) const { - long charIndex = XYToPosition(0, lineNo); - int len = (int)SendMessage(GetHwnd(), EM_LINELENGTH, charIndex, 0); - return len; + long pos = XYToPosition(0, lineNo); + + return GetLengthOfLineContainingPos(pos); } wxString wxTextCtrl::GetLineText(long lineNo) const @@ -878,6 +1232,11 @@ wxString wxTextCtrl::GetLineText(long lineNo) const return str; } +void wxTextCtrl::SetMaxLength(unsigned long len) +{ + ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0); +} + // ---------------------------------------------------------------------------- // Undo/redo // ---------------------------------------------------------------------------- @@ -901,12 +1260,12 @@ void wxTextCtrl::Redo() bool wxTextCtrl::CanUndo() const { - return (::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0); + return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; } bool wxTextCtrl::CanRedo() const { - return (::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0); + return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0; } // ---------------------------------------------------------------------------- @@ -941,7 +1300,7 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) // usual preprocessing for them if ( msg->message == WM_KEYDOWN ) { - WORD vkey = msg->wParam; + WORD vkey = (WORD) msg->wParam; if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN ) { if ( vkey == VK_BACK ) @@ -949,24 +1308,42 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) } else // no Alt { - if ( wxIsCtrlDown() ) - { - switch ( vkey ) - { - case 'C': - case 'V': - case 'X': - case VK_INSERT: - case VK_DELETE: - case VK_HOME: - case VK_END: - return FALSE; - } - } - else if ( wxIsShiftDown() ) + // we want to process some Ctrl-foo and Shift-bar but no key + // combinations without either Ctrl or Shift nor with both of them + // pressed + const int ctrl = wxIsCtrlDown(), + shift = wxIsShiftDown(); + switch ( ctrl + shift ) { - if ( vkey == VK_INSERT || vkey == VK_DELETE ) - return FALSE; + default: + wxFAIL_MSG( _T("how many modifiers have we got?") ); + // fall through + + case 0: + case 2: + break; + + case 1: + // either Ctrl or Shift pressed + if ( ctrl ) + { + switch ( vkey ) + { + case 'C': + case 'V': + case 'X': + case VK_INSERT: + case VK_DELETE: + case VK_HOME: + case VK_END: + return FALSE; + } + } + else // Shift is pressed + { + if ( vkey == VK_INSERT || vkey == VK_DELETE ) + return FALSE; + } } } } @@ -976,7 +1353,7 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg) void wxTextCtrl::OnChar(wxKeyEvent& event) { - switch ( event.KeyCode() ) + switch ( event.GetKeyCode() ) { case WXK_RETURN: if ( !(m_windowStyle & wxTE_MULTILINE) ) @@ -1012,41 +1389,103 @@ void wxTextCtrl::OnChar(wxKeyEvent& event) event.Skip(); } +long wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +{ + long lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam); + + if ( nMsg == 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; + } + } + + return lRc; +} + +// ---------------------------------------------------------------------------- +// text control event processing +// ---------------------------------------------------------------------------- + +bool wxTextCtrl::SendUpdateEvent() +{ + // is event reporting suspended? + if ( m_suppressNextUpdate ) + { + // do process the next one + m_suppressNextUpdate = FALSE; + + return FALSE; + } + + wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId()); + InitCommandEvent(event); + event.SetString(GetValue()); + + return ProcessCommand(event); +} + bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) { - switch (param) + switch ( param ) { case EN_SETFOCUS: case EN_KILLFOCUS: { wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS - : wxEVT_SET_FOCUS, - m_windowId); - event.SetEventObject( this ); + : wxEVT_SET_FOCUS, + m_windowId); + event.SetEventObject(this); GetEventHandler()->ProcessEvent(event); } break; case EN_CHANGE: + SendUpdateEvent(); + break; + + case EN_MAXTEXT: + // the text size limit has been hit -- try to increase it + if ( !AdjustSpaceLimit() ) { - wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId); + wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId); InitCommandEvent(event); event.SetString(GetValue()); ProcessCommand(event); } break; - case EN_MAXTEXT: - // the text size limit has been hit - increase it - AdjustSpaceLimit(); - break; - - // the other notification messages are not processed - case EN_UPDATE: - case EN_ERRSPACE: - case EN_HSCROLL: - case EN_VSCROLL: - return FALSE; + // the other edit notification messages are not processed default: return FALSE; } @@ -1084,7 +1523,7 @@ WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSE wxColour colBack = GetBackgroundColour(); if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0) - colBack = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE); + colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); ::SetBkColor(hdc, wxColourToRGB(colBack)); ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour())); @@ -1103,15 +1542,13 @@ void wxTextCtrl::OnEraseBackground(wxEraseEvent& event) #if wxUSE_CTL3D if (m_useCtl3D) - col = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW); + col = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); #endif RECT rect; ::GetClientRect(GetHwnd(), &rect); - COLORREF ref = PALETTERGB(col.Red(), - col.Green(), - col.Blue()); + COLORREF ref = wxColourToRGB(col); HBRUSH hBrush = ::CreateSolidBrush(ref); if ( !hBrush ) wxLogLastError(wxT("CreateSolidBrush")); @@ -1125,19 +1562,35 @@ void wxTextCtrl::OnEraseBackground(wxEraseEvent& event) ::SetMapMode(hdc, mode); } -#endif +#endif // Win16 -void wxTextCtrl::AdjustSpaceLimit() +bool wxTextCtrl::AdjustSpaceLimit() { #ifndef __WIN16__ - unsigned int len = ::GetWindowTextLength(GetHwnd()), - limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0); + 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; + } + + unsigned int len = ::GetWindowTextLength(GetHwnd()); if ( len >= limit ) { limit = len + 0x8000; // 32Kb #if wxUSE_RICHEDIT - if ( m_isRich ) + if ( IsRich() ) { // as a nice side effect, this also allows passing limit > 64Kb ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit); @@ -1156,12 +1609,17 @@ void wxTextCtrl::AdjustSpaceLimit() } } #endif // !Win16 + + // we changed the limit + return TRUE; } bool wxTextCtrl::AcceptsFocus() const { - // we don't want focus if we can't be edited - return IsEditable() && wxControl::AcceptsFocus(); + // 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 + // to be able to scroll it without mouse + return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus(); } wxSize wxTextCtrl::DoGetBestSize() const @@ -1210,6 +1668,19 @@ void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event)) Redo(); } +void wxTextCtrl::OnDelete(wxCommandEvent& event) +{ + long from, to; + GetSelection(& from, & to); + if (from != -1 && to != -1) + Remove(from, to); +} + +void wxTextCtrl::OnSelectAll(wxCommandEvent& event) +{ + SetSelection(-1, -1); +} + void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event) { event.Enable( CanCut() ); @@ -1235,6 +1706,44 @@ void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) event.Enable( CanRedo() ); } +void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event) +{ + long from, to; + GetSelection(& from, & to); + event.Enable(from != -1 && to != -1 && from != to && IsEditable()) ; +} + +void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event) +{ + event.Enable(GetLastPosition() > 0); +} + +void wxTextCtrl::OnRightClick(wxMouseEvent& event) +{ +#if wxUSE_RICHEDIT + if (IsRich()) + { + if (!m_privateContextMenu) + { + m_privateContextMenu = new wxMenu; + m_privateContextMenu->Append(wxID_UNDO, _("&Undo")); + m_privateContextMenu->Append(wxID_REDO, _("&Redo")); + m_privateContextMenu->AppendSeparator(); + m_privateContextMenu->Append(wxID_CUT, _("Cu&t")); + m_privateContextMenu->Append(wxID_COPY, _("&Copy")); + m_privateContextMenu->Append(wxID_PASTE, _("&Paste")); + m_privateContextMenu->Append(wxID_CLEAR, _("&Delete")); + m_privateContextMenu->AppendSeparator(); + m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All")); + } + PopupMenu(m_privateContextMenu, event.GetPosition()); + return; + } + else +#endif + event.Skip(); +} + // the rest of the file only deals with the rich edit controls #if wxUSE_RICHEDIT @@ -1245,74 +1754,100 @@ void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) { NMHDR *hdr = (NMHDR* )lParam; - if ( hdr->code == EN_LINK ) + switch ( hdr->code ) { - ENLINK *enlink = (ENLINK *)hdr; - - switch ( enlink->msg ) - { - case WM_SETCURSOR: - // ok, so it is hardcoded - do we really nee to customize it? - ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND))); - *result = TRUE; - break; - - case WM_MOUSEMOVE: - case WM_LBUTTONDOWN: - case WM_LBUTTONUP: - case WM_LBUTTONDBLCLK: - case WM_RBUTTONDOWN: - case WM_RBUTTONUP: - case WM_RBUTTONDBLCLK: - // send a mouse event + case EN_MSGFILTER: + { + const MSGFILTER *msgf = (MSGFILTER *)lParam; + UINT msg = msgf->msg; + + // this is a bit crazy but richedit 1.0 sends us all mouse + // events _except_ WM_LBUTTONUP (don't ask me why) so we have + // generate the wxWin events for this message manually + // + // NB: in fact, this is still not totally correct as it does + // send us WM_LBUTTONUP if the selection was cleared by the + // last click -- so currently we get 2 events in this case, + // but as I don't see any obvious way to check for this I + // leave this code in place because it's still better than + // not getting left up events at all + if ( msg == WM_LBUTTONUP ) { - static const wxEventType eventsMouse[] = - { - wxEVT_MOTION, - wxEVT_LEFT_DOWN, - wxEVT_LEFT_UP, - wxEVT_LEFT_DCLICK, - wxEVT_RIGHT_DOWN, - wxEVT_RIGHT_UP, - wxEVT_RIGHT_DCLICK, - }; - - // the event ids are consecutive - wxMouseEvent - evtMouse(eventsMouse[enlink->msg - WM_MOUSEMOVE]); - - InitMouseEvent(evtMouse, - GET_X_LPARAM(enlink->lParam), - GET_Y_LPARAM(enlink->lParam), - enlink->wParam); - - wxTextUrlEvent event(m_windowId, evtMouse, - enlink->chrg.cpMin, - enlink->chrg.cpMax); - - InitCommandEvent(event); - - *result = ProcessCommand(event); + WXUINT flags = msgf->wParam; + int x = GET_X_LPARAM(msgf->lParam), + y = GET_Y_LPARAM(msgf->lParam); + + HandleMouseEvent(msg, x, y, flags); } - break; - } + } - return TRUE; - } + // return TRUE to process the event (and FALSE to ignore it) + return TRUE; - // not processed - return FALSE; + case EN_LINK: + { + const ENLINK *enlink = (ENLINK *)hdr; + + switch ( enlink->msg ) + { + case WM_SETCURSOR: + // ok, so it is hardcoded - do we really nee to + // customize it? + ::SetCursor(GetHcursorOf(wxCursor(wxCURSOR_HAND))); + *result = TRUE; + break; + + case WM_MOUSEMOVE: + case WM_LBUTTONDOWN: + case WM_LBUTTONUP: + case WM_LBUTTONDBLCLK: + case WM_RBUTTONDOWN: + case WM_RBUTTONUP: + case WM_RBUTTONDBLCLK: + // send a mouse event + { + static const wxEventType eventsMouse[] = + { + wxEVT_MOTION, + wxEVT_LEFT_DOWN, + wxEVT_LEFT_UP, + wxEVT_LEFT_DCLICK, + wxEVT_RIGHT_DOWN, + wxEVT_RIGHT_UP, + wxEVT_RIGHT_DCLICK, + }; + + // the event ids are consecutive + wxMouseEvent + evtMouse(eventsMouse[enlink->msg - WM_MOUSEMOVE]); + + InitMouseEvent(evtMouse, + GET_X_LPARAM(enlink->lParam), + GET_Y_LPARAM(enlink->lParam), + enlink->wParam); + + wxTextUrlEvent event(m_windowId, evtMouse, + enlink->chrg.cpMin, + enlink->chrg.cpMax); + + InitCommandEvent(event); + + *result = ProcessCommand(event); + } + break; + } + } + return TRUE; + } + + // not processed, leave it to the base class + return wxTextCtrlBase::MSWOnNotify(idCtrl, lParam, result); } // ---------------------------------------------------------------------------- // colour setting for the rich edit controls // ---------------------------------------------------------------------------- -// Watcom C++ doesn't define this -#ifndef SCF_ALL -#define SCF_ALL 0x0004 -#endif - bool wxTextCtrl::SetBackgroundColour(const wxColour& colour) { if ( !wxTextCtrlBase::SetBackgroundColour(colour) ) @@ -1357,6 +1892,8 @@ bool wxTextCtrl::SetForegroundColour(const wxColour& colour) // styling support for rich edit controls // ---------------------------------------------------------------------------- +#if wxUSE_RICHEDIT + bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) { if ( !IsRich() ) @@ -1365,10 +1902,9 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) return FALSE; } - // the rich text control doesn't handle setting background colour, so don't - // even try if it's the only thing we want to change - if ( wxRichEditModule::GetLoadedVersion() < 2 && - !style.HasFont() && !style.HasTextColour() ) + // the richedit 1.0 doesn't handle setting background colour, so don't + // even try to do anything if it's the only thing we want to change + if ( m_verRichEdit == 1 && !style.HasFont() && !style.HasTextColour() ) { // nothing to do: return TRUE if there was really nothing to do and // FALSE if we failed to set bg colour @@ -1392,7 +1928,9 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) bool changeSel = start != startOld || end != endOld; if ( changeSel ) - SendMessage(GetHwnd(), EM_SETSEL, (WPARAM) start, (LPARAM) end); + { + DoSetSelection(start, end, FALSE /* don't scroll caret into view */); + } // initialize CHARFORMAT struct #if wxUSE_RICHEDIT2 @@ -1400,11 +1938,29 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) #else CHARFORMAT cf; #endif + wxZeroMemory(cf); - cf.cbSize = sizeof(cf); + + // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple + // CHARFORMAT in that case +#if wxUSE_RICHEDIT2 + if ( m_verRichEdit == 1 ) + { + // this is the only thing the control is going to grok + cf.cbSize = sizeof(CHARFORMAT); + } + else +#endif + { + // CHARFORMAT or CHARFORMAT2 + cf.cbSize = sizeof(cf); + } if ( style.HasFont() ) { + // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0 + // but using it doesn't seem to hurt neither so leaving it for now + cf.dwMask |= CFM_FACE | CFM_SIZE | CFM_CHARSET | CFM_ITALIC | CFM_BOLD | CFM_UNDERLINE; @@ -1447,7 +2003,7 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) } #if wxUSE_RICHEDIT2 - if ( wxRichEditModule::GetLoadedVersion() > 1 && style.HasBackgroundColour() ) + if ( m_verRichEdit != 1 && style.HasBackgroundColour() ) { cf.dwMask |= CFM_BACKCOLOR; cf.crBackColor = wxColourToRGB(style.GetBackgroundColour()); @@ -1465,12 +2021,27 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style) if ( changeSel ) { // restore the original selection - SendMessage(GetHwnd(), EM_SETSEL, (WPARAM)startOld, (LPARAM)endOld); + DoSetSelection(startOld, endOld, FALSE); } return ok; } +bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style) +{ + if ( !wxTextCtrlBase::SetDefaultStyle(style) ) + 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); + + return TRUE; +} + +#endif + // ---------------------------------------------------------------------------- // wxRichEditModule // ---------------------------------------------------------------------------- @@ -1483,48 +2054,48 @@ bool wxRichEditModule::OnInit() void wxRichEditModule::OnExit() { - if ( ms_hRichEdit ) + for ( size_t i = 0; i < WXSIZEOF(ms_hRichEdit); i++ ) { - FreeLibrary(ms_hRichEdit); + if ( ms_hRichEdit[i] ) + { + ::FreeLibrary(ms_hRichEdit[i]); + } } } /* static */ bool wxRichEditModule::Load(int version) { - wxCHECK_MSG( version >= 1 && version <= 3, FALSE, + // 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") ); - if ( version <= ms_verRichEdit ) + // make it the index in the array + version--; + + if ( ms_hRichEdit[version] == (HINSTANCE)-1 ) { - // we've already got this or better - return TRUE; + // we had already tried to load it and failed + return FALSE; } - if ( ms_hRichEdit ) + if ( ms_hRichEdit[version] ) { - ::FreeLibrary(ms_hRichEdit); + // we've already got this one + return TRUE; } - // always try load riched20.dll first - like this we won't have to reload - // it later if we're first asked for RE 1 and then for RE 2 or 3 - wxString dllname = _T("riched20.dll"); - ms_hRichEdit = ::LoadLibrary(dllname); - ms_verRichEdit = 2; // no way to tell if it's 2 or 3, assume 2 + wxString dllname = version ? _T("riched20") : _T("riched32"); + dllname += _T(".dll"); - if ( !ms_hRichEdit && (version == 1) ) - { - // fall back to RE 1 - dllname = _T("riched32.dll"); - ms_hRichEdit = ::LoadLibrary(dllname); - ms_verRichEdit = 1; - } + ms_hRichEdit[version] = ::LoadLibrary(dllname); - if ( !ms_hRichEdit ) + if ( !ms_hRichEdit[version] ) { wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str()); - ms_verRichEdit = -1; + ms_hRichEdit[version] = (HINSTANCE)-1; return FALSE; }