]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/textctrl.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
typo fixed
[wxWidgets.git] / src / os2 / textctrl.cpp
diff --git a/src/os2/textctrl.cpp b/src/os2/textctrl.cpp
index acbe4bca0a37a43ce4a573efe66f01c15c9d8d9f..0e4b7a4461ddd4f490f8f7c4ed4cde41d8599516 100644 (file)
--- a/src/os2/textctrl.cpp
+++ b/src/os2/textctrl.cpp
@@ -18,6 +18,7 @@
 
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
 
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
+    #include "wx/scrolwin.h"
     #include "wx/settings.h"
     #include "wx/brush.h"
     #include "wx/utils.h"
     #include "wx/settings.h"
     #include "wx/brush.h"
     #include "wx/utils.h"
@@ -43,6 +44,11 @@
 #   include <fstream>
 #endif
 
 #   include <fstream>
 #endif
 
+#if !defined(MLE_INDEX)
+#define MLE_INDEX  0
+#define MLE_RGB    1
+#endif
+
 
 // ----------------------------------------------------------------------------
 // event tables and other macros
 
 // ----------------------------------------------------------------------------
 // event tables and other macros
@@ -93,6 +99,8 @@ bool wxTextCtrl::Create(
 , const wxString&                   rsName
 )
 {
 , const wxString&                   rsName
 )
 {
+    HWND                            hParent;
+    int                             nTempy;
     //
     // Base initialization
     //
     //
     // Base initialization
     //
@@ -108,8 +116,39 @@ bool wxTextCtrl::Create(
                     ))
         return FALSE;
 
                     ))
         return FALSE;
 
+    wxPoint                         vPos = rPos; // The OS/2 position
+
     if (pParent )
     if (pParent )
+    {
         pParent->AddChild(this);
         pParent->AddChild(this);
+        hParent = GetWinHwnd(pParent);
+        //
+        // OS2 uses normal coordinates, no bassackwards Windows ones
+        //
+        if (pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+            pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+        {
+            wxWindow*               pGrandParent = NULL;
+
+            pGrandParent = pParent->GetParent();
+            if (pGrandParent)
+                nTempy = pGrandParent->GetSize().y - (vPos.y + rSize.y);
+            else
+                nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+        }
+        else
+            nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+        vPos.y = nTempy;
+    }
+    else
+    {
+        RECTL                   vRect;
+
+        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+        hParent = HWND_DESKTOP;
+        vPos.y = vRect.yTop - (vPos.y + rSize.y);
+    }
 
     m_windowStyle = lStyle;
 
 
     m_windowStyle = lStyle;
 
@@ -120,8 +159,8 @@ bool wxTextCtrl::Create(
     //
     if ( m_windowStyle & wxTE_MULTILINE )
     {
     //
     if ( m_windowStyle & wxTE_MULTILINE )
     {
+        lSstyle |= MLS_BORDER | MLS_WORDWRAP;
         m_bIsMLE = TRUE;
         m_bIsMLE = TRUE;
-        m_windowStyle |= wxTE_PROCESS_ENTER;
 
         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
             lSstyle |= MLS_VSCROLL;
 
         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
             lSstyle |= MLS_VSCROLL;
@@ -132,7 +171,7 @@ bool wxTextCtrl::Create(
     }
     else
     {
     }
     else
     {
-        lSstyle |= ES_LEFT;
+        lSstyle |= ES_LEFT | ES_AUTOSCROLL | ES_MARGIN;
 
         if (m_windowStyle & wxHSCROLL)
             lSstyle |=  ES_AUTOSCROLL;
 
         if (m_windowStyle & wxHSCROLL)
             lSstyle |=  ES_AUTOSCROLL;
@@ -141,16 +180,20 @@ bool wxTextCtrl::Create(
         if (m_windowStyle & wxTE_PASSWORD) // hidden input
             lSstyle |= ES_UNREADABLE;
     }
         if (m_windowStyle & wxTE_PASSWORD) // hidden input
             lSstyle |= ES_UNREADABLE;
     }
+    if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+         pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+       )
+        lSstyle |= WS_CLIPSIBLINGS;
     if (m_bIsMLE)
     {
         m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
                                            ,WC_MLE                   // Window class
                                            ,(PSZ)rsValue.c_str()     // Initial Text
                                            ,(ULONG)lSstyle           // Style flags
     if (m_bIsMLE)
     {
         m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
                                            ,WC_MLE                   // Window class
                                            ,(PSZ)rsValue.c_str()     // Initial Text
                                            ,(ULONG)lSstyle           // Style flags
-                                           ,(LONG)rPos.x             // X pos of origin
-                                           ,(LONG)rPos.y             // Y pos of origin
-                                           ,(LONG)rSize.x            // field width
-                                           ,(LONG)rSize.y            // field height
+                                           ,(LONG)0                  // X pos of origin
+                                           ,(LONG)0                  // Y pos of origin
+                                           ,(LONG)0                  // field width
+                                           ,(LONG)0                  // field height
                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
                                            ,HWND_TOP                 // initial z position
                                            ,(ULONG)vId               // Window identifier
                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
                                            ,HWND_TOP                 // initial z position
                                            ,(ULONG)vId               // Window identifier
@@ -164,10 +207,10 @@ bool wxTextCtrl::Create(
                                            ,WC_ENTRYFIELD            // Window class
                                            ,(PSZ)rsValue.c_str()     // Initial Text
                                            ,(ULONG)lSstyle           // Style flags
                                            ,WC_ENTRYFIELD            // Window class
                                            ,(PSZ)rsValue.c_str()     // Initial Text
                                            ,(ULONG)lSstyle           // Style flags
-                                           ,(LONG)rPos.x             // X pos of origin
-                                           ,(LONG)rPos.y             // Y pos of origin
-                                           ,(LONG)rSize.x            // field width
-                                           ,(LONG)rSize.y            // field height
+                                           ,(LONG)0                  // X pos of origin
+                                           ,(LONG)0                  // Y pos of origin
+                                           ,(LONG)0                  // field width
+                                           ,(LONG)0                  // field height
                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
                                            ,HWND_TOP                 // initial z position
                                            ,(ULONG)vId               // Window identifier
                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
                                            ,HWND_TOP                 // initial z position
                                            ,(ULONG)vId               // Window identifier
@@ -201,8 +244,8 @@ bool wxTextCtrl::Create(
         SetValue(rsValue);
     }
     SetupColours();
         SetValue(rsValue);
     }
     SetupColours();
-    SetSize( rPos.x
-            ,rPos.y
+    SetSize( vPos.x
+            ,vPos.y
             ,rSize.x
             ,rSize.y
            );
             ,rSize.x
             ,rSize.y
            );
@@ -232,14 +275,24 @@ void wxTextCtrl::AdoptAttributesFromHWND()
         if (lStyle & ES_READONLY)
             m_windowStyle |= wxTE_READONLY;
     }
         if (lStyle & ES_READONLY)
             m_windowStyle |= wxTE_READONLY;
     }
-}
+} // end of wxTextCtrl::AdoptAttributesFromHWND
 
 void wxTextCtrl::SetupColours()
 {
 
 void wxTextCtrl::SetupColours()
 {
-    // FIXME why is bg colour not inherited from parent?
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+    wxColour                        vBkgndColour;
+
+    vBkgndColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW);
+    SetBackgroundColour(vBkgndColour);
     SetForegroundColour(GetParent()->GetForegroundColour());
     SetForegroundColour(GetParent()->GetForegroundColour());
-}
+    if (m_bIsMLE)
+    {
+        ::WinSendMsg( GetHwnd()
+                     ,MLM_SETTEXTCOLOR
+                     ,(MPARAM)GetParent()->GetForegroundColour().GetPixel()
+                     ,(MPARAM)MLE_RGB
+                    );
+    }
+} // end of wxTextCtrl::SetupColours
 
 // ----------------------------------------------------------------------------
 // set/get the controls text
 
 // ----------------------------------------------------------------------------
 // set/get the controls text
@@ -247,46 +300,60 @@ void wxTextCtrl::SetupColours()
 
 wxString wxTextCtrl::GetValue() const
 {
 
 wxString wxTextCtrl::GetValue() const
 {
-    return wxGetWindowText(GetHWND());
-}
-
-void wxTextCtrl::SetValue(const wxString& value)
-{
-// TODO:
-/*
-    wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
+    wxString                        sStr = wxGetWindowText(GetHWND());
+    char*                           zStr = (char*)sStr.c_str();
 
 
-    SetWindowText(GetHwnd(), valueDos);
-
-    AdjustSpaceLimit();
-*/
-}
+    for ( ; *zStr; zStr++ )
+    {
+        //
+        // this will replace \r\n with just \n
+        //
+        if (*zStr == '\n')
+            *zStr = '\0';
+        if (*zStr == '\r')
+            *zStr = '\n';
+    }
+    sStr = zStr;
+    return sStr;
+} // end of wxTextCtrl::GetValue
 
 
-void wxTextCtrl::WriteText(const wxString& value)
+void wxTextCtrl::SetValue(
+  const wxString&                   rsValue
+)
 {
 {
-// TODO:
-/*
-    wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
-
-    SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
+    //
+    // 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 ((rsValue.length() > 0x400) || (rsValue != GetValue()))
+    {
+        ::WinSetWindowText(GetHwnd(), rsValue.c_str());
+        AdjustSpaceLimit();
+    }
+} // end of wxTextCtrl::SetValue
 
 
+void wxTextCtrl::WriteText(
+  const wxString&                   rsValue
+)
+{
+    ::WinSetWindowText(GetHwnd(), rsValue.c_str());
     AdjustSpaceLimit();
     AdjustSpaceLimit();
-*/
-}
+} // end of wxTextCtrl::WriteText
 
 
-void wxTextCtrl::AppendText(const wxString& text)
+void wxTextCtrl::AppendText(
+  const wxString&                   rsText
+)
 {
 {
-// TODO:
-/*
     SetInsertionPointEnd();
     SetInsertionPointEnd();
-    WriteText(text);
-*/
-}
+    WriteText(rsText);
+} // end of wxTextCtrl::AppendText
 
 void wxTextCtrl::Clear()
 {
 
 void wxTextCtrl::Clear()
 {
-//    SetWindowText(GetHwnd(), wxT(""));
-}
+    ::WinSetWindowText(GetHwnd(), "");
+} // end of wxTextCtrl::Clear
 
 // ----------------------------------------------------------------------------
 // Clipboard operations
 
 // ----------------------------------------------------------------------------
 // Clipboard operations
@@ -315,34 +382,41 @@ void wxTextCtrl::Cut()
         else
             ::WinSendMsg(hWnd, EM_CUT, 0, 0);
     }
         else
             ::WinSendMsg(hWnd, EM_CUT, 0, 0);
     }
-}
+} // end of wxTextCtrl::Cut
 
 void wxTextCtrl::Paste()
 {
     if (CanPaste())
     {
 
 void wxTextCtrl::Paste()
 {
     if (CanPaste())
     {
-        HWND hWnd = GetHwnd();
-//        SendMessage(hWnd, WM_PASTE, 0, 0L);
+        HWND                        hWnd = GetHwnd();
+
+        ::WinSendMsg(hWnd, EM_PASTE, 0, 0);
     }
     }
-}
+} // end of wxTextCtrl::Paste
 
 bool wxTextCtrl::CanCopy() const
 {
 
 bool wxTextCtrl::CanCopy() const
 {
+    //
     // Can copy if there's a selection
     // Can copy if there's a selection
-    long from = 0L;
-    long to = 0L;
-//    GetSelection(& from, & to);
-    return (from != to);
-}
+    //
+    long                            lFrom = 0L;
+    long                            lTo = 0L;
+
+    GetSelection(&lFrom, &lTo);
+    return (lFrom != lTo);
+} // end of wxTextCtrl::CanCopy
 
 bool wxTextCtrl::CanCut() const
 {
 
 bool wxTextCtrl::CanCut() const
 {
+    //
     // Can cut if there's a selection
     // Can cut if there's a selection
-    long from = 0L;
-    long to = 0L;
-//    GetSelection(& from, & to);
-    return (from != to);
-}
+    //
+    long                            lFrom = 0L;
+    long                            lTo = 0L;
+
+    GetSelection(&lFrom, &lTo);
+    return (lFrom != lTo);
+} // end of wxTextCtrl::CanCut
 
 bool wxTextCtrl::CanPaste() const
 {
 
 bool wxTextCtrl::CanPaste() const
 {
@@ -366,29 +440,36 @@ bool wxTextCtrl::CanPaste() const
 // Accessors
 // ----------------------------------------------------------------------------
 
 // Accessors
 // ----------------------------------------------------------------------------
 
-void wxTextCtrl::SetEditable(bool editable)
+void wxTextCtrl::SetEditable(
+  bool                              bEditable
+)
 {
 {
-    HWND hWnd = GetHwnd();
-//    SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (m_bIsMLE)
+        ::WinSendMsg(hWnd, MLM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
+    else
+        ::WinSendMsg(hWnd, EM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
+} // end of wxTextCtrl::SetEditable
 
 
-void wxTextCtrl::SetInsertionPoint(long pos)
+void wxTextCtrl::SetInsertionPoint(
+  long                              lPos
+)
 {
 {
-// TODO:
-/*
-    HWND hWnd = GetHwnd();
-    {
-        SendMessage(hWnd, EM_SETSEL, pos, pos);
-        SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
-    }
-    static const char *nothing = "";
-    SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing);
-*/
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (m_bIsMLE)
+        ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lPos, (MPARAM)lPos);
+    else
+        ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lPos, (USHORT)lPos), (MPARAM)0);
+} // end of wxTextCtrl::SetInsertionPoint
 
 void wxTextCtrl::SetInsertionPointEnd()
 {
 
 void wxTextCtrl::SetInsertionPointEnd()
 {
-}
+    long                            lPos = GetLastPosition();
+
+    SetInsertionPoint(lPos);
+} // end of wxTextCtrl::SetInsertionPointEnd
 
 long wxTextCtrl::GetInsertionPoint() const
 {
 
 long wxTextCtrl::GetInsertionPoint() const
 {
@@ -441,103 +522,145 @@ long wxTextCtrl::GetLastPosition() const
 
 // If the return values from and to are the same, there is no
 // selection.
 
 // If the return values from and to are the same, there is no
 // selection.
-void wxTextCtrl::GetSelection(long* from, long* to) const
+void wxTextCtrl::GetSelection(
+  long*                             plFrom
+, long*                             plTo
+) const
 {
 {
-    DWORD dwStart, dwEnd;
-    MPARAM wParam = (MPARAM) (DWORD*) & dwStart; // receives starting position
-    MPARAM lParam = (MPARAM) (DWORD*) & dwEnd;   // receives ending position
+    WXDWORD                         dwPos;
 
 
-//    ::SendMessage(GetHwnd(), EM_GETSEL, wParam, lParam);
-
-    *from = dwStart;
-    *to = dwEnd;
-}
+    if (m_bIsMLE)
+        dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), MLM_QUERYSEL, (MPARAM)MLFQS_MINSEL, 0);
+    else
+    {
+        dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), EM_QUERYSEL, 0, 0);
+    }
+    *plFrom = SHORT1FROMMP((MPARAM)dwPos);  // the first 16 bit value is the min pos
+    *plTo = SHORT2FROMMP((MPARAM)dwPos);  // the first 16 bit value is the min pos
+} // end of wxTextCtrl::GetSelection
 
 bool wxTextCtrl::IsEditable() const
 {
 
 bool wxTextCtrl::IsEditable() const
 {
-// TODO:
-/*
-    long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
-
-    return ((style & ES_READONLY) == 0);
-*/
-    return FALSE;
-}
+    if (m_bIsMLE)
+        return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYREADONLY, 0, 0)));
+    else
+        return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYREADONLY, 0, 0)));
+} // end of wxTextCtrl::IsEditable
 
 // ----------------------------------------------------------------------------
 // Editing
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // Editing
 // ----------------------------------------------------------------------------
 
-void wxTextCtrl::Replace(long from, long to, const wxString& value)
+void wxTextCtrl::Replace(
+  long                              lFrom
+, long                              lTo
+, const wxString&                   rsValue
+)
 {
 #if wxUSE_CLIPBOARD
 {
 #if wxUSE_CLIPBOARD
-    HWND hWnd = GetHwnd();
-    long fromChar = from;
-    long toChar = to;
+    HWND                            hWnd      = GetHwnd();
+    long                            lFromChar = lFrom;
+    long                            lToChar   = lTo;
 
 
+    //
     // Set selection and remove it
     // Set selection and remove it
-//    SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
-//    SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
+    //
+    if (m_bIsMLE)
+    {
+        ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
+        ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
+    }
+    else
+    {
+        ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
+        ::WinSendMsg(hWnd, EM_CUT, 0, 0);
+    }
 
 
+    //
     // Now replace with 'value', by pasting.
     // Now replace with 'value', by pasting.
-    wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)value, 0, 0);
+    //
+    wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)rsValue, 0, 0);
 
     // Paste into edit control
 
     // Paste into edit control
-//    SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L);
+    if (m_bIsMLE)
+        ::WinSendMsg(hWnd, MLM_PASTE, (MPARAM)0, (MPARAM)0);
+    else
+        ::WinSendMsg(hWnd, EM_PASTE, (MPARAM)0, (MPARAM)0);
 #else
     wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
 #endif
 #else
     wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
 #endif
-}
+}  // end of wxTextCtrl::Replace
 
 
-void wxTextCtrl::Remove(long from, long to)
+void wxTextCtrl::Remove(
+  long                              lFrom
+, long                              lTo
+)
 {
 {
-    HWND hWnd = GetHwnd();
-    long fromChar = from;
-    long toChar = to;
+    HWND                            hWnd      = GetHwnd();
+    long                            lFromChar = lFrom;
+    long                            lToChar   = lTo;
 
 
-    // Cut all selected text
-//    SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
-//    SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
-}
+    if (m_bIsMLE)
+    {
+        ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
+        ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
+    }
+    else
+    {
+        ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
+        ::WinSendMsg(hWnd, EM_CUT, 0, 0);
+    }
+} // end of wxTextCtrl::Remove
 
 
-void wxTextCtrl::SetSelection(long from, long to)
+void wxTextCtrl::SetSelection(
+  long                              lFrom
+, long                              lTo
+)
 {
 {
-    HWND hWnd = GetHwnd();
-    long fromChar = from;
-    long toChar = to;
+    HWND                            hWnd = GetHwnd();
+    long                            lFromChar = lFrom;
+    long                            lToChar = lTo;
 
 
-    // if from and to are both -1, it means (in wxWindows) that all text should
+    //
+    // If from and to are both -1, it means (in wxWindows) that all text should
     // be selected. Translate into Windows convention
     // be selected. Translate into Windows convention
-    if ((from == -1) && (to == -1))
+    //
+    if ((lFrom == -1L) && (lTo == -1L))
     {
     {
-      fromChar = 0;
-      toChar = -1;
+        lFromChar = 0L;
+        lToChar   = -1L;
     }
     }
+    if (m_bIsMLE)
+        ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lFromChar, (MPARAM)lToChar);
+    else
+        ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFromChar, (USHORT)lToChar), (MPARAM)0);
+} // end of wxTextCtrl::SetSelection
 
 
-//    SendMessage(hWnd, EM_SETSEL, (WPARAM)fromChar, (LPARAM)toChar);
-//    SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
-}
-
-bool wxTextCtrl::LoadFile(const wxString& file)
+bool wxTextCtrl::LoadFile(
+  const wxString&                   rsFile
+)
 {
 {
-// TODO:
-/*
-    if ( wxTextCtrlBase::LoadFile(file) )
+    if ( wxTextCtrlBase::LoadFile(rsFile) )
     {
     {
-        // update the size limit if needed
+        //
+        // Update the size limit if needed
+        //
         AdjustSpaceLimit();
         AdjustSpaceLimit();
-
         return TRUE;
     }
         return TRUE;
     }
-*/
     return FALSE;
     return FALSE;
-}
+} // end of wxTextCtrl::LoadFile
 
 bool wxTextCtrl::IsModified() const
 {
 
 bool wxTextCtrl::IsModified() const
 {
-//    return (SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0);
-    return FALSE;
-}
+    bool                            bRc;
+
+    if (m_bIsMLE)
+        bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYCHANGED, 0, 0));
+    else
+        bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYCHANGED, 0, 0));
+    return bRc;
+} // end of wxTextCtrl::IsModified
 
 //
 // Makes 'unmodified'
 
 //
 // Makes 'unmodified'
@@ -555,56 +678,104 @@ void wxTextCtrl::DiscardEdits()
 
 int wxTextCtrl::GetNumberOfLines() const
 {
 
 int wxTextCtrl::GetNumberOfLines() const
 {
-//    return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0);
-    return 0;
-}
+    int                             nNumLines;
 
 
-long wxTextCtrl::XYToPosition(long x, long y) const
-{
-    HWND hWnd = GetHwnd();
+    if (m_bIsMLE)
+        nNumLines = (int)::WinSendMsg(GetHwnd(), MLM_QUERYLINECOUNT, 0, 0);
+    else
+        nNumLines = 1;
+    return nNumLines;
+} // end of wxTextCtrl::GetNumberOfLines
 
 
-    // This gets the char index for the _beginning_ of this line
-// TODO:
-/*
-    int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)y, (LPARAM)0);
-    return (long)(x + charIndex);
-*/
-    return 0L;
-}
+long wxTextCtrl::XYToPosition(
+  long                              lX
+, long                              lY
+) const
+{
+    HWND                            hWnd = GetHwnd();
+    long                            lCharIndex = 0L;
+    long                            lLen;
 
 
-bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
+    if (m_bIsMLE)
+    {
+        lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
+        lCharIndex = ((lLen * lY) + lX);
+    }
+    else
+        lCharIndex = lX;
+    return lCharIndex;
+} // end of wxTextCtrl::XYToPosition
+
+bool wxTextCtrl::PositionToXY(
+  long                              lPos
+, long*                             plX
+, long*                             plY
+) const
 {
 {
-    HWND hWnd = GetHwnd();
+    HWND                            hWnd = GetHwnd();
+    long                            nLineNo = -1;
+    long                            lCharIndex = 0;
 
 
-    // This gets the line number containing the character
-    int lineNo = -1;
-//    lineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0);
+    if (m_bIsMLE)
+        nLineNo = (long)::WinSendMsg(hWnd, MLM_LINEFROMCHAR, (MPARAM)lPos, 0);
+    else
+        nLineNo = 0;
 
 
-    if ( lineNo == -1 )
+    if (nLineNo == -1)
     {
         // no such line
         return FALSE;
     }
 
     {
         // no such line
         return FALSE;
     }
 
+    //
     // This gets the char index for the _beginning_ of this line
     // This gets the char index for the _beginning_ of this line
-    int charIndex = 0; // TODO: (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0);
-    if ( charIndex == -1 )
+    //
+    long                            lLineWidth;
+
+    if (m_bIsMLE)
+    {
+        lLineWidth = (long)::WinSendMsg(hWnd, MLM_QUERYLINELENGTH, (MPARAM)0, (MPARAM)0);
+        lCharIndex = (nLineNo + 1) * lLineWidth;
+    }
+    else
+    {
+        WNDPARAMS                   vParams;
+
+        vParams.fsStatus = WPM_CCHTEXT;
+        if (::WinSendMsg( hWnd
+                         ,WM_QUERYWINDOWPARAMS
+                         ,&vParams
+                         ,0
+                        ))
+        {
+            lCharIndex = vParams.cchText;
+        }
+        else
+            lCharIndex = 32;
+    }
+
+    if (lCharIndex == -1)
     {
         return FALSE;
     }
 
     {
         return FALSE;
     }
 
-    // The X position must therefore be the different between pos and charIndex
-    if ( x )
-        *x = (long)(pos - charIndex);
-    if ( y )
-        *y = (long)lineNo;
+    //
+    // The X position must therefore be the difference between pos and charIndex
+    //
+    if (plX)
+        *plX = lPos - lCharIndex;
+    if (plY)
+        *plY = nLineNo;
 
     return TRUE;
 
     return TRUE;
-}
+} // end of wxTextCtrl::PositionToXY
 
 
-void wxTextCtrl::ShowPosition(long pos)
+void wxTextCtrl::ShowPosition(
+  long                              lPos
+)
 {
 {
-    HWND hWnd = GetHwnd();
+    HWND                            hWnd = GetHwnd();
+    long                            lCurrentLineLineNo = 0L;
 
     // To scroll to a position, we pass the number of lines and characters
     // to scroll *by*. This means that we need to:
 
     // To scroll to a position, we pass the number of lines and characters
     // to scroll *by*. This means that we need to:
@@ -613,22 +784,23 @@ void wxTextCtrl::ShowPosition(long pos)
     // (3) Scroll by (pos - current).
     // For now, ignore the horizontal scrolling.
 
     // (3) Scroll by (pos - current).
     // For now, ignore the horizontal scrolling.
 
+    //
     // Is this where scrolling is relative to - the line containing the caret?
     // Or is the first visible line??? Try first visible line.
     // Is this where scrolling is relative to - the line containing the caret?
     // Or is the first visible line??? Try first visible line.
-//    int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
-
-// TODO:
-/*
-    int currentLineLineNo = (int)SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L);
-
-    int specifiedLineLineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L);
-
-    int linesToScroll = specifiedLineLineNo - currentLineLineNo;
+    //
+    if (m_bIsMLE)
+    {
+        //
+        // In PM this is the actual char position
+        //
+        lCurrentLineLineNo = (long)::WinSendMsg(hWnd, MLM_QUERYFIRSTCHAR, (MPARAM)0, (MPARAM)0);
 
 
-    if (linesToScroll != 0)
-      (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll);
-*/
-}
+        //
+        // This will cause a scroll to the selected position
+        //
+        ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lCurrentLineLineNo, (MPARAM)lCurrentLineLineNo);
+    }
+} // end of wxTextCtrl::ShowPosition
 
 int wxTextCtrl::GetLineLength(
   long                              lLineNo
 
 int wxTextCtrl::GetLineLength(
   long                              lLineNo
@@ -655,22 +827,54 @@ int wxTextCtrl::GetLineLength(
             lLen = 32;
     }
     return lLen;
             lLen = 32;
     }
     return lLen;
-} // end of
+} // end ofwxTextCtrl::GetLineLength
 
 
-wxString wxTextCtrl::GetLineText(long lineNo) const
+wxString wxTextCtrl::GetLineText(
+  long                              lLineNo
+) const
 {
 {
-    size_t len = (size_t)GetLineLength(lineNo) + 1;
-    char *buf = (char *)malloc(len);
-    *(WORD *)buf = len;
-    int noChars = 0; // TODO:(int)SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
-    buf[noChars] = 0;
+    long                            lLen = (long)GetLineLength((long)lLineNo) + 1;
+    wxString                        sStr;
+    char*                           zBuf;
+
+    //
+    // There must be at least enough place for the length WORD in the
+    // buffer
+    //
+    lLen += sizeof(WORD);
+    zBuf = new char[lLen];
+    if (m_bIsMLE)
+    {
+        long                        lIndex;
+        long                        lBuflen;
+        long                        lCopied;
 
 
-    wxString str(buf);
+        lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
+        lIndex = lLen * lLineNo;
 
 
-    free(buf);
+        ::WinSendMsg(GetHwnd(), MLM_SETSEL, (MPARAM)lIndex, (MPARAM)lIndex);
+        ::WinSendMsg(GetHwnd(), MLM_SETIMPORTEXPORT, MPFROMP(zBuf), MPFROMSHORT((USHORT)sizeof(zBuf)));
+        lBuflen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYFORMATTEXTLENGTH, MPFROMLONG(lIndex), MPFROMLONG(-1));
+        lCopied = (long)::WinSendMsg(GetHwnd(), MLM_EXPORT, MPFROMP(&lIndex), MPFROMP(&lBuflen));
+        zBuf[lCopied] = '\0';
+    }
+    else
+    {
+        WNDPARAMS                   vParams;
 
 
-    return str;
-}
+        vParams.fsStatus = WPM_CCHTEXT;
+        if (::WinSendMsg( GetHwnd()
+                         ,WM_QUERYWINDOWPARAMS
+                         ,&vParams
+                         ,0
+                        ))
+         memcpy(zBuf, vParams.pszText, vParams.cchText);
+         zBuf[vParams.cchText] = '\0';
+     }
+     sStr = zBuf;
+     delete [] zBuf;
+     return sStr;
+} // end of wxTextCtrl::GetLineText
 
 // ----------------------------------------------------------------------------
 // Undo/redo
 
 // ----------------------------------------------------------------------------
 // Undo/redo
@@ -680,18 +884,21 @@ void wxTextCtrl::Undo()
 {
     if (CanUndo())
     {
 {
     if (CanUndo())
     {
-//        ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
+        if (m_bIsMLE)
+            ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
+        // Simple entryfields cannot be undone
     }
     }
-}
+} // end of wxTextCtrl::Undo
 
 void wxTextCtrl::Redo()
 {
     if (CanRedo())
     {
 
 void wxTextCtrl::Redo()
 {
     if (CanRedo())
     {
-        // Same as Undo, since Undo undoes the undo, i.e. a redo.
-//        ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
+        if (m_bIsMLE)
+            ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
+        // Simple entryfields cannot be undone
     }
     }
-}
+} // end of wxTextCtrl::Redo
 
 bool wxTextCtrl::CanUndo() const
 {
 
 bool wxTextCtrl::CanUndo() const
 {
@@ -719,51 +926,72 @@ bool wxTextCtrl::CanRedo() const
 // implemenation details
 // ----------------------------------------------------------------------------
 
 // implemenation details
 // ----------------------------------------------------------------------------
 
-void wxTextCtrl::Command(wxCommandEvent & event)
+void wxTextCtrl::Command(
+  wxCommandEvent&                   rEvent
+)
 {
 {
-    SetValue(event.GetString());
-    ProcessCommand (event);
-}
+    SetValue(rEvent.GetString());
+    ProcessCommand (rEvent);
+} // end of wxTextCtrl::Command
 
 
-void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
+void wxTextCtrl::OnDropFiles(
+  wxDropFilesEvent&                 rEvent
+)
 {
     // By default, load the first file into the text window.
 {
     // By default, load the first file into the text window.
-    if (event.GetNumberOfFiles() > 0)
+    if (rEvent.GetNumberOfFiles() > 0)
     {
     {
-        LoadFile(event.GetFiles()[0]);
+        LoadFile(rEvent.GetFiles()[0]);
     }
     }
-}
-
-WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
-                                WXUINT message, WXWPARAM wParam,
-                                WXLPARAM lParam)
+} // end of wxTextCtrl::OnDropFiles
+
+WXHBRUSH wxTextCtrl::OnCtlColor(
+  WXHDC                             hWxDC
+, WXHWND                            hWnd
+, WXUINT                            uCtlColor
+, WXUINT                            uMessage
+, WXWPARAM                          wParam
+, WXLPARAM                          lParam
+)
 {
 {
-    HDC hdc = (HDC)pDC;
-// TODO:
-/*
-    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();
-}
+    HPS                             hPS = (HPS)hWxDC;
+    wxBrush*                        pBrush = NULL;
+    wxColour                        vColBack = GetBackgroundColour();
+    wxColour                        vColFore = GetForegroundColour();
+    wxBrush*                        pBackgroundBrush = wxTheBrushList->FindOrCreateBrush( GetBackgroundColour()
+                                                                                         ,wxSOLID
+                                                                                        );
+
+    if (m_bUseCtl3D)
+    {
+        HBRUSH                      hBrush = NULLHANDLE;
 
 
-void wxTextCtrl::OnChar(wxKeyEvent& event)
+        return hBrush;
+    }
+    if (GetParent()->GetTransparentBackground())
+        ::GpiSetBackMix(hPS, BM_LEAVEALONE);
+    else
+        ::GpiSetBackMix(hPS, BM_OVERPAINT);
+    if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
+        vColBack = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+    ::GpiSetBackColor(hPS, vColBack.GetPixel());
+    ::GpiSetColor(hPS, vColFore.GetPixel());
+    return (WXHBRUSH)pBackgroundBrush->GetResourceHandle();
+} // end of wxTextCtrl::OnCtlColor
+
+void wxTextCtrl::OnChar(
+  wxKeyEvent&                       rEvent
+)
 {
 {
-    switch ( event.KeyCode() )
+    switch (rEvent.KeyCode())
     {
     {
-// TODO:
-/*
         case WXK_RETURN:
             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
         case WXK_RETURN:
             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
-                wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
-                event.SetEventObject( this );
-                if ( GetEventHandler()->ProcessEvent(event) )
+                wxCommandEvent      vEvent(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
+
+                vEvent.SetEventObject(this);
+                if ( GetEventHandler()->ProcessEvent(vEvent))
                     return;
             }
             //else: multiline controls need Enter for themselves
                     return;
             }
             //else: multiline controls need Enter for themselves
@@ -779,75 +1007,72 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
             // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
             //     handled by Windows
             {
             // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
             //     handled by Windows
             {
-                wxNavigationKeyEvent eventNav;
-                eventNav.SetDirection(!event.ShiftDown());
-                eventNav.SetWindowChange(FALSE);
-                eventNav.SetEventObject(this);
+                wxNavigationKeyEvent    vEventNav;
+
+                vEventNav.SetDirection(!rEvent.ShiftDown());
+                vEventNav.SetWindowChange(FALSE);
+                vEventNav.SetEventObject(this);
 
 
-                if ( GetEventHandler()->ProcessEvent(eventNav) )
+                if ( GetEventHandler()->ProcessEvent(vEventNav) )
                     return;
             }
             break;
                     return;
             }
             break;
-*/
-        default:
-            event.Skip();
-            return;
     }
     }
+    rEvent.Skip();
+} // end of wxTextCtrl::OnChar
 
 
-    // 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
-    event.Skip();
-}
-
-bool wxTextCtrl::OS2Command(WXUINT param, WXWORD WXUNUSED(id))
+bool wxTextCtrl::OS2Command(
+  WXUINT                            uParam
+, WXWORD                            WXUNUSED(vId)
+)
 {
 {
-    switch (param)
+    switch (uParam)
     {
     {
-// TODO:
-/*
         case EN_SETFOCUS:
         case EN_KILLFOCUS:
             {
         case EN_SETFOCUS:
         case EN_KILLFOCUS:
             {
-                wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
-                        : wxEVT_SET_FOCUS,
-                        m_windowId);
-                event.SetEventObject( this );
-                GetEventHandler()->ProcessEvent(event);
+                wxFocusEvent        vEvent( uParam == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
+                                                                   : wxEVT_SET_FOCUS
+                                           ,m_windowId
+                                          );
+
+                vEvent.SetEventObject(this);
+                GetEventHandler()->ProcessEvent(vEvent);
             }
             break;
 
         case EN_CHANGE:
             {
             }
             break;
 
         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 );
-                ProcessCommand(event);
+                wxCommandEvent      vEvent( wxEVT_COMMAND_TEXT_UPDATED
+                                           ,m_windowId
+                                          );
+
+                InitCommandEvent(vEvent);
+                vEvent.SetString((char*)GetValue().c_str());
+                ProcessCommand(vEvent);
             }
             break;
 
             }
             break;
 
-        case EN_ERRSPACE:
-            // the text size limit has been hit - increase it
+        case EN_OVERFLOW:
+            //
+            // The text size limit has been hit - increase it
+            //
             AdjustSpaceLimit();
             break;
 
             AdjustSpaceLimit();
             break;
 
-            // the other notification messages are not processed
-        case EN_UPDATE:
-        case EN_MAXTEXT:
-        case EN_HSCROLL:
-        case EN_VSCROLL:
-*/
+        case EN_SCROLL:
+        case EN_INSERTMODETOGGLE:
+        case EN_MEMERROR:
+            return FALSE;
         default:
             return FALSE;
     }
 
         default:
             return FALSE;
     }
 
-    // processed
+    //
+    // Processed
+    //
     return TRUE;
     return TRUE;
-}
+} // end of wxTextCtrl::OS2Command
 
 void wxTextCtrl::AdjustSpaceLimit()
 {
 
 void wxTextCtrl::AdjustSpaceLimit()
 {
@@ -899,78 +1124,166 @@ void wxTextCtrl::AdjustSpaceLimit()
 
 bool wxTextCtrl::AcceptsFocus() const
 {
 
 bool wxTextCtrl::AcceptsFocus() const
 {
-    // we don't want focus if we can't be edited
+    //
+    // We don't want focus if we can't be edited
+    //
     return IsEditable() && wxControl::AcceptsFocus();
     return IsEditable() && wxControl::AcceptsFocus();
-}
+} // end of wxTextCtrl::Command
 
 wxSize wxTextCtrl::DoGetBestSize() const
 {
 
 wxSize wxTextCtrl::DoGetBestSize() const
 {
-    int cx, cy;
-    wxGetCharSize(GetHWND(), &cx, &cy, (wxFont*)&GetFont());
+    int                             nCx;
+    int                             nCy;
 
 
-    int wText = DEFAULT_ITEM_WIDTH;
+    wxGetCharSize(GetHWND(), &nCx, &nCy, (wxFont*)&GetFont());
 
 
-    int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
-    if ( m_windowStyle & wxTE_MULTILINE )
+    int                             wText = DEFAULT_ITEM_WIDTH;
+    int                             hText = (EDIT_HEIGHT_FROM_CHAR_HEIGHT(nCy) * .8);
+
+    if (m_windowStyle & wxTE_MULTILINE)
     {
         hText *= wxMin(GetNumberOfLines(), 5);
     }
     //else: for single line control everything is ok
     {
         hText *= wxMin(GetNumberOfLines(), 5);
     }
     //else: for single line control everything is ok
-
     return wxSize(wText, hText);
     return wxSize(wText, hText);
-}
+} // end of 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&                   rEvent
+)
 {
     Cut();
 {
     Cut();
-}
+} // end of wxTextCtrl::OnCut
 
 
-void wxTextCtrl::OnCopy(wxCommandEvent& event)
+void wxTextCtrl::OnCopy(
+  wxCommandEvent&                   rEvent
+)
 {
     Copy();
 {
     Copy();
-}
+} // end of wxTextCtrl::OnCopy
 
 
-void wxTextCtrl::OnPaste(wxCommandEvent& event)
+void wxTextCtrl::OnPaste(
+  wxCommandEvent&                   rEvent
+)
 {
     Paste();
 {
     Paste();
-}
+} // end of wxTextCtrl::OnPaste
 
 
-void wxTextCtrl::OnUndo(wxCommandEvent& event)
+void wxTextCtrl::OnUndo(
+  wxCommandEvent&                   rEvent
+)
 {
     Undo();
 {
     Undo();
-}
+} // end of wxTextCtrl::OnUndo
 
 
-void wxTextCtrl::OnRedo(wxCommandEvent& event)
+void wxTextCtrl::OnRedo(
+  wxCommandEvent&                   rEvent
+)
 {
     Redo();
 {
     Redo();
-}
+} // end of wxTextCtrl::OnRedo
 
 
-void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+void wxTextCtrl::OnUpdateCut(
+  wxUpdateUIEvent&                  rEvent
+)
 {
 {
-    event.Enable( CanCut() );
-}
+    rEvent.Enable(CanCut());
+} // end of wxTextCtrl::OnUpdateCut
 
 
-void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+void wxTextCtrl::OnUpdateCopy(
+  wxUpdateUIEvent&                  rEvent
+)
 {
 {
-    event.Enable( CanCopy() );
-}
+    rEvent.Enable(CanCopy());
+} // end of wxTextCtrl::OnUpdateCopy
 
 
-void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+void wxTextCtrl::OnUpdatePaste(
+  wxUpdateUIEvent&                  rEvent
+)
 {
 {
-    event.Enable( CanPaste() );
-}
+    rEvent.Enable(CanPaste());
+} // end of wxTextCtrl::OnUpdatePaste
+
+void wxTextCtrl::OnUpdateUndo(
+  wxUpdateUIEvent&                  rEvent
+)
+{
+    rEvent.Enable(CanUndo());
+} // end of wxTextCtrl::OnUpdateUndo
 
 
-void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+void wxTextCtrl::OnUpdateRedo(
+  wxUpdateUIEvent&                  rEvent
+)
 {
 {
-    event.Enable( CanUndo() );
-}
+    rEvent.Enable(CanRedo());
+} // end of wxTextCtrl::OnUpdateRedo
 
 
-void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+bool wxTextCtrl::SetBackgroundColour(
+  const wxColour&                   rColour
+)
 {
 {
-    event.Enable( CanRedo() );
-}
+    if (m_bIsMLE)
+        ::WinSendMsg(GetHwnd(), MLM_SETBACKCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
+    return TRUE;
+} // end of wxTextCtrl::SetBackgroundColour
+
+bool wxTextCtrl::SetForegroundColour(
+  const wxColour&                   rColour
+)
+{
+    if (m_bIsMLE)
+        ::WinSendMsg(GetHwnd(), MLM_SETTEXTCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
+    return TRUE;
+} // end of wxTextCtrl::SetForegroundColour
+
+bool wxTextCtrl::SetStyle(
+  long                              lStart
+, long                              lEnd
+, const wxTextAttr&                 rStyle
+)
+{
+    HWND                            hWnd = GetHwnd();
+
+    if (lStart > lEnd)
+    {
+        long                        lTmp = lStart;
+
+        lStart = lEnd;
+        lEnd   = lTmp;
+    }
+
+    //
+    // We can only change the format of the selection, so select the range we
+    // want and restore the old selection later
+    //
+    long                            lStartOld;
+    long                            lEndOld;
+
+    GetSelection( &lStartOld
+                 ,&lEndOld
+                );
+
+    //
+    // But do we really have to change the selection?
+    //
+    bool                            bChangeSel = lStart != lStartOld ||
+                                                 lEnd != lEndOld;
+
+    if (bChangeSel)
+    {
+        if (m_bIsMLE)
+            ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lStart, (USHORT)lEnd), 0);
+        else
+            ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lStart, (USHORT)lEnd), 0);
+    }
+
+    //
+    // TODO:: finish this part
+    //
+    return TRUE;
+} // end of wxTextCtrl::SetStyle
 
 
wxWidgets (Impactor)