]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/textctrl.cpp
Committing in .
[wxWidgets.git] / src / msw / textctrl.cpp
index fc7e926e8c4bd7f6203dee2d747972302ef729ec..4fdcde3e8332d4c46197c3a7e693c8ba193b4e82 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        textctrl.cpp
+// Name:        msw/textctrl.cpp
 // Purpose:     wxTextCtrl
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     wxTextCtrl
 // Author:      Julian Smart
 // Modified by:
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
+#if wxUSE_TEXTCTRL
+
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
     #include "wx/settings.h"
     #include "wx/brush.h"
     #include "wx/utils.h"
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
     #include "wx/settings.h"
     #include "wx/brush.h"
     #include "wx/utils.h"
+    #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/log.h"
+    #include "wx/app.h"
 #endif
 
 #endif
 
+#include "wx/module.h"
+
 #if wxUSE_CLIPBOARD
 #if wxUSE_CLIPBOARD
-    #include "wx/app.h"
     #include "wx/clipbrd.h"
 #endif
 
     #include "wx/clipbrd.h"
 #endif
 
 #include <stdlib.h>
 #include <sys/types.h>
 
 #include <stdlib.h>
 #include <sys/types.h>
 
-#if wxUSE_IOSTREAMH
-#   include <fstream.h>
-#else
-#   include <fstream>
+#if wxUSE_RICHEDIT && (!defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__))
+    #include <richedit.h>
 #endif
 
 #endif
 
-#if wxUSE_RICHEDIT && (!defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS))
-    #include <richedit.h>
+// old mingw32 doesn't define this
+#ifndef CFM_CHARSET
+    #define CFM_CHARSET 0x08000000
+#endif // CFM_CHARSET
+
+#ifndef CFM_BACKCOLOR
+    #define CFM_BACKCOLOR 0x04000000
+#endif
+
+// cygwin does not have these defined for richedit
+#ifndef ENM_LINK
+    #define ENM_LINK 0x04000000
 #endif
 
 #endif
 
-#if !USE_SHARED_LIBRARY
+#ifndef EM_AUTOURLDETECT
+    #define EM_AUTOURLDETECT (WM_USER + 91)
+#endif
+
+#ifndef EN_LINK
+    #define EN_LINK 0x070b
+
+    typedef struct _enlink
+    {
+        NMHDR nmhdr;
+        UINT msg;
+        WPARAM wParam;
+        LPARAM lParam;
+        CHARRANGE chrg;
+    } ENLINK;
+#endif // ENLINK
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+#if wxUSE_RICHEDIT
+
+// this module initializes RichEdit DLL 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;
+
+    DECLARE_DYNAMIC_CLASS(wxRichEditModule)
+};
+
+HINSTANCE wxRichEditModule::ms_hRichEdit = (HINSTANCE)NULL;
+int       wxRichEditModule::ms_verRichEdit = -1;
+
+IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule)
+
+#endif // wxUSE_RICHEDIT
 
 // ----------------------------------------------------------------------------
 // event tables and other macros
 
 // ----------------------------------------------------------------------------
 // event tables and other macros
@@ -84,10 +148,11 @@ BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
     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_PASTE, wxTextCtrl::OnUpdatePaste)
     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
+#ifdef __WIN16__
+    EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
+#endif
 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 
-#endif // USE_SHARED_LIBRARY
-
 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================
@@ -115,42 +180,48 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
         return FALSE;
 
     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
         return FALSE;
 
-    // Validator was set in CreateBase
-    //SetValidator(validator);
     if ( parent )
         parent->AddChild(this);
 
     if ( parent )
         parent->AddChild(this);
 
-    // set colours
-    SetupColours();
-
     // translate wxWin style flags to MSW ones, checking for consistency while
     // doing it
     // translate wxWin style flags to MSW ones, checking for consistency while
     // doing it
-    long msStyle = ES_LEFT | WS_VISIBLE | WS_CHILD | WS_TABSTOP;
+    long msStyle = ES_LEFT | WS_TABSTOP;
+
+    if ( m_windowStyle & wxCLIP_SIBLINGS )
+        msStyle |= WS_CLIPSIBLINGS;
+
     if ( m_windowStyle & wxTE_MULTILINE )
     {
         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
     if ( m_windowStyle & wxTE_MULTILINE )
     {
         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
-                      wxT("wxTE_PROCESS_ENTER style is ignored for multiline "
-                         "text controls (they always process it)") );
+                      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;
     }
 
         msStyle |= ES_MULTILINE | ES_WANTRETURN;
         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
             msStyle |= WS_VSCROLL;
         m_windowStyle |= wxTE_PROCESS_ENTER;
     }
-    else
+    else // !multiline
+    {
+        // there is really no reason to not have this style for single line
+        // text controls
         msStyle |= ES_AUTOHSCROLL;
         msStyle |= ES_AUTOHSCROLL;
+    }
 
 
-    if (m_windowStyle & wxHSCROLL)
-        msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL);
+    if ( m_windowStyle & wxHSCROLL )
+        msStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
 
 
-    if (m_windowStyle & wxTE_READONLY)
+    if ( m_windowStyle & wxTE_READONLY )
         msStyle |= ES_READONLY;
 
         msStyle |= ES_READONLY;
 
-    if (m_windowStyle & wxHSCROLL)
-        msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL);
-    if (m_windowStyle & wxTE_PASSWORD) // hidden input
+    if ( m_windowStyle & wxTE_PASSWORD )
         msStyle |= ES_PASSWORD;
 
         msStyle |= ES_PASSWORD;
 
+    if ( m_windowStyle & wxTE_AUTO_SCROLL )
+        msStyle |= ES_AUTOHSCROLL;
+
+    if ( m_windowStyle & wxTE_NOHIDESEL )
+        msStyle |= ES_NOHIDESEL;
+
     // we always want the characters and the arrows
     m_lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
 
     // we always want the characters and the arrows
     m_lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
 
@@ -167,81 +238,86 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
         m_lDlgCode |= DLGC_WANTTAB;
 
     // do create the control - either an EDIT or RICHEDIT
         m_lDlgCode |= DLGC_WANTTAB;
 
     // do create the control - either an EDIT or RICHEDIT
-    const wxChar *windowClass = wxT("EDIT");
+    wxString windowClass = wxT("EDIT");
 
 #if wxUSE_RICHEDIT
     if ( m_windowStyle & wxTE_RICH )
     {
 
 #if wxUSE_RICHEDIT
     if ( m_windowStyle & wxTE_RICH )
     {
-        msStyle |= ES_AUTOVSCROLL;
-        m_isRich = TRUE;
-        windowClass = wxT("RICHEDIT");
+        static bool s_errorGiven = FALSE;   // MT-FIXME
+
+        // 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() )
+            {
+                wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
+
+                s_errorGiven = TRUE;
+            }
+        }
+
+        if ( s_errorGiven )
+        {
+            m_isRich = FALSE;
+        }
+        else
+        {
+            msStyle |= ES_AUTOVSCROLL;
+            // Experimental: this seems to help with the scroll problem. See messages from Jekabs Andrushaitis <j.andrusaitis@konts.lv>
+            // wx-dev list, entitled "[wx-dev] wxMSW-EVT_KEY_DOWN and wxMSW-wxTextCtrl" and "[wx-dev] TextCtrl (RichEdit)"
+            // Unfortunately, showing the selection in blue when the control doesn't have
+            // the focus is non-standard behaviour, and we need to find another workaround.
+            //msStyle |= ES_NOHIDESEL ;
+            m_isRich = TRUE;
+
+            int ver = wxRichEditModule::GetLoadedVersion();
+            if ( ver == 1 )
+            {
+                windowClass = wxT("RICHEDIT");
+            }
+            else
+            {
+#ifndef RICHEDIT_CLASS
+                wxString RICHEDIT_CLASS;
+                RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), ver);
+#if wxUSE_UNICODE
+                RICHEDIT_CLASS += _T('W');
+#else // ANSI
+                RICHEDIT_CLASS += _T('A');
+#endif // Unicode/ANSI
+#endif // !RICHEDIT_CLASS
+
+                windowClass = RICHEDIT_CLASS;
+            }
+        }
     }
     else
         m_isRich = FALSE;
     }
     else
         m_isRich = FALSE;
-#endif
+#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,
-                                      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 ( !MSWCreateControl(windowClass, msStyle, pos, size, value) )
+        return FALSE;
 
 
-#if wxUSE_CTL3D
-    if ( want3D )
-    {
-        Ctl3dSubclassCtl(GetHwnd());
-        m_useCtl3D = TRUE;
-    }
-#endif
+    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
 
 #if wxUSE_RICHEDIT
     if (m_isRich)
     {
 
 #if wxUSE_RICHEDIT
     if (m_isRich)
     {
-        // Have to enable events
-        ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0,
-                      ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE);
-    }
-#endif
+        // have to enable events manually
+        LPARAM mask = ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE;
 
 
-    SubclassWin(GetHWND());
+        if ( m_windowStyle & wxTE_AUTO_URL )
+        {
+            mask |= ENM_LINK;
 
 
-    // set font, position, size and initial value
-    wxFont& fontParent = parent->GetFont();
-    if ( fontParent.Ok() )
-    {
-        SetFont(fontParent);
-    }
-    else
-    {
-        SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT));
-    }
+            ::SendMessage(GetHwnd(), EM_AUTOURLDETECT, TRUE, 0);
+        }
 
 
-    // Causes a crash for Symantec C++ and WIN32 for some reason
-#if !(defined(__SC__) && defined(__WIN32__))
-    if ( !value.IsEmpty() )
-    {
-        SetValue(value);
+        ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0, mask);
     }
     }
-#endif
-
-    SetSize(pos.x, pos.y, size.x, size.y);
+#endif // wxUSE_RICHEDIT
 
     return TRUE;
 }
 
     return TRUE;
 }
@@ -276,29 +352,76 @@ void wxTextCtrl::AdoptAttributesFromHWND()
     m_windowStyle |= wxTE_PROCESS_ENTER;
 }
 
     m_windowStyle |= wxTE_PROCESS_ENTER;
 }
 
-void wxTextCtrl::SetupColours()
-{
-    // FIXME why is bg colour not inherited from parent?
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
-    SetForegroundColour(GetParent()->GetForegroundColour());
-}
-
 // ----------------------------------------------------------------------------
 // set/get the controls text
 // ----------------------------------------------------------------------------
 
 wxString wxTextCtrl::GetValue() const
 {
 // ----------------------------------------------------------------------------
 // set/get the controls text
 // ----------------------------------------------------------------------------
 
 wxString wxTextCtrl::GetValue() const
 {
-    return wxGetWindowText(GetHWND());
+    // we can't use wxGetWindowText() (i.e. WM_GETTEXT internally) for
+    // retrieving more than 64Kb under Win9x
+#if wxUSE_RICHEDIT
+    if ( m_isRich )
+    {
+        wxString str;
+
+        int len = GetWindowTextLength(GetHwnd());
+        if ( len )
+        {
+            // 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.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 ( *p == _T('\r') )
+                    *p = _T('\n');
+            }
+
+            str.UngetWriteBuf();
+        }
+        //else: no text at all, leave the string empty
+
+        return str;
+    }
+#endif // wxUSE_RICHEDIT
+
+    // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
+    // same one as above for consitency
+    wxString str = wxGetWindowText(GetHWND());
+
+    return wxTextFile::Translate(str, wxTextFileType_Unix);
 }
 
 void wxTextCtrl::SetValue(const wxString& value)
 {
 }
 
 void wxTextCtrl::SetValue(const wxString& value)
 {
-    wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
-
-    if ( valueDos != GetValue() )
+    // 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
+    // anyhow, this comparison is there to avoid flicker for small single-line
+    // edit controls mostly)
+    if ( (value.length() > 0x400) || (value != GetValue()) )
     {
     {
-        SetWindowText(GetHwnd(), valueDos);
+        wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
+
+        SetWindowText(GetHwnd(), valueDos.c_str());
+
+        // for compatibility with the GTK and because it is more logical, we
+        // move the cursor to the end of the text after SetValue()
+
+        // 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();
 
         AdjustSpaceLimit();
     }
 
         AdjustSpaceLimit();
     }
@@ -308,6 +431,17 @@ void wxTextCtrl::WriteText(const wxString& value)
 {
     wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
 
 {
     wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
 
+#if wxUSE_RICHEDIT
+    // ensure that the new text will be in the default style
+    if ( IsRich() &&
+            (m_defaultStyle.HasFont() || m_defaultStyle.HasTextColour()) )
+    {
+        long start, end;
+        GetSelection(&start, &end);
+        SetStyle(start, end, m_defaultStyle );
+    }
+#endif // wxUSE_RICHEDIT
+
     SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
 
     AdjustSpaceLimit();
     SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
 
     AdjustSpaceLimit();
@@ -360,7 +494,7 @@ bool wxTextCtrl::CanCopy() const
     // Can copy if there's a selection
     long from, to;
     GetSelection(& from, & to);
     // Can copy if there's a selection
     long from, to;
     GetSelection(& from, & to);
-    return (from != to);
+    return (from != to) ;
 }
 
 bool wxTextCtrl::CanCut() const
 }
 
 bool wxTextCtrl::CanCut() const
@@ -368,7 +502,7 @@ bool wxTextCtrl::CanCut() const
     // Can cut if there's a selection
     long from, to;
     GetSelection(& from, & to);
     // Can cut if there's a selection
     long from, to;
     GetSelection(& from, & to);
-    return (from != to);
+    return (from != to) && (IsEditable());
 }
 
 bool wxTextCtrl::CanPaste() const
 }
 
 bool wxTextCtrl::CanPaste() const
@@ -427,8 +561,13 @@ void wxTextCtrl::SetInsertionPoint(long pos)
     SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(pos, pos));
 #endif // Win32/16
 
     SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(pos, pos));
 #endif // Win32/16
 
-    static const char *nothing = "";
-    SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing);
+#if wxUSE_RICHEDIT
+    if ( !m_isRich)
+#endif
+    {
+        static const wxChar *nothing = _T("");
+        SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing);
+    }
 }
 
 void wxTextCtrl::SetInsertionPointEnd()
 }
 
 void wxTextCtrl::SetInsertionPointEnd()
@@ -483,18 +622,19 @@ void wxTextCtrl::GetSelection(long* from, long* to) const
 
         *from = charRange.cpMin;
         *to = charRange.cpMax;
 
         *from = charRange.cpMin;
         *to = charRange.cpMax;
-
-        return;
     }
     }
-#endif
-    DWORD dwStart, dwEnd;
-    WPARAM wParam = (WPARAM) (DWORD*) & dwStart; // receives starting position
-    LPARAM lParam = (LPARAM) (DWORD*) & dwEnd;   // receives ending position
+    else
+#endif // rich/!rich
+    {
+        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, lParam);
 
 
-    *from = dwStart;
-    *to = dwEnd;
+        *from = dwStart;
+        *to = dwEnd;
+    }
 }
 
 bool wxTextCtrl::IsEditable() const
 }
 
 bool wxTextCtrl::IsEditable() const
@@ -510,7 +650,6 @@ bool wxTextCtrl::IsEditable() const
 
 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 {
 
 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 {
-#if wxUSE_CLIPBOARD
     HWND hWnd = GetHwnd();
     long fromChar = from;
     long toChar = to;
     HWND hWnd = GetHwnd();
     long fromChar = from;
     long toChar = to;
@@ -518,18 +657,10 @@ void wxTextCtrl::Replace(long from, long to, const wxString& value)
     // Set selection and remove it
 #ifdef __WIN32__
     SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
     // 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));
 #else
     SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar));
-#endif
-    SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
-
-    // Now replace with 'value', by pasting.
-    wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)value, 0, 0);
-
-    // Paste into edit control
-    SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L);
-#else
-    wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
+    SendMessage(hWnd, EM_REPLACESEL, (WPARAM)0, (LPARAM)value.c_str());
 #endif
 }
 
 #endif
 }
 
@@ -542,10 +673,11 @@ void wxTextCtrl::Remove(long from, long to)
     // Cut all selected text
 #ifdef __WIN32__
     SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
     // 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));
 #else
     SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar));
+    SendMessage(hWnd, EM_REPLACESEL, (WPARAM)0, (LPARAM)"");
 #endif
 #endif
-    SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
 }
 
 void wxTextCtrl::SetSelection(long from, long to)
 }
 
 void wxTextCtrl::SetSelection(long from, long to)
@@ -681,18 +813,28 @@ int wxTextCtrl::GetLineLength(long lineNo) const
 wxString wxTextCtrl::GetLineText(long lineNo) const
 {
     size_t len = (size_t)GetLineLength(lineNo) + 1;
 wxString wxTextCtrl::GetLineText(long lineNo) const
 {
     size_t len = (size_t)GetLineLength(lineNo) + 1;
-    char *buf = (char *)malloc(len);
-    *(WORD *)buf = len;
-    int noChars = (int)SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
-    buf[noChars] = 0;
 
 
-    wxString str(buf);
+    // there must be at least enough place for the length WORD in the
+    // buffer
+    len += sizeof(WORD);
+
+    wxString str;
+    wxChar *buf = str.GetWriteBuf(len);
+
+    *(WORD *)buf = (WORD)len;
+    len = (size_t)::SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
+    buf[len] = 0;
 
 
-    free(buf);
+    str.UngetWriteBuf(len);
 
     return str;
 }
 
 
     return str;
 }
 
+void wxTextCtrl::SetMaxLength(unsigned long len)
+{
+    ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0);
+}
+
 // ----------------------------------------------------------------------------
 // Undo/redo
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Undo/redo
 // ----------------------------------------------------------------------------
@@ -743,28 +885,50 @@ void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
     }
 }
 
     }
 }
 
-WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
-                                WXUINT message, WXWPARAM wParam,
-                                WXLPARAM lParam)
+// ----------------------------------------------------------------------------
+// kbd input processing
+// ----------------------------------------------------------------------------
+
+bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg)
 {
 {
-#if wxUSE_CTL3D
-    if ( m_useCtl3D )
+    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 )
     {
     {
-        HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
-        return (WXHBRUSH) hbrush;
+        WORD vkey = msg->wParam;
+        if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN )
+        {
+            if ( vkey == VK_BACK )
+                return FALSE;
+        }
+        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() )
+            {
+                if ( vkey == VK_INSERT || vkey == VK_DELETE )
+                    return FALSE;
+            }
+        }
     }
     }
-#endif
-
-    HDC hdc = (HDC)pDC;
-    SetBkMode(hdc, GetParent()->GetTransparentBackground() ? TRANSPARENT
-                                                           : OPAQUE);
-
-    ::SetBkColor(hdc, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
-    ::SetTextColor(hdc, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
 
 
-    wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
-
-    return (WXHBRUSH) backgroundBrush->GetResourceHandle();
+    return wxControl::MSWShouldPreProcessMessage(pMsg);
 }
 
 void wxTextCtrl::OnChar(wxKeyEvent& event)
 }
 
 void wxTextCtrl::OnChar(wxKeyEvent& event)
@@ -775,7 +939,8 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
-                event.SetEventObject( this );
+                InitCommandEvent(event);
+                event.SetString(GetValue());
                 if ( GetEventHandler()->ProcessEvent(event) )
                     return;
             }
                 if ( GetEventHandler()->ProcessEvent(event) )
                     return;
             }
@@ -788,30 +953,19 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
             // 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.
             // 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.
-            //
-            // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
-            //     handled by Windows
             {
                 wxNavigationKeyEvent eventNav;
                 eventNav.SetDirection(!event.ShiftDown());
             {
                 wxNavigationKeyEvent eventNav;
                 eventNav.SetDirection(!event.ShiftDown());
-                eventNav.SetWindowChange(FALSE);
+                eventNav.SetWindowChange(event.ControlDown());
                 eventNav.SetEventObject(this);
 
                 eventNav.SetEventObject(this);
 
-                if ( GetEventHandler()->ProcessEvent(eventNav) )
+                if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
                     return;
             }
             break;
                     return;
             }
             break;
-
-        default:
-            event.Skip();
-            return;
     }
 
     }
 
-    // don't just call event.Skip() because this will cause TABs and ENTERs
-    // be passed upwards and we don't always want this - instead process it
-    // right here
-
-    // FIXME
+    // no, we didn't process it
     event.Skip();
 }
 
     event.Skip();
 }
 
@@ -823,8 +977,8 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
         case EN_KILLFOCUS:
             {
                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
         case EN_KILLFOCUS:
             {
                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
-                        : wxEVT_SET_FOCUS,
-                        m_windowId);
+                                                         : wxEVT_SET_FOCUS,
+                                   m_windowId);
                 event.SetEventObject( this );
                 GetEventHandler()->ProcessEvent(event);
             }
                 event.SetEventObject( this );
                 GetEventHandler()->ProcessEvent(event);
             }
@@ -833,24 +987,29 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
         case EN_CHANGE:
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
         case EN_CHANGE:
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
-                wxString val(GetValue());
-                if ( !val.IsNull() )
-                    event.m_commandString = WXSTRINGCAST val;
-                event.SetEventObject( this );
+                InitCommandEvent(event);
+                event.SetString(GetValue());
                 ProcessCommand(event);
             }
             break;
 
                 ProcessCommand(event);
             }
             break;
 
-        case EN_ERRSPACE:
+        case EN_MAXTEXT:
             // the text size limit has been hit - increase it
             // the text size limit has been hit - increase it
-            AdjustSpaceLimit();
+            if ( !AdjustSpaceLimit() )
+            {
+                wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId);
+                InitCommandEvent(event);
+                event.SetString(GetValue());
+                ProcessCommand(event);
+            }
             break;
 
             // the other notification messages are not processed
         case EN_UPDATE:
             break;
 
             // the other notification messages are not processed
         case EN_UPDATE:
-        case EN_MAXTEXT:
+        case EN_ERRSPACE:
         case EN_HSCROLL:
         case EN_VSCROLL:
         case EN_HSCROLL:
         case EN_VSCROLL:
+            return FALSE;
         default:
             return FALSE;
     }
         default:
             return FALSE;
     }
@@ -859,25 +1018,126 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
     return TRUE;
 }
 
     return TRUE;
 }
 
-void wxTextCtrl::AdjustSpaceLimit()
+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;
+    if (GetParent()->GetTransparentBackground())
+        SetBkMode(hdc, TRANSPARENT);
+    else
+        SetBkMode(hdc, OPAQUE);
+
+    wxColour colBack = GetBackgroundColour();
+
+    if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
+        colBack = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+
+    ::SetBkColor(hdc, wxColourToRGB(colBack));
+    ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
+
+    wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
+
+    return (WXHBRUSH)brush->GetResourceHandle();
+}
+
+// In WIN16, need to override normal erasing because
+// Ctl3D doesn't use the wxWindows background colour.
+#ifdef __WIN16__
+void wxTextCtrl::OnEraseBackground(wxEraseEvent& event)
+{
+    wxColour col(m_backgroundColour);
+
+#if wxUSE_CTL3D
+    if (m_useCtl3D)
+        col = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW);
+#endif
+
+    RECT rect;
+    ::GetClientRect(GetHwnd(), &rect);
+
+    COLORREF ref = PALETTERGB(col.Red(),
+                              col.Green(),
+                              col.Blue());
+    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);
+
+}
+#endif
+
+bool wxTextCtrl::AdjustSpaceLimit()
 {
 #ifndef __WIN16__
 {
 #ifndef __WIN16__
-    unsigned int len = ::GetWindowTextLength(GetHwnd()),
-    limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0);
-    if ( len > limit )
+    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
     {
         limit = len + 0x8000;    // 32Kb
 
 #if wxUSE_RICHEDIT
-        if ( m_isRich || limit > 0xffff )
-#else
-        if ( limit > 0xffff )
-#endif
-            ::SendMessage(GetHwnd(), EM_LIMITTEXT, 0, limit);
+        if ( m_isRich )
+        {
+            // as a nice side effect, this also allows passing limit > 64Kb
+            ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit);
+        }
         else
         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);
             ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0);
+        }
     }
     }
-#endif
+#endif // !Win16
+
+    // we changed the limit
+    return TRUE;
 }
 
 bool wxTextCtrl::AcceptsFocus() const
 }
 
 bool wxTextCtrl::AcceptsFocus() const
@@ -886,7 +1146,7 @@ bool wxTextCtrl::AcceptsFocus() const
     return IsEditable() && wxControl::AcceptsFocus();
 }
 
     return IsEditable() && wxControl::AcceptsFocus();
 }
 
-wxSize wxTextCtrl::DoGetBestSize()
+wxSize wxTextCtrl::DoGetBestSize() const
 {
     int cx, cy;
     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
 {
     int cx, cy;
     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
@@ -896,7 +1156,7 @@ wxSize wxTextCtrl::DoGetBestSize()
     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
     if ( m_windowStyle & wxTE_MULTILINE )
     {
     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
     if ( m_windowStyle & wxTE_MULTILINE )
     {
-        hText *= wxMin(GetNumberOfLines(), 5);
+        hText *= wxMax(GetNumberOfLines(), 5);
     }
     //else: for single line control everything is ok
 
     }
     //else: for single line control everything is ok
 
@@ -907,27 +1167,27 @@ wxSize wxTextCtrl::DoGetBestSize()
 // standard handlers for standard edit menu events
 // ----------------------------------------------------------------------------
 
 // standard handlers for standard edit menu events
 // ----------------------------------------------------------------------------
 
-void wxTextCtrl::OnCut(wxCommandEvent& event)
+void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
 {
     Cut();
 }
 
 {
     Cut();
 }
 
-void wxTextCtrl::OnCopy(wxCommandEvent& event)
+void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
 {
     Copy();
 }
 
 {
     Copy();
 }
 
-void wxTextCtrl::OnPaste(wxCommandEvent& event)
+void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
 {
     Paste();
 }
 
 {
     Paste();
 }
 
-void wxTextCtrl::OnUndo(wxCommandEvent& event)
+void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
 {
     Undo();
 }
 
 {
     Undo();
 }
 
-void wxTextCtrl::OnRedo(wxCommandEvent& event)
+void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
 {
     Redo();
 }
 {
     Redo();
 }
@@ -957,3 +1217,303 @@ void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
     event.Enable( CanRedo() );
 }
 
     event.Enable( CanRedo() );
 }
 
+// the rest of the file only deals with the rich edit controls
+#if wxUSE_RICHEDIT
+
+// ----------------------------------------------------------------------------
+// EN_LINK processing
+// ----------------------------------------------------------------------------
+
+bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
+{
+    NMHDR *hdr = (NMHDR* )lParam;
+    if ( hdr->code == EN_LINK )
+    {
+        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
+    return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// 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) )
+    {
+        // colour didn't really change
+        return FALSE;
+    }
+
+    if ( IsRich() )
+    {
+        // rich edit doesn't use WM_CTLCOLOR, hence we need to send
+        // EM_SETBKGNDCOLOR additionally
+        ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR, 0, wxColourToRGB(colour));
+    }
+
+    return TRUE;
+}
+
+bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
+{
+    if ( !wxTextCtrlBase::SetForegroundColour(colour) )
+    {
+        // colour didn't really change
+        return FALSE;
+    }
+
+    if ( IsRich() )
+    {
+        // change the colour of everything
+        CHARFORMAT cf;
+        wxZeroMemory(cf);
+        cf.cbSize = sizeof(cf);
+        cf.dwMask = CFM_COLOR;
+        cf.crTextColor = wxColourToRGB(colour);
+        ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
+    }
+
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// styling support for rich edit controls
+// ----------------------------------------------------------------------------
+
+bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
+{
+    if ( !IsRich() )
+    {
+        // can't do it with normal text control
+        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() )
+    {
+        // nothing to do: return TRUE if there was really nothing to do and
+        // FALSE if we failed to set bg colour
+        return !style.HasBackgroundColour();
+    }
+
+    // order the range if needed
+    if ( start > end )
+    {
+        long tmp = start;
+        start = end;
+        end = tmp;
+    }
+
+    // we can only change the format of the selection, so select the range we
+    // want and restore the old selection later
+    long startOld, endOld;
+    GetSelection(&startOld, &endOld);
+
+    // but do we really have to change the selection?
+    bool changeSel = start != startOld || end != endOld;
+
+    if ( changeSel )
+        SendMessage(GetHwnd(), EM_SETSEL, (WPARAM) start, (LPARAM) end);
+
+    // initialize CHARFORMAT struct
+#if wxUSE_RICHEDIT2
+    CHARFORMAT2 cf;
+#else
+    CHARFORMAT cf;
+#endif
+    wxZeroMemory(cf);
+    cf.cbSize = sizeof(cf);
+
+    if ( style.HasFont() )
+    {
+        cf.dwMask |= CFM_FACE | CFM_SIZE | CFM_CHARSET |
+                     CFM_ITALIC | CFM_BOLD | CFM_UNDERLINE;
+
+        // fill in data from LOGFONT but recalculate lfHeight because we need
+        // 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)
+        LOGFONT lf;
+        wxFillLogFont(&lf, &style.GetFont());
+        cf.yHeight = 20*style.GetFont().GetPointSize(); // 1 pt = 20 twips
+        cf.bCharSet = lf.lfCharSet;
+        cf.bPitchAndFamily = lf.lfPitchAndFamily;
+        wxStrncpy( cf.szFaceName, lf.lfFaceName, WXSIZEOF(cf.szFaceName) );
+
+        // also deal with underline/italic/bold attributes: note that we must
+        // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
+        // style to allow clearing it
+        if ( lf.lfItalic )
+        {
+            cf.dwEffects |= CFE_ITALIC;
+        }
+
+        if ( lf.lfWeight == FW_BOLD )
+        {
+            cf.dwEffects |= CFE_BOLD;
+        }
+
+        if ( lf.lfUnderline )
+        {
+            cf.dwEffects |= CFE_UNDERLINE;
+        }
+
+        // strikeout fonts are not supported by wxWindows
+    }
+
+    if ( style.HasTextColour() )
+    {
+        cf.dwMask |= CFM_COLOR;
+        cf.crTextColor = wxColourToRGB(style.GetTextColour());
+    }
+
+#if wxUSE_RICHEDIT2
+    if ( wxRichEditModule::GetLoadedVersion() > 1 && style.HasBackgroundColour() )
+    {
+        cf.dwMask |= CFM_BACKCOLOR;
+        cf.crBackColor = wxColourToRGB(style.GetBackgroundColour());
+    }
+#endif // wxUSE_RICHEDIT2
+
+    // do format the selection
+    bool ok = ::SendMessage(GetHwnd(), EM_SETCHARFORMAT,
+                            SCF_SELECTION, (LPARAM)&cf) != 0;
+    if ( !ok )
+    {
+        wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
+    }
+
+    if ( changeSel )
+    {
+        // restore the original selection
+        SendMessage(GetHwnd(), EM_SETSEL, (WPARAM)startOld, (LPARAM)endOld);
+    }
+
+    return ok;
+}
+
+// ----------------------------------------------------------------------------
+// wxRichEditModule
+// ----------------------------------------------------------------------------
+
+bool wxRichEditModule::OnInit()
+{
+    // don't do anything - we will load it when needed
+    return TRUE;
+}
+
+void wxRichEditModule::OnExit()
+{
+    if ( ms_hRichEdit )
+    {
+        FreeLibrary(ms_hRichEdit);
+    }
+}
+
+/* static */
+bool wxRichEditModule::Load(int version)
+{
+    wxCHECK_MSG( version >= 1 && version <= 3, FALSE,
+                 _T("incorrect richedit control version requested") );
+
+    if ( version <= ms_verRichEdit )
+    {
+        // we've already got this or better
+        return TRUE;
+    }
+
+    if ( ms_hRichEdit )
+    {
+        ::FreeLibrary(ms_hRichEdit);
+    }
+
+    // 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
+
+    if ( !ms_hRichEdit && (version == 1) )
+    {
+        // fall back to RE 1
+        dllname = _T("riched32.dll");
+        ms_hRichEdit = ::LoadLibrary(dllname);
+        ms_verRichEdit = 1;
+    }
+
+    if ( !ms_hRichEdit )
+    {
+        wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str());
+
+        ms_verRichEdit = -1;
+
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+#endif // wxUSE_RICHEDIT
+
+#endif // wxUSE_TEXTCTRL