placeholder

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

diff --git a/src/msw/dde.cpp b/src/msw/dde.cpp
index 6a7e4d547c09c042250a0b5cfeb58038e96d75ea..6554c530debad9e0d4e76e18a56404fb72b4193e 100644 (file)
--- a/src/msw/dde.cpp
+++ b/src/msw/dde.cpp
@@ -5,7 +5,7 @@
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
+// Copyright:   (c) Julian Smart

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "dde.h"
 #endif
 
     #pragma implementation "dde.h"
 #endif
 


@@ -38,15 +38,14 @@
 #include "wx/module.h"
 #include "wx/dde.h"
 #include "wx/intl.h"
 #include "wx/module.h"
 #include "wx/dde.h"
 #include "wx/intl.h"

-
+#include "wx/hashmap.h"

 
 #include "wx/msw/private.h"
 
 #include <string.h>
 
 #include "wx/msw/private.h"
 
 #include <string.h>

-#include <windows.h>

 #include <ddeml.h>
 
 #include <ddeml.h>
 

-#if defined(__TWIN32__) || defined(__GNUWIN32_OLD__)
+#ifdef __GNUWIN32_OLD__

     #include "wx/msw/gnuwin32/extra.h"
 #endif
 
     #include "wx/msw/gnuwin32/extra.h"
 #endif
 


@@ -113,6 +112,7 @@ static HSZ DDEGetAtom(const wxString& string);
 // string handles
 static HSZ DDEAtomFromString(const wxString& s);
 static wxString DDEStringFromAtom(HSZ hsz);
 // string handles
 static HSZ DDEAtomFromString(const wxString& s);
 static wxString DDEStringFromAtom(HSZ hsz);

+static void DDEFreeString(HSZ hsz);

 
 // error handling
 static wxString DDEGetErrorMsg(UINT error);
 
 // error handling
 static wxString DDEGetErrorMsg(UINT error);


@@ -122,16 +122,22 @@ static void DDELogError(const wxString& s, UINT error = DMLERR_NO_ERROR);
 // global variables
 // ----------------------------------------------------------------------------
 
 // global variables
 // ----------------------------------------------------------------------------
 

+WX_DECLARE_STRING_HASH_MAP( HSZ, wxAtomMap );
+

 static DWORD DDEIdInst = 0L;
 static wxDDEConnection *DDECurrentlyConnecting = NULL;
 static DWORD DDEIdInst = 0L;
 static wxDDEConnection *DDECurrentlyConnecting = NULL;

+static wxAtomMap wxAtomTable;
+
+#include "wx/listimpl.cpp"
+
+WX_DEFINE_LIST(wxDDEClientList);
+WX_DEFINE_LIST(wxDDEServerList);
+WX_DEFINE_LIST(wxDDEConnectionList);

 
 

-static wxList wxAtomTable(wxKEY_STRING);
-static wxList wxDDEClientObjects;
-static wxList wxDDEServerObjects;
+static wxDDEClientList wxDDEClientObjects;
+static wxDDEServerList wxDDEServerObjects;

 
 

-char *DDEDefaultIPCBuffer = NULL;
-int DDEDefaultIPCBufferSize = 0;
-static bool DDEInitialized = FALSE;
+static bool DDEInitialized = false;

 
 // ----------------------------------------------------------------------------
 // private classes
 
 // ----------------------------------------------------------------------------
 // private classes


@@ -144,7 +150,7 @@ class wxDDEModule : public wxModule
 {
 public:
     wxDDEModule() {}
 {
 public:
     wxDDEModule() {}

-    bool OnInit() { return TRUE; }
+    bool OnInit() { return true; }

     void OnExit() { wxDDECleanUp(); }
 
 private:
     void OnExit() { wxDDECleanUp(); }
 
 private:


@@ -182,20 +188,25 @@ extern void wxDDEInitialize()
         }
         else
         {
         }
         else
         {

-            DDEInitialized = TRUE;
+            DDEInitialized = true;

         }
     }
 }
 
 void wxDDECleanUp()
 {
         }
     }
 }
 
 void wxDDECleanUp()
 {

+    // deleting them later won't work as DDE won't be initialized any more
+    wxASSERT_MSG( wxDDEServerObjects.empty() &&
+                    wxDDEClientObjects.empty(),
+                    _T("all DDE objects should be deleted by now") );
+
+    wxAtomTable.clear();
+

     if ( DDEIdInst != 0 )
     {
         DdeUninitialize(DDEIdInst);
         DDEIdInst = 0;
     }
     if ( DDEIdInst != 0 )
     {
         DdeUninitialize(DDEIdInst);
         DDEIdInst = 0;
     }

-
-    delete [] DDEDefaultIPCBuffer;

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


@@ -205,64 +216,75 @@ void wxDDECleanUp()
 // Global find connection
 static wxDDEConnection *DDEFindConnection(HCONV hConv)
 {
 // Global find connection
 static wxDDEConnection *DDEFindConnection(HCONV hConv)
 {

-  wxNode *node = wxDDEServerObjects.First();
-  wxDDEConnection *found = NULL;
-  while (node && !found)
-  {
-    wxDDEServer *object = (wxDDEServer *)node->Data();
-    found = object->FindConnection((WXHCONV) hConv);
-    node = node->Next();
-  }
-  if (found)
-      return found;
-
-  node = wxDDEClientObjects.First();
-  while (node && !found)
-  {
-    wxDDEClient *object = (wxDDEClient *)node->Data();
-    found = object->FindConnection((WXHCONV) hConv);
-    node = node->Next();
-  }
-  return found;
+    wxDDEServerList::compatibility_iterator serverNode = wxDDEServerObjects.GetFirst();
+    wxDDEConnection *found = NULL;
+    while (serverNode && !found)
+    {
+        wxDDEServer *object = serverNode->GetData();
+        found = object->FindConnection((WXHCONV) hConv);
+        serverNode = serverNode->GetNext();
+    }
+
+    if (found)
+    {
+        return found;
+    }
+
+    wxDDEClientList::compatibility_iterator clientNode = wxDDEClientObjects.GetFirst();
+    while (clientNode && !found)
+    {
+        wxDDEClient *object = clientNode->GetData();
+        found = object->FindConnection((WXHCONV) hConv);
+        clientNode = clientNode->GetNext();
+    }
+    return found;

 }
 
 // Global delete connection
 static void DDEDeleteConnection(HCONV hConv)
 {
 }
 
 // Global delete connection
 static void DDEDeleteConnection(HCONV hConv)
 {

-  wxNode *node = wxDDEServerObjects.First();
-  bool found = FALSE;
-  while (node && !found)
-  {
-    wxDDEServer *object = (wxDDEServer *)node->Data();
-    found = object->DeleteConnection((WXHCONV) hConv);
-    node = node->Next();
-  }
-  if (found)
-    return;
-
-  node = wxDDEClientObjects.First();
-  while (node && !found)
-  {
-    wxDDEClient *object = (wxDDEClient *)node->Data();
-    found = object->DeleteConnection((WXHCONV) hConv);
-    node = node->Next();
-  }
+    wxDDEServerList::compatibility_iterator serverNode = wxDDEServerObjects.GetFirst();
+    bool found = false;
+    while (serverNode && !found)
+    {
+        wxDDEServer *object = serverNode->GetData();
+        found = object->DeleteConnection((WXHCONV) hConv);
+        serverNode = serverNode->GetNext();
+    }
+    if (found)
+    {
+        return;
+    }
+
+    wxDDEClientList::compatibility_iterator clientNode = wxDDEClientObjects.GetFirst();
+    while (clientNode && !found)
+    {
+        wxDDEClient *object = clientNode->GetData();
+        found = object->DeleteConnection((WXHCONV) hConv);
+        clientNode = clientNode->GetNext();
+    }

 }
 
 // Find a server from a service name
 static wxDDEServer *DDEFindServer(const wxString& s)
 {
 }
 
 // Find a server from a service name
 static wxDDEServer *DDEFindServer(const wxString& s)
 {

-  wxNode *node = wxDDEServerObjects.First();
-  wxDDEServer *found = NULL;
-  while (node && !found)
-  {
-    wxDDEServer *object = (wxDDEServer *)node->Data();
-
-    if (object->GetServiceName() == s)
-      found = object;
-    else node = node->Next();
-  }
-  return found;
+    wxDDEServerList::compatibility_iterator node = wxDDEServerObjects.GetFirst();
+    wxDDEServer *found = NULL;
+    while (node && !found)
+    {
+        wxDDEServer *object = node->GetData();
+
+        if (object->GetServiceName() == s)
+        {
+            found = object;
+        }
+        else
+        {
+            node = node->GetNext();
+        }
+    }
+
+    return found;

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


@@ -280,46 +302,66 @@ bool wxDDEServer::Create(const wxString& server)
 {
     m_serviceName = server;
 
 {
     m_serviceName = server;
 

-    if ( !DdeNameService(DDEIdInst, DDEAtomFromString(server), (HSZ)NULL, DNS_REGISTER) )
+    HSZ hsz = DDEAtomFromString(server);
+
+    if ( !hsz )

     {
     {

-        DDELogError(wxString::Format(_("Failed to register DDE server '%s'"),
-                                     server.c_str()));
+        return false;
+    }

 
 

-        return FALSE;
+
+    bool success = (DdeNameService(DDEIdInst, hsz, (HSZ) NULL, DNS_REGISTER)
+        != NULL);
+
+    if (!success)
+    {
+        DDELogError(wxString::Format(_("Failed to register DDE server '%s'"),
+            server.c_str()));

     }
 
     }
 

-    return TRUE;
+    DDEFreeString(hsz);
+
+    return success;

 }
 
 wxDDEServer::~wxDDEServer()
 {
     if ( !!m_serviceName )
     {
 }
 
 wxDDEServer::~wxDDEServer()
 {
     if ( !!m_serviceName )
     {

-        if ( !DdeNameService(DDEIdInst, DDEAtomFromString(m_serviceName),
-                             (HSZ)NULL, DNS_UNREGISTER) )
+        HSZ hsz = DDEAtomFromString(m_serviceName);
+
+        if (hsz)

         {
         {

-            DDELogError(wxString::Format(_("Failed to unregister DDE server '%s'"),
-                                         m_serviceName.c_str()));
+            if ( !DdeNameService(DDEIdInst, hsz,
+                (HSZ) NULL, DNS_UNREGISTER) )
+            {
+                DDELogError(wxString::Format(
+                    _("Failed to unregister DDE server '%s'"),
+                    m_serviceName.c_str()));
+            }
+
+            DDEFreeString(hsz);

         }
     }
 
     wxDDEServerObjects.DeleteObject(this);
 
         }
     }
 
     wxDDEServerObjects.DeleteObject(this);
 

-    wxNode *node = m_connections.First();
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();

     while (node)
     {
     while (node)
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
-        wxNode *next = node->Next();
+        wxDDEConnection *connection = node->GetData();
+        wxDDEConnectionList::compatibility_iterator next = node->GetNext();
+        connection->SetConnected(false);

         connection->OnDisconnect(); // May delete the node implicitly
         node = next;
     }
 
     // If any left after this, delete them
         connection->OnDisconnect(); // May delete the node implicitly
         node = next;
     }
 
     // If any left after this, delete them

-    node = m_connections.First();
+    node = m_connections.GetFirst();

     while (node)
     {
     while (node)
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
-        wxNode *next = node->Next();
+        wxDDEConnection *connection = node->GetData();
+        wxDDEConnectionList::compatibility_iterator next = node->GetNext();

         delete connection;
         node = next;
     }
         delete connection;
         node = next;
     }


@@ -332,14 +374,14 @@ wxConnectionBase *wxDDEServer::OnAcceptConnection(const wxString& /* topic */)
 
 wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
 {
 
 wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
 {

-    wxNode *node = m_connections.First();
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();

     wxDDEConnection *found = NULL;
     while (node && !found)
     {
     wxDDEConnection *found = NULL;
     while (node && !found)
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+        wxDDEConnection *connection = node->GetData();

         if (connection->m_hConv == conv)
             found = connection;
         if (connection->m_hConv == conv)
             found = connection;

-        else node = node->Next();
+        else node = node->GetNext();

     }
     return found;
 }
     }
     return found;
 }


@@ -347,19 +389,21 @@ wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
 // Only delete the entry in the map, not the actual connection
 bool wxDDEServer::DeleteConnection(WXHCONV conv)
 {
 // Only delete the entry in the map, not the actual connection
 bool wxDDEServer::DeleteConnection(WXHCONV conv)
 {

-    wxNode *node = m_connections.First();
-    bool found = FALSE;
-    while (node && !found)
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
+    while (node)

     {
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+        wxDDEConnection *connection = node->GetData();

         if (connection->m_hConv == conv)
         {
         if (connection->m_hConv == conv)
         {

-            found = TRUE;
-            delete node;
+            m_connections.Erase(node);
+            return true;
+        }
+        else
+        {
+            node = node->GetNext();

         }
         }

-        else node = node->Next();

     }
     }

-    return found;
+    return false;

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


@@ -376,30 +420,53 @@ wxDDEClient::wxDDEClient()
 wxDDEClient::~wxDDEClient()
 {
     wxDDEClientObjects.DeleteObject(this);
 wxDDEClient::~wxDDEClient()
 {
     wxDDEClientObjects.DeleteObject(this);

-    wxNode *node = m_connections.First();
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();

     while (node)
     {
     while (node)
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+        wxDDEConnection *connection = node->GetData();

         delete connection;  // Deletes the node implicitly (see ~wxDDEConnection)
         delete connection;  // Deletes the node implicitly (see ~wxDDEConnection)

-        node = m_connections.First();
+        node = m_connections.GetFirst();

     }
 }
 
 bool wxDDEClient::ValidHost(const wxString& /* host */)
 {
     }
 }
 
 bool wxDDEClient::ValidHost(const wxString& /* host */)
 {

-    return TRUE;
+    return true;

 }
 
 wxConnectionBase *wxDDEClient::MakeConnection(const wxString& WXUNUSED(host),
                                               const wxString& server,
                                               const wxString& topic)
 {
 }
 
 wxConnectionBase *wxDDEClient::MakeConnection(const wxString& WXUNUSED(host),
                                               const wxString& server,
                                               const wxString& topic)
 {

-    HCONV hConv = DdeConnect(DDEIdInst, DDEAtomFromString(server), DDEAtomFromString(topic),
-                             (PCONVCONTEXT)NULL);
+    HSZ hszServer = DDEAtomFromString(server);
+
+    if ( !hszServer )
+    {
+        return (wxConnectionBase*) NULL;
+    }
+
+
+    HSZ hszTopic = DDEAtomFromString(topic);
+
+    if ( !hszTopic )
+    {
+        DDEFreeString(hszServer);
+        return (wxConnectionBase*) NULL;
+    }
+
+
+    HCONV hConv = ::DdeConnect(DDEIdInst, hszServer, hszTopic,
+        (PCONVCONTEXT) NULL);
+
+    DDEFreeString(hszServer);
+    DDEFreeString(hszTopic);
+
+

     if ( !hConv )
     {
     if ( !hConv )
     {

-        DDELogError(wxString::Format(_("Failed to create connection to server '%s' on topic '%s'"),
-                                     server.c_str(), topic.c_str()));
+        DDELogError( wxString::Format(
+            _("Failed to create connection to server '%s' on topic '%s'"),
+            server.c_str(), topic.c_str()) );

     }
     else
     {
     }
     else
     {


@@ -424,14 +491,14 @@ wxConnectionBase *wxDDEClient::OnMakeConnection()
 
 wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
 {
 
 wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
 {

-    wxNode *node = m_connections.First();
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();

     wxDDEConnection *found = NULL;
     while (node && !found)
     {
     wxDDEConnection *found = NULL;
     while (node && !found)
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+        wxDDEConnection *connection = node->GetData();

         if (connection->m_hConv == conv)
             found = connection;
         if (connection->m_hConv == conv)
             found = connection;

-        else node = node->Next();
+        else node = node->GetNext();

     }
     return found;
 }
     }
     return found;
 }


@@ -439,40 +506,27 @@ wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
 // Only delete the entry in the map, not the actual connection
 bool wxDDEClient::DeleteConnection(WXHCONV conv)
 {
 // Only delete the entry in the map, not the actual connection
 bool wxDDEClient::DeleteConnection(WXHCONV conv)
 {

-    wxNode *node = m_connections.First();
-    bool found = FALSE;
-    while (node && !found)
+    wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
+    while (node)

     {
     {

-        wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+        wxDDEConnection *connection = node->GetData();

         if (connection->m_hConv == conv)
         {
         if (connection->m_hConv == conv)
         {

-            found = TRUE;
-            delete node;
+            m_connections.Erase(node);
+            return true;

         }
         }

-        else node = node->Next();
+        else node = node->GetNext();

     }
     }

-    return found;
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 // wxDDEConnection
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxDDEConnection
 // ----------------------------------------------------------------------------
 

-wxDDEConnection::wxDDEConnection(char *buffer, int size)
+wxDDEConnection::wxDDEConnection(wxChar *buffer, int size)
+     : wxConnectionBase(buffer, size)

 {
 {

-    if (buffer == NULL)
-    {
-        if (DDEDefaultIPCBuffer == NULL)
-            DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
-        m_bufPtr = DDEDefaultIPCBuffer;
-        m_bufSize = DDEDefaultIPCBufferSize;
-    }
-    else
-    {
-        m_bufPtr = buffer;
-        m_bufSize = size;
-    }
-

     m_client = NULL;
     m_server = NULL;
 
     m_client = NULL;
     m_server = NULL;
 


@@ -481,20 +535,17 @@ wxDDEConnection::wxDDEConnection(char *buffer, int size)
 }
 
 wxDDEConnection::wxDDEConnection()
 }
 
 wxDDEConnection::wxDDEConnection()

+     : wxConnectionBase()

 {
     m_hConv = 0;
     m_sendingData = NULL;
     m_server = NULL;
     m_client = NULL;
 {
     m_hConv = 0;
     m_sendingData = NULL;
     m_server = NULL;
     m_client = NULL;

-    if (DDEDefaultIPCBuffer == NULL)
-        DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
-
-    m_bufPtr = DDEDefaultIPCBuffer;
-    m_bufSize = DDEDefaultIPCBufferSize;

 }
 
 wxDDEConnection::~wxDDEConnection()
 {
 }
 
 wxDDEConnection::~wxDDEConnection()
 {

+    Disconnect();

     if (m_server)
         m_server->GetConnections().DeleteObject(this);
     else
     if (m_server)
         m_server->GetConnections().DeleteObject(this);
     else


@@ -504,6 +555,9 @@ wxDDEConnection::~wxDDEConnection()
 // Calls that CLIENT can make
 bool wxDDEConnection::Disconnect()
 {
 // Calls that CLIENT can make
 bool wxDDEConnection::Disconnect()
 {

+    if ( !GetConnected() )
+        return true;
+

     DDEDeleteConnection(GetHConv());
 
     bool ok = DdeDisconnect(GetHConv()) != 0;
     DDEDeleteConnection(GetHConv());
 
     bool ok = DdeDisconnect(GetHConv()) != 0;


@@ -512,6 +566,8 @@ bool wxDDEConnection::Disconnect()
         DDELogError(_T("Failed to disconnect from DDE server gracefully"));
     }
 
         DDELogError(_T("Failed to disconnect from DDE server gracefully"));
     }
 

+    SetConnected( false );  // so we don't try and disconnect again
+

     return ok;
 }
 
     return ok;
 }
 


@@ -539,9 +595,10 @@ bool wxDDEConnection::Execute(const wxChar *data, int size, wxIPCFormat format)
     return ok;
 }
 
     return ok;
 }
 

-char *wxDDEConnection::Request(const wxString& item, int *size, wxIPCFormat format)
+wxChar *wxDDEConnection::Request(const wxString& item, int *size, wxIPCFormat format)

 {
     DWORD result;
 {
     DWORD result;

+

     HSZ atom = DDEGetAtom(item);
 
     HDDEDATA returned_data = DdeClientTransaction(NULL, 0,
     HSZ atom = DDEGetAtom(item);
 
     HDDEDATA returned_data = DdeClientTransaction(NULL, 0,


@@ -557,14 +614,19 @@ char *wxDDEConnection::Request(const wxString& item, int *size, wxIPCFormat form
         return NULL;
     }
 
         return NULL;
     }
 

-    DWORD len = DdeGetData(returned_data, (LPBYTE)m_bufPtr, m_bufSize, 0);
+    DWORD len = DdeGetData(returned_data, NULL, 0, 0);
+
+    wxChar *data = GetBufferAtLeast( len );
+    wxASSERT_MSG(data != NULL,
+                 _T("Buffer too small in wxDDEConnection::Request") );
+    (void) DdeGetData(returned_data, (LPBYTE)data, len, 0);

 
 

-    DdeFreeDataHandle(returned_data);
+    (void) DdeFreeDataHandle(returned_data);

 
     if (size)
         *size = (int)len;
 
 
     if (size)
         *size = (int)len;
 

-    return m_bufPtr;
+    return data;

 }
 
 bool wxDDEConnection::Poke(const wxString& item, wxChar *data, int size, wxIPCFormat format)
 }
 
 bool wxDDEConnection::Poke(const wxString& item, wxChar *data, int size, wxIPCFormat format)


@@ -641,7 +703,7 @@ bool wxDDEConnection::Advise(const wxString& item,
 
     HSZ item_atom = DDEGetAtom(item);
     HSZ topic_atom = DDEGetAtom(m_topicName);
 
     HSZ item_atom = DDEGetAtom(item);
     HSZ topic_atom = DDEGetAtom(m_topicName);

-    m_sendingData = data;
+    m_sendingData = data;  // mrf: potential for scope problems here?

     m_dataSize = size;
     m_dataType = format;
 
     m_dataSize = size;
     m_dataType = format;
 


@@ -657,7 +719,7 @@ bool wxDDEConnection::Advise(const wxString& item,
 bool wxDDEConnection::OnDisconnect()
 {
     delete this;
 bool wxDDEConnection::OnDisconnect()
 {
     delete this;

-    return TRUE;
+    return true;

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


@@ -694,7 +756,7 @@ _DDECallback(WORD wType,
                         connection->m_hConv = 0;
                         connection->m_topicName = topic;
                         DDECurrentlyConnecting = connection;
                         connection->m_hConv = 0;
                         connection->m_topicName = topic;
                         DDECurrentlyConnecting = connection;

-                        return (DDERETURN)(DWORD)TRUE;
+                        return (DDERETURN)(DWORD)true;

                     }
                 }
                 break;
                     }
                 }
                 break;


@@ -706,7 +768,7 @@ _DDECallback(WORD wType,
                 {
                     DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
                     DDECurrentlyConnecting = NULL;
                 {
                     DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
                     DDECurrentlyConnecting = NULL;

-                    return (DDERETURN)(DWORD)TRUE;
+                    return (DDERETURN)(DWORD)true;

                 }
                 break;
             }
                 }
                 break;
             }


@@ -714,10 +776,14 @@ _DDECallback(WORD wType,
         case XTYP_DISCONNECT:
             {
                 wxDDEConnection *connection = DDEFindConnection(hConv);
         case XTYP_DISCONNECT:
             {
                 wxDDEConnection *connection = DDEFindConnection(hConv);

-                if (connection && connection->OnDisconnect())
+                if (connection)

                 {
                 {

-                    DDEDeleteConnection(hConv);  // Delete mapping: hConv => connection
-                    return (DDERETURN)(DWORD)TRUE;
+                    connection->SetConnected( false );
+                    if (connection->OnDisconnect())
+                    {
+                        DDEDeleteConnection(hConv);  // Delete mapping: hConv => connection
+                        return (DDERETURN)(DWORD)true;
+                    }

                 }
                 break;
             }
                 }
                 break;
             }


@@ -728,13 +794,18 @@ _DDECallback(WORD wType,
 
                 if (connection)
                 {
 
                 if (connection)
                 {

-                    DWORD len = DdeGetData(hData,
-                                           (LPBYTE)connection->m_bufPtr,
-                                           connection->m_bufSize,
-                                           0);
+                    DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+                    wxChar *data = connection->GetBufferAtLeast( len );
+                    wxASSERT_MSG(data != NULL,
+                                 _T("Buffer too small in _DDECallback (XTYP_EXECUTE)") );
+
+                    DdeGetData(hData, (LPBYTE)data, len, 0);
+

                     DdeFreeDataHandle(hData);
                     DdeFreeDataHandle(hData);

+

                     if ( connection->OnExecute(connection->m_topicName,
                     if ( connection->OnExecute(connection->m_topicName,

-                                               connection->m_bufPtr,
+                                               data,

                                                (int)len,
                                                (wxIPCFormat) wFmt) )
                     {
                                                (int)len,
                                                (wxIPCFormat) wFmt) )
                     {


@@ -754,7 +825,7 @@ _DDECallback(WORD wType,
                     wxString item_name = DDEStringFromAtom(hsz2);
 
                     int user_size = -1;
                     wxString item_name = DDEStringFromAtom(hsz2);
 
                     int user_size = -1;

-                    char *data = connection->OnRequest(connection->m_topicName,
+                    wxChar *data = connection->OnRequest(connection->m_topicName,

                                                        item_name,
                                                        &user_size,
                                                        (wxIPCFormat) wFmt);
                                                        item_name,
                                                        &user_size,
                                                        (wxIPCFormat) wFmt);


@@ -784,15 +855,19 @@ _DDECallback(WORD wType,
                 {
                     wxString item_name = DDEStringFromAtom(hsz2);
 
                 {
                     wxString item_name = DDEStringFromAtom(hsz2);
 

-                    DWORD len = DdeGetData(hData,
-                                           (LPBYTE)connection->m_bufPtr,
-                                           connection->m_bufSize,
-                                           0);
+                    DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+                    wxChar *data = connection->GetBufferAtLeast( len );
+                    wxASSERT_MSG(data != NULL,
+                                 _T("Buffer too small in _DDECallback (XTYP_EXECUTE)") );
+
+                    DdeGetData(hData, (LPBYTE)data, len, 0);
+

                     DdeFreeDataHandle(hData);
 
                     connection->OnPoke(connection->m_topicName,
                                        item_name,
                     DdeFreeDataHandle(hData);
 
                     connection->OnPoke(connection->m_topicName,
                                        item_name,

-                                       (wxChar*)connection->m_bufPtr,
+                                       data,

                                        (int)len,
                                        (wxIPCFormat) wFmt);
 
                                        (int)len,
                                        (wxIPCFormat) wFmt);
 


@@ -867,14 +942,18 @@ _DDECallback(WORD wType,
                 {
                     wxString item_name = DDEStringFromAtom(hsz2);
 
                 {
                     wxString item_name = DDEStringFromAtom(hsz2);
 

-                    DWORD len = DdeGetData(hData,
-                                           (LPBYTE)connection->m_bufPtr,
-                                           connection->m_bufSize,
-                                           0);
+                    DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+                    wxChar *data = connection->GetBufferAtLeast( len );
+                    wxASSERT_MSG(data != NULL,
+                                 _T("Buffer too small in _DDECallback (XTYP_ADVDATA)") );
+
+                    DdeGetData(hData, (LPBYTE)data, len, 0);
+

                     DdeFreeDataHandle(hData);
                     if ( connection->OnAdvise(connection->m_topicName,
                                               item_name,
                     DdeFreeDataHandle(hData);
                     if ( connection->OnAdvise(connection->m_topicName,
                                               item_name,

-                                              connection->m_bufPtr,
+                                              data,

                                               (int)len,
                                               (wxIPCFormat) wFmt) )
                     {
                                               (int)len,
                                               (wxIPCFormat) wFmt) )
                     {


@@ -894,26 +973,27 @@ _DDECallback(WORD wType,
 // ----------------------------------------------------------------------------
 
 // Atom table stuff
 // ----------------------------------------------------------------------------
 
 // Atom table stuff

-static HSZ DDEAddAtom(const wxString& string)
+static HSZ DDEAddAtom(const wxString& str)

 {
 {

-    HSZ atom = DDEAtomFromString(string);
-    wxAtomTable.Append(string, (wxObject *)atom);
+    HSZ atom = DDEAtomFromString(str);
+    wxAtomTable[str] = atom;

     return atom;
 }
 
     return atom;
 }
 

-static HSZ DDEGetAtom(const wxString& string)
+static HSZ DDEGetAtom(const wxString& str)

 {
 {

-    wxNode *node = wxAtomTable.Find(string);
-    if (node)
-        return (HSZ)node->Data();
-    else
-    {
-        DDEAddAtom(string);
-        return (HSZ)(wxAtomTable.Find(string)->Data());
-    }
+    wxAtomMap::iterator it = wxAtomTable.find(str);
+
+    if (it != wxAtomTable.end())
+        return it->second;
+
+    return DDEAddAtom(str);

 }
 
 }
 

-// atom <-> strings
+/* atom <-> strings
+The returned handle has to be freed by the caller (using
+(static) DDEFreeString).
+*/

 static HSZ DDEAtomFromString(const wxString& s)
 {
     wxASSERT_MSG( DDEIdInst, _T("DDE not initialized") );
 static HSZ DDEAtomFromString(const wxString& s)
 {
     wxASSERT_MSG( DDEIdInst, _T("DDE not initialized") );


@@ -933,12 +1013,20 @@ static wxString DDEStringFromAtom(HSZ hsz)
     static const size_t len = 256;
 
     wxString s;
     static const size_t len = 256;
 
     wxString s;

-    (void)DdeQueryString(DDEIdInst, hsz, s.GetWriteBuf(len), len, DDE_CP);
-    s.UngetWriteBuf();
+    (void)DdeQueryString(DDEIdInst, hsz, wxStringBuffer(s, len), len, DDE_CP);

 
     return s;
 }
 
 
     return s;
 }
 

+static void DDEFreeString(HSZ hsz)
+{
+    // DS: Failure to free a string handle might indicate there's
+    // some other severe error.
+    bool ok = (::DdeFreeStringHandle(DDEIdInst, hsz) != 0);
+    wxASSERT_MSG( ok, wxT("Failed to free DDE string handle") );
+    wxUnusedVar(ok);
+}
+

 // ----------------------------------------------------------------------------
 // error handling
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // error handling
 // ----------------------------------------------------------------------------