fixing osx_cocoa

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

diff --git a/src/msw/textentry.cpp b/src/msw/textentry.cpp
index f2d8eafd5671d00d1a373a5b41511fec6670ce62..77bc4cd1bce5f890efbdfed2fadad128046e2d5d 100644 (file)
--- a/src/msw/textentry.cpp
+++ b/src/msw/textentry.cpp
@@ -34,6 +34,8 @@
 #include "wx/textcompleter.h"
 #include "wx/dynlib.h"
 
 #include "wx/textcompleter.h"
 #include "wx/dynlib.h"
 

+#include <initguid.h>
+

 #include "wx/msw/private.h"
 
 #if wxUSE_UXTHEME
 #include "wx/msw/private.h"
 
 #if wxUSE_UXTHEME


@@ -43,7 +45,7 @@
 #define GetEditHwnd() ((HWND)(GetEditHWND()))
 
 // ----------------------------------------------------------------------------
 #define GetEditHwnd() ((HWND)(GetEditHWND()))
 
 // ----------------------------------------------------------------------------

-// wxIEnumString implements IEnumString interface
+// Classes used by auto-completion implementation.

 // ----------------------------------------------------------------------------
 
 // standard VC6 SDK (WINVER == 0x0400) does not know about IAutoComplete
 // ----------------------------------------------------------------------------
 
 // standard VC6 SDK (WINVER == 0x0400) does not know about IAutoComplete


@@ -55,11 +57,14 @@
 
 #include "wx/msw/ole/oleutils.h"
 #include <shldisp.h>
 
 #include "wx/msw/ole/oleutils.h"
 #include <shldisp.h>

-#include <shobjidl.h>

 
 #if defined(__MINGW32__) || defined (__WATCOMC__) || defined(__CYGWIN__)
     // needed for IID_IAutoComplete, IID_IAutoComplete2 and ACO_AUTOSUGGEST
     #include <shlguid.h>
 
 #if defined(__MINGW32__) || defined (__WATCOMC__) || defined(__CYGWIN__)
     // needed for IID_IAutoComplete, IID_IAutoComplete2 and ACO_AUTOSUGGEST
     #include <shlguid.h>

+
+    #ifndef ACO_AUTOAPPEND
+        #define ACO_AUTOAPPEND 0x02
+    #endif

 #endif
 
 #ifndef ACO_UPDOWNKEYDROPSLIST
 #endif
 
 #ifndef ACO_UPDOWNKEYDROPSLIST


@@ -70,24 +75,91 @@
     #define SHACF_FILESYS_ONLY 0x00000010
 #endif
 
     #define SHACF_FILESYS_ONLY 0x00000010
 #endif
 

-DEFINE_GUID(CLSID_AutoComplete,
+namespace
+{
+
+// Normally this interface and its IID are defined in shobjidl.h header file
+// included in the platform SDK but MinGW and Cygwin don't have it so redefine
+// the interface ourselves and, as long as we do it all, do it for all
+// compilers to ensure we have the same behaviour for all of them and to avoid
+// the need to check for concrete compilers and maybe even their versions.
+class IAutoCompleteDropDown : public IUnknown
+{
+public:
+    virtual HRESULT wxSTDCALL GetDropDownStatus(DWORD *, LPWSTR *) = 0;
+    virtual HRESULT wxSTDCALL ResetEnumerator() = 0;
+};
+
+DEFINE_GUID(wxIID_IAutoCompleteDropDown,
+    0x3cd141f4, 0x3c6a, 0x11d2, 0xbc, 0xaa, 0x00, 0xc0, 0x4f, 0xd9, 0x29, 0xdb);
+
+DEFINE_GUID(wxCLSID_AutoComplete,

     0x00bb2763, 0x6a77, 0x11d0, 0xa5, 0x35, 0x00, 0xc0, 0x4f, 0xd7, 0xd0, 0x62);
 
     0x00bb2763, 0x6a77, 0x11d0, 0xa5, 0x35, 0x00, 0xc0, 0x4f, 0xd7, 0xd0, 0x62);
 

+// Small helper class which can be used to ensure thread safety even when
+// wxUSE_THREADS==0 (and hence wxCriticalSection does nothing).
+class CSLock
+{
+public:
+    CSLock(CRITICAL_SECTION& cs) : m_cs(&cs)
+    {
+        ::EnterCriticalSection(m_cs);
+    }
+
+    ~CSLock()
+    {
+        ::LeaveCriticalSection(m_cs);
+    }
+
+private:
+    CRITICAL_SECTION * const m_cs;
+
+    wxDECLARE_NO_COPY_CLASS(CSLock);
+};
+
+} // anonymity namespace
+
+// Implementation of string enumerator used by wxTextAutoCompleteData. This
+// class simply forwards to wxTextCompleter associated with it.
+//
+// Notice that Next() method of this class is called by IAutoComplete
+// background thread and so we must care about thread safety here.

 class wxIEnumString : public IEnumString
 {
 public:
     wxIEnumString()
     {
 class wxIEnumString : public IEnumString
 {
 public:
     wxIEnumString()
     {

-        m_index = 0;
+        Init();

     }
 
     }
 

-    wxIEnumString(const wxIEnumString& other)
-        : m_strings(other.m_strings),
-          m_index(other.m_index)
+    void ChangeCompleter(wxTextCompleter *completer)

     {
     {

+        // Indicate to Next() that it should bail out as soon as possible.
+        {
+            CSLock lock(m_csRestart);
+
+            m_restart = TRUE;
+        }
+
+        // Now try to enter this critical section to ensure that Next() doesn't
+        // use the old pointer any more before changing it (this is vital as
+        // the old pointer will be destroyed after we return).
+        CSLock lock(m_csCompleter);
+
+        m_completer = completer;

     }
 
     }
 

-    DECLARE_IUNKNOWN_METHODS;
+    void UpdatePrefix(const wxString& prefix)
+    {
+        CSLock lock(m_csRestart);
+
+        // We simply store the prefix here and will really update during the
+        // next call to our Next() method as we want to call Start() from the
+        // worker thread to prevent the main UI thread from blocking while the
+        // completions are generated.
+        m_prefix = prefix;
+        m_restart = TRUE;
+    }

 
     virtual HRESULT STDMETHODCALLTYPE Next(ULONG celt,
                                            LPOLESTR *rgelt,
 
     virtual HRESULT STDMETHODCALLTYPE Next(ULONG celt,
                                            LPOLESTR *rgelt,


@@ -102,12 +174,22 @@ public:
 
         *pceltFetched = 0;
 
 
         *pceltFetched = 0;
 

-        for ( const unsigned count = m_strings.size(); celt--; ++m_index )
+        CSLock lock(m_csCompleter);
+
+        if ( !RestartIfNeeded() )
+            return S_FALSE;
+
+        while ( celt-- )

         {
         {

-            if ( m_index == count )
+            // Stop iterating if we need to update completions anyhow.
+            if ( m_restart )

                 return S_FALSE;
 
                 return S_FALSE;
 

-            const wxWX2WCbuf wcbuf = m_strings[m_index].wc_str();
+            const wxString s = m_completer->GetNext();
+            if ( s.empty() )
+                return S_FALSE;
+
+            const wxWX2WCbuf wcbuf = s.wc_str();

             const size_t size = (wcslen(wcbuf) + 1)*sizeof(wchar_t);
             void *olestr = CoTaskMemAlloc(size);
             if ( !olestr )
             const size_t size = (wcslen(wcbuf) + 1)*sizeof(wchar_t);
             void *olestr = CoTaskMemAlloc(size);
             if ( !olestr )


@@ -125,11 +207,21 @@ public:
 
     virtual HRESULT STDMETHODCALLTYPE Skip(ULONG celt)
     {
 
     virtual HRESULT STDMETHODCALLTYPE Skip(ULONG celt)
     {

-        m_index += celt;
-        if ( m_index > m_strings.size() )
-        {
-            m_index = m_strings.size();
+        if ( !celt )
+            return E_INVALIDARG;
+
+        CSLock lock(m_csCompleter);
+
+        if ( !RestartIfNeeded() )

             return S_FALSE;
             return S_FALSE;

+
+        while ( celt-- )
+        {
+            if ( m_restart )
+                return S_FALSE;
+
+            if ( m_completer->GetNext().empty() )
+                return S_FALSE;

         }
 
         return S_OK;
         }
 
         return S_OK;


@@ -137,7 +229,9 @@ public:
 
     virtual HRESULT STDMETHODCALLTYPE Reset()
     {
 
     virtual HRESULT STDMETHODCALLTYPE Reset()
     {

-        m_index = 0;
+        CSLock lock(m_csRestart);
+
+        m_restart = TRUE;

 
         return S_OK;
     }
 
         return S_OK;
     }


@@ -147,28 +241,100 @@ public:
         if ( !ppEnum )
             return E_POINTER;
 
         if ( !ppEnum )
             return E_POINTER;
 

-        wxIEnumString *e = new wxIEnumString(*this);
+        CSLock lock(m_csCompleter);

 
 

+        wxIEnumString * const e = new wxIEnumString;

         e->AddRef();
         e->AddRef();

+
+        e->ChangeCompleter(m_completer);
+

         *ppEnum = e;
 
         return S_OK;
     }
 
         *ppEnum = e;
 
         return S_OK;
     }
 

+    DECLARE_IUNKNOWN_METHODS;
+

 private:
     // dtor doesn't have to be virtual as we're only ever deleted from our own
     // Release() and are not meant to be derived form anyhow, but making it
     // virtual silences gcc warnings; making it private makes it impossible to
     // (mistakenly) delete us directly instead of calling Release()
 private:
     // dtor doesn't have to be virtual as we're only ever deleted from our own
     // Release() and are not meant to be derived form anyhow, but making it
     // virtual silences gcc warnings; making it private makes it impossible to
     // (mistakenly) delete us directly instead of calling Release()

-    virtual ~wxIEnumString() { }
+    virtual ~wxIEnumString()
+    {
+        ::DeleteCriticalSection(&m_csRestart);
+        ::DeleteCriticalSection(&m_csCompleter);
+    }

 
 

+    // Common part of all ctors.
+    void Init()
+    {
+        ::InitializeCriticalSection(&m_csCompleter);
+        ::InitializeCriticalSection(&m_csRestart);

 
 

-    wxArrayString m_strings;
-    unsigned m_index;
+        m_completer = NULL;
+        m_restart = FALSE;
+    }

 
 

-    friend class wxTextAutoCompleteData;
+    // Restart completions generation if needed. Should be only called from
+    // inside m_csCompleter.
+    //
+    // If false is returned, it means that there are no completions and that
+    // wxTextCompleter::GetNext() shouldn't be called at all.
+    bool RestartIfNeeded()
+    {
+        bool rc = true;
+        for ( ;; )
+        {
+            wxString prefix;
+            LONG restart;
+            {
+                CSLock lock(m_csRestart);
+
+                prefix = m_prefix;
+                restart = m_restart;
+
+                m_restart = FALSE;
+            } // Release m_csRestart before calling Start() to avoid blocking
+              // the main thread in UpdatePrefix() during its execution.
+
+            if ( !restart )
+                break;
+
+            rc = m_completer->Start(prefix);
+        }
+
+        return rc;
+    }

 
 

-    wxDECLARE_NO_ASSIGN_CLASS(wxIEnumString);
+
+    // Critical section protecting m_completer itself. It must be entered when
+    // using the pointer to ensure that we don't continue using a dangling one
+    // after it is destroyed.
+    CRITICAL_SECTION m_csCompleter;
+
+    // The completer we delegate to for the completions generation. It is never
+    // NULL after the initial ChangeCompleter() call.
+    wxTextCompleter *m_completer;
+
+
+    // Critical section m_prefix and m_restart. It should be only entered for
+    // short periods of time, i.e. we shouldn't call any wxTextCompleter
+    // methods from inside, to prevent the main thread from blocking on it in
+    // UpdatePrefix().
+    CRITICAL_SECTION m_csRestart;
+
+    // If m_restart is true, we need to call wxTextCompleter::Start() with the
+    // given prefix to restart generating the completions.
+    wxString m_prefix;
+
+    // Notice that we use LONG and not bool here to ensure that reading this
+    // value is atomic (32 bit reads are atomic operations under all Windows
+    // versions but reading bool isn't necessarily).
+    LONG m_restart;
+
+
+    wxDECLARE_NO_COPY_CLASS(wxIEnumString);

 };
 
 BEGIN_IID_TABLE(wxIEnumString)
 };
 
 BEGIN_IID_TABLE(wxIEnumString)


@@ -179,8 +345,8 @@ END_IID_TABLE;
 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumString)
 
 
 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumString)
 
 

-// This class gathers the auto-complete-related we use. It is allocated on
-// demand by wxTextEntry when AutoComplete() is called.
+// This class gathers the all auto-complete-related stuff we use. It is
+// allocated on demand by wxTextEntry when AutoComplete() is called.

 class wxTextAutoCompleteData wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS
 {
 public:
 class wxTextAutoCompleteData wxBIND_OR_CONNECT_HACK_ONLY_BASE_CLASS
 {
 public:


@@ -192,6 +358,8 @@ public:
         m_autoComplete = NULL;
         m_autoCompleteDropDown = NULL;
         m_enumStrings = NULL;
         m_autoComplete = NULL;
         m_autoCompleteDropDown = NULL;
         m_enumStrings = NULL;

+
+        m_fixedCompleter = NULL;

         m_customCompleter = NULL;
 
         m_connectedCharEvent = false;
         m_customCompleter = NULL;
 
         m_connectedCharEvent = false;


@@ -201,7 +369,7 @@ public:
         // apparently.
         HRESULT hr = CoCreateInstance
                      (
         // apparently.
         HRESULT hr = CoCreateInstance
                      (

-                        CLSID_AutoComplete,
+                        wxCLSID_AutoComplete,

                         NULL,
                         CLSCTX_INPROC_SERVER,
                         IID_IAutoComplete,
                         NULL,
                         CLSCTX_INPROC_SERVER,
                         IID_IAutoComplete,


@@ -236,7 +404,7 @@ public:
         // provided IAutoComplete always implements IAutoCompleteDropDown too.
         hr = m_autoComplete->QueryInterface
                              (
         // provided IAutoComplete always implements IAutoCompleteDropDown too.
         hr = m_autoComplete->QueryInterface
                              (

-                               IID_IAutoCompleteDropDown,
+                               wxIID_IAutoCompleteDropDown,

                                reinterpret_cast<void **>(&m_autoCompleteDropDown)
                              );
         if ( FAILED(hr) )
                                reinterpret_cast<void **>(&m_autoCompleteDropDown)
                              );
         if ( FAILED(hr) )


@@ -264,6 +432,7 @@ public:
     ~wxTextAutoCompleteData()
     {
         delete m_customCompleter;
     ~wxTextAutoCompleteData()
     {
         delete m_customCompleter;

+        delete m_fixedCompleter;

 
         if ( m_enumStrings )
             m_enumStrings->Release();
 
         if ( m_enumStrings )
             m_enumStrings->Release();


@@ -282,7 +451,12 @@ public:
 
     void ChangeStrings(const wxArrayString& strings)
     {
 
     void ChangeStrings(const wxArrayString& strings)
     {

-        m_enumStrings->m_strings = strings;
+        if ( !m_fixedCompleter )
+            m_fixedCompleter = new wxTextCompleterFixed;
+
+        m_fixedCompleter->SetCompletions(strings);
+
+        m_enumStrings->ChangeCompleter(m_fixedCompleter);

 
         DoRefresh();
     }
 
         DoRefresh();
     }


@@ -290,6 +464,10 @@ public:
     // Takes ownership of the pointer if it is non-NULL.
     bool ChangeCustomCompleter(wxTextCompleter *completer)
     {
     // Takes ownership of the pointer if it is non-NULL.
     bool ChangeCustomCompleter(wxTextCompleter *completer)
     {

+        // Ensure that the old completer is not used any more before deleting
+        // it.
+        m_enumStrings->ChangeCompleter(completer);
+

         delete m_customCompleter;
         m_customCompleter = completer;
 
         delete m_customCompleter;
         m_customCompleter = completer;
 


@@ -332,16 +510,12 @@ public:
         // to effectively disable auto-completion just fine. We could (and
         // probably should) use IAutoComplete::Enable(FALSE) for this too but
         // then we'd need to call Enable(TRUE) to turn it on back again later.
         // to effectively disable auto-completion just fine. We could (and
         // probably should) use IAutoComplete::Enable(FALSE) for this too but
         // then we'd need to call Enable(TRUE) to turn it on back again later.

-
-        m_enumStrings->m_strings.clear();
-        m_enumStrings->Reset();
-
-        ChangeCustomCompleter(NULL);
+        ChangeStrings(wxArrayString());

     }
 
 private:
     }
 
 private:

-    // Must be called after changing wxIEnumString::m_strings to really make
-    // the changes stick.
+    // Must be called after changing the values to be returned by wxIEnumString
+    // to really make the changes stick.

     void DoRefresh()
     {
         m_enumStrings->Reset();
     void DoRefresh()
     {
         m_enumStrings->Reset();


@@ -372,11 +546,7 @@ private:
 
         const wxString prefix = m_entry->GetRange(0, from);
 
 
         const wxString prefix = m_entry->GetRange(0, from);
 

-        // For efficiency we access m_strings directly instead of creating
-        // another wxArrayString, normally this should save us an unnecessary
-        // memory allocation on the subsequent calls.
-        m_enumStrings->m_strings.clear();
-        m_customCompleter->GetCompletions(prefix, m_enumStrings->m_strings);
+        m_enumStrings->UpdatePrefix(prefix);

 
         DoRefresh();
     }
 
         DoRefresh();
     }


@@ -408,6 +578,9 @@ private:
     // Enumerator for strings currently used for auto-completion.
     wxIEnumString *m_enumStrings;
 
     // Enumerator for strings currently used for auto-completion.
     wxIEnumString *m_enumStrings;
 

+    // Fixed string completer or NULL if none.
+    wxTextCompleterFixed *m_fixedCompleter;
+

     // Custom completer or NULL if none.
     wxTextCompleter *m_customCompleter;
 
     // Custom completer or NULL if none.
     wxTextCompleter *m_customCompleter;
 


@@ -670,6 +843,11 @@ bool wxTextEntry::DoAutoCompleteStrings(const wxArrayString& choices)
     return wxTextEntryBase::DoAutoCompleteStrings(choices);
 }
 
     return wxTextEntryBase::DoAutoCompleteStrings(choices);
 }
 

+bool wxTextEntry::DoAutoCompleteCustom(wxTextCompleter *completer)
+{
+    return wxTextEntryBase::DoAutoCompleteCustom(completer);
+}
+

 #endif // HAS_AUTOCOMPLETE/!HAS_AUTOCOMPLETE
 
 #endif // wxUSE_OLE
 #endif // HAS_AUTOCOMPLETE/!HAS_AUTOCOMPLETE
 
 #endif // wxUSE_OLE