Updated date

[wxWidgets.git] / src / msw / textctrl.cpp

diff --git a/src/msw/textctrl.cpp b/src/msw/textctrl.cpp
index 12716ffeb5165b8e13154da8b699a7e2f0b35aaa..9cb0a4f03ae5dfbd4f4f09edca43144c56b19e94 100644 (file)
--- a/src/msw/textctrl.cpp
+++ b/src/msw/textctrl.cpp
@@ -177,7 +177,9 @@ void wxTextCtrl::Init()
 {
 #if wxUSE_RICHEDIT
     m_verRichEdit = 0;
 {
 #if wxUSE_RICHEDIT
     m_verRichEdit = 0;

-#endif
+
+    m_suppressNextUpdate = FALSE;
+#endif // wxUSE_RICHEDIT

 }
 
 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 }
 
 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,


@@ -300,10 +302,17 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 #if wxUSE_RICHEDIT
     if ( IsRich() )
     {
 #if wxUSE_RICHEDIT
     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;
 
         {
             mask |= ENM_LINK;
 


@@ -353,6 +362,10 @@ void wxTextCtrl::AdoptAttributesFromHWND()
         m_windowStyle |= wxTE_READONLY;
     if (style & ES_WANTRETURN)
         m_windowStyle |= wxTE_PROCESS_ENTER;
         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
 }
 
 WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const


@@ -401,6 +414,12 @@ WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const
     if ( style & wxTE_NOHIDESEL )
         msStyle |= ES_NOHIDESEL;
 
     if ( style & wxTE_NOHIDESEL )
         msStyle |= ES_NOHIDESEL;
 

+    if ( style & wxTE_CENTRE )
+        msStyle |= ES_CENTER;
+
+    if ( style & wxTE_RIGHT )
+        msStyle |= ES_RIGHT;
+

     return msStyle;
 }
 
     return msStyle;
 }
 


@@ -544,6 +563,15 @@ DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb)
 
 extern long wxEncodingToCodepage(wxFontEncoding encoding); // from utils.cpp
 
 
 extern long wxEncodingToCodepage(wxFontEncoding encoding); // from utils.cpp
 

+#ifdef __WXWINE__
+bool wxTextCtrl::StreamIn(const wxString& value,
+                          wxFontEncoding WXUNUSED(encoding),
+                          bool selectionOnly)
+{
+    return FALSE;
+}
+#else
+

 #if wxUSE_UNICODE_MSLU
 bool wxTextCtrl::StreamIn(const wxString& value,
                           wxFontEncoding WXUNUSED(encoding),
 #if wxUSE_UNICODE_MSLU
 bool wxTextCtrl::StreamIn(const wxString& value,
                           wxFontEncoding WXUNUSED(encoding),


@@ -608,6 +636,9 @@ bool wxTextCtrl::StreamIn(const wxString& value,
     return TRUE;
 }
 
     return TRUE;
 }
 

+#endif
+    // __WXWINE__
+ 

 #endif // wxUSE_RICHEDIT
 
 void wxTextCtrl::WriteText(const wxString& value)
 #endif // wxUSE_RICHEDIT
 
 void wxTextCtrl::WriteText(const wxString& value)


@@ -645,7 +676,7 @@ void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly)
         }
 #endif // wxUSE_UNICODE_MSLU
 
         }
 #endif // wxUSE_UNICODE_MSLU
 

-#if !wxUSE_UNICODE
+#if !wxUSE_UNICODE && !defined(__WXWINE__)

         // 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 )
         // 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 )


@@ -669,12 +700,18 @@ void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly)
     if ( !done )
 #endif // wxUSE_RICHEDIT
     {
     if ( !done )
 #endif // wxUSE_RICHEDIT
     {

-        if ( !selectionOnly )
+#if wxUSE_RICHEDIT
+        // rich edit text control sends us 2 EN_CHANGE events when we send
+        // WM_SETTEXT to it, we have to suppress one of them to make wxTextCtrl
+        // behaviour consistent
+        if ( IsRich() )

         {
         {

-            SetSelection(-1, -1);
+            m_suppressNextUpdate = TRUE;

         }
         }

+#endif // wxUSE_RICHEDIT

 
 

-        ::SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
+        ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL : WM_SETTEXT,
+                      0, (LPARAM)valueDos.c_str());

     }
 
     AdjustSpaceLimit();
     }
 
     AdjustSpaceLimit();


@@ -690,8 +727,37 @@ void wxTextCtrl::AppendText(const wxString& text)
 void wxTextCtrl::Clear()
 {
     ::SetWindowText(GetHwnd(), wxT(""));
 void wxTextCtrl::Clear()
 {
     ::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
+        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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Clipboard operations
 // ----------------------------------------------------------------------------


@@ -844,6 +910,12 @@ void wxTextCtrl::GetSelection(long* from, long* to) const
 
 bool wxTextCtrl::IsEditable() 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;
     long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
 
     return (style & ES_READONLY) == 0;


@@ -1127,24 +1199,42 @@ bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg)
         }
         else // no Alt
         {
         }
         else // no Alt
         {

-            if ( wxIsCtrlDown() )
+            // 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 )

             {
             {

-                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;
+                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;
+                    }

             }
         }
     }
             }
         }
     }


@@ -1192,33 +1282,75 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
 
 long wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 {
 
 long wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 {

-    // we always want the characters and the arrows
+    long lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
+

     if ( nMsg == WM_GETDLGCODE )
     {
     if ( nMsg == WM_GETDLGCODE )
     {

-        // we always want the chars and the arrows
-        long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
+        if ( IsEditable() )
+        {
+            // we always want the chars and the arrows
+            long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
+
+            // 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 <Return> 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
+        {
+            // when the control can't be edited by user, it doesn't need any
+            // extra keys changing its contents at all -- but it still needs
+            // the arrows to allow navigating in it
+            //
+            // 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 = DLGC_WANTARROWS;
+        }
+    }
+
+    return lRc;
+}
+
+// ----------------------------------------------------------------------------
+// text control event processing
+// ----------------------------------------------------------------------------

 
 

-        // 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 )
-            lDlgCode |= DLGC_WANTMESSAGE;
-        if ( m_windowStyle & wxTE_PROCESS_TAB )
-            lDlgCode |= DLGC_WANTTAB;
+bool wxTextCtrl::SendUpdateEvent()
+{
+    // is event reporting suspended?
+    if ( m_suppressNextUpdate )
+    {
+        // do process the next one
+        m_suppressNextUpdate = FALSE;

 
 

-        return lDlgCode;
+        return FALSE;

     }
 
     }
 

-    return wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
+    wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
+    InitCommandEvent(event);
+    event.SetString(GetValue());
+
+    return ProcessCommand(event);

 }
 
 bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 {
 }
 
 bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 {

-    switch (param)
+    switch ( param )

     {
         case EN_SETFOCUS:
         case EN_KILLFOCUS:
     {
         case EN_SETFOCUS:
         case EN_KILLFOCUS:


@@ -1226,22 +1358,17 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
                                                          : wxEVT_SET_FOCUS,
                                    m_windowId);
                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
                                                          : wxEVT_SET_FOCUS,
                                    m_windowId);

-                event.SetEventObject( this );
+                event.SetEventObject(this);

                 GetEventHandler()->ProcessEvent(event);
             }
             break;
 
         case EN_CHANGE:
                 GetEventHandler()->ProcessEvent(event);
             }
             break;
 
         case EN_CHANGE:

-            {
-                wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
-                InitCommandEvent(event);
-                event.SetString(GetValue());
-                ProcessCommand(event);
-            }
+            SendUpdateEvent();

             break;
 
         case EN_MAXTEXT:
             break;
 
         case EN_MAXTEXT:

-            // the text size limit has been hit - increase it
+            // the text size limit has been hit -- try to increase it

             if ( !AdjustSpaceLimit() )
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId);
             if ( !AdjustSpaceLimit() )
             {
                 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId);


@@ -1251,12 +1378,7 @@ bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
             }
             break;
 
             }
             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;
     }
         default:
             return FALSE;
     }


@@ -1469,66 +1591,99 @@ void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
 // EN_LINK processing
 // ----------------------------------------------------------------------------
 
 // EN_LINK processing
 // ----------------------------------------------------------------------------
 

-bool wxTextCtrl::MSWOnNotify(int WXUNUSED(idCtrl), WXLPARAM lParam, WXLPARAM *result)
+bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)

 {
 {

+#ifndef __WXWINE__

     NMHDR *hdr = (NMHDR* )lParam;
     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;
+    }
+#endif
+    
+    // not processed, leave it to the base class
+    return wxTextCtrlBase::MSWOnNotify(idCtrl, lParam, result);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1579,8 +1734,13 @@ bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
 // styling support for rich edit controls
 // ----------------------------------------------------------------------------
 
 // styling support for rich edit controls
 // ----------------------------------------------------------------------------
 

+#if wxUSE_RICHEDIT
+

 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 {
 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 {

+#ifdef __WXWINE__
+    return FALSE;
+#else

     if ( !IsRich() )
     {
         // can't do it with normal text control
     if ( !IsRich() )
     {
         // can't do it with normal text control


@@ -1710,8 +1870,24 @@ bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
     }
 
     return ok;
     }
 
     return ok;

+#endif
+}
+
+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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxRichEditModule
 // ----------------------------------------------------------------------------