/////////////////////////////////////////////////////////////////////////////
-// Name: msw/dde.cpp
+// Name: src/msw/dde.cpp
// Purpose: DDE classes
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
+// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "dde.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/utils.h"
#include "wx/app.h"
+ #include "wx/hashmap.h"
+ #include "wx/module.h"
#endif
-#include "wx/module.h"
#include "wx/dde.h"
#include "wx/intl.h"
-
+#include "wx/buffer.h"
+#include "wx/strconv.h"
#include "wx/msw/private.h"
#include <string.h>
-#include <windows.h>
#include <ddeml.h>
-#if defined(__TWIN32__) || defined(__GNUWIN32_OLD__)
- #include "wx/msw/gnuwin32/extra.h"
-#endif
-
-// some compilers headers don't define this one (mingw32)
-#ifndef DMLERR_NO_ERROR
- #define DMLERR_NO_ERROR (0)
-
- // this one is also missing from some mingw32 headers, but there is no way
- // to test for it (I know of) - the test for DMLERR_NO_ERROR works for me,
- // but is surely not the right thing to do
- extern "C"
- HDDEDATA STDCALL DdeClientTransaction(LPBYTE pData,
- DWORD cbData,
- HCONV hConv,
- HSZ hszItem,
- UINT wFmt,
- UINT wType,
- DWORD dwTimeout,
- LPDWORD pdwResult);
-#endif // no DMLERR_NO_ERROR
-
// ----------------------------------------------------------------------------
// macros and constants
// ----------------------------------------------------------------------------
// 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);
// global variables
// ----------------------------------------------------------------------------
+WX_DECLARE_STRING_HASH_MAP( HSZ, wxAtomMap );
+
static DWORD DDEIdInst = 0L;
static wxDDEConnection *DDECurrentlyConnecting = NULL;
+static wxAtomMap wxAtomTable;
+
+#include "wx/listimpl.cpp"
-static wxList wxAtomTable(wxKEY_STRING);
-static wxList wxDDEClientObjects;
-static wxList wxDDEServerObjects;
+WX_DEFINE_LIST(wxDDEClientList)
+WX_DEFINE_LIST(wxDDEServerList)
+WX_DEFINE_LIST(wxDDEConnectionList)
-char *DDEDefaultIPCBuffer = NULL;
-int DDEDefaultIPCBufferSize = 0;
-static bool DDEInitialized = FALSE;
+static wxDDEClientList wxDDEClientObjects;
+static wxDDEServerList wxDDEServerObjects;
+
+static bool DDEInitialized = false;
// ----------------------------------------------------------------------------
// private classes
{
public:
wxDDEModule() {}
- bool OnInit() { return TRUE; }
+ bool OnInit() { return true; }
void OnExit() { wxDDECleanUp(); }
private:
IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxServerBase)
IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxClientBase)
-IMPLEMENT_CLASS(wxDDEConnection, wxConnectionBase)
+IMPLEMENT_DYNAMIC_CLASS(wxDDEConnection, wxConnectionBase)
IMPLEMENT_DYNAMIC_CLASS(wxDDEModule, wxModule)
// ============================================================================
UINT rc = DdeInitialize(&DDEIdInst, callback, APPCLASS_STANDARD, 0L);
if ( rc != DMLERR_NO_ERROR )
{
- DDELogError(_T("Failed to initialize DDE"), rc);
+ DDELogError(wxT("Failed to initialize DDE"), rc);
}
else
{
- DDEInitialized = TRUE;
+ DDEInitialized = true;
}
}
}
void wxDDECleanUp()
{
+ // deleting them later won't work as DDE won't be initialized any more
+ wxASSERT_MSG( wxDDEServerObjects.empty() &&
+ wxDDEClientObjects.empty(),
+ wxT("all DDE objects should be deleted by now") );
+
+ wxAtomTable.clear();
+
if ( DDEIdInst != 0 )
{
DdeUninitialize(DDEIdInst);
DDEIdInst = 0;
}
-
- delete [] DDEDefaultIPCBuffer;
}
// ----------------------------------------------------------------------------
// 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)
{
- 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)
{
- 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;
}
// ----------------------------------------------------------------------------
{
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;
+ }
+
+
+ bool success = (DdeNameService(DDEIdInst, hsz, (HSZ) NULL, DNS_REGISTER)
+ != NULL);
- return FALSE;
+ 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 )
+ if ( !m_serviceName.empty() )
{
- 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);
- wxNode *node = m_connections.First();
+ wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
while (node)
{
- wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- wxNode *next = node->Next();
+ wxDDEConnection *connection = node->GetData();
+ wxDDEConnectionList::compatibility_iterator next = node->GetNext();
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)
{
- wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- wxNode *next = node->Next();
+ wxDDEConnection *connection = node->GetData();
+ wxDDEConnectionList::compatibility_iterator next = node->GetNext();
delete connection;
node = next;
}
wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
{
- wxNode *node = m_connections.First();
+ wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
wxDDEConnection *found = NULL;
while (node && !found)
{
- wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+ wxDDEConnection *connection = node->GetData();
if (connection->m_hConv == conv)
found = connection;
- else node = node->Next();
+ else node = node->GetNext();
}
return found;
}
// 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)
{
- found = TRUE;
- delete node;
+ m_connections.Erase(node);
+ return true;
+ }
+ else
+ {
+ node = node->GetNext();
}
- else node = node->Next();
}
- return found;
+ return false;
}
// ----------------------------------------------------------------------------
wxDDEClient::~wxDDEClient()
{
wxDDEClientObjects.DeleteObject(this);
- wxNode *node = m_connections.First();
+ wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
while (node)
{
- wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+ wxDDEConnection *connection = node->GetData();
delete connection; // Deletes the node implicitly (see ~wxDDEConnection)
- node = m_connections.First();
+ node = m_connections.GetFirst();
}
}
bool wxDDEClient::ValidHost(const wxString& /* host */)
{
- return TRUE;
+ return true;
}
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 NULL;
+ }
+
+
+ HSZ hszTopic = DDEAtomFromString(topic);
+
+ if ( !hszTopic )
+ {
+ DDEFreeString(hszServer);
+ return NULL;
+ }
+
+
+ HCONV hConv = ::DdeConnect(DDEIdInst, hszServer, hszTopic,
+ (PCONVCONTEXT) NULL);
+
+ DDEFreeString(hszServer);
+ DDEFreeString(hszTopic);
+
+
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
{
}
}
- return (wxConnectionBase*) NULL;
+ return NULL;
}
wxConnectionBase *wxDDEClient::OnMakeConnection()
wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
{
- wxNode *node = m_connections.First();
+ wxDDEConnectionList::compatibility_iterator node = m_connections.GetFirst();
wxDDEConnection *found = NULL;
while (node && !found)
{
- wxDDEConnection *connection = (wxDDEConnection *)node->Data();
+ wxDDEConnection *connection = node->GetData();
if (connection->m_hConv == conv)
found = connection;
- else node = node->Next();
+ else node = node->GetNext();
}
return found;
}
// 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)
{
- 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(char *buffer, int size)
+wxDDEConnection::wxDDEConnection(void *buffer, size_t 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;
}
wxDDEConnection::wxDDEConnection()
+ : wxConnectionBase()
{
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()
{
+ Disconnect();
if (m_server)
m_server->GetConnections().DeleteObject(this);
else
// Calls that CLIENT can make
bool wxDDEConnection::Disconnect()
{
+ if ( !GetConnected() )
+ return true;
+
DDEDeleteConnection(GetHConv());
bool ok = DdeDisconnect(GetHConv()) != 0;
if ( !ok )
{
- DDELogError(_T("Failed to disconnect from DDE server gracefully"));
+ DDELogError(wxT("Failed to disconnect from DDE server gracefully"));
}
+ SetConnected( false ); // so we don't try and disconnect again
+
return ok;
}
-bool wxDDEConnection::Execute(const wxChar *data, int size, wxIPCFormat format)
+bool
+wxDDEConnection::DoExecute(const void *data, size_t size, wxIPCFormat format)
{
- DWORD result;
- if (size < 0)
+ wxCHECK_MSG( format == wxIPC_TEXT ||
+ format == wxIPC_UTF8TEXT ||
+ format == wxIPC_UNICODETEXT,
+ false,
+ wxT("wxDDEServer::Execute() supports only text data") );
+
+ wxMemoryBuffer buffer;
+ LPBYTE realData = NULL;
+ size_t realSize = 0;
+ wxMBConv *conv = NULL;
+
+ // Windows only supports either ANSI or UTF-16 format depending on the
+ // build, so we need to convert the data if it doesn't use it already
+#if wxUSE_UNICODE
+ if ( format == wxIPC_TEXT )
+ {
+ conv = &wxConvLibc;
+ }
+ else if ( format == wxIPC_UTF8TEXT )
{
- size = wxStrlen(data) + 1;
+ conv = &wxConvUTF8;
+ }
+ else // no conversion necessary for wxIPC_UNICODETEXT
+ {
+ realData = (LPBYTE)data;
+ realSize = size;
+ }
+
+ if ( conv )
+ {
+ const char * const text = (const char *)data;
+ const size_t len = size/sizeof(char);
+
+ realSize = conv->ToWChar(NULL, 0, text, len);
+ if ( realSize == wxCONV_FAILED )
+ return false;
+
+ realData = (LPBYTE)buffer.GetWriteBuf(realSize*sizeof(wchar_t));
+ if ( !realData )
+ return false;
+
+ realSize = conv->ToWChar((wchar_t *)realData, realSize, text, len);
+ if ( realSize == wxCONV_FAILED )
+ return false;
+
+ // We need to pass the size of the buffer to DdeClientTransaction() and
+ // not the length of the string.
+ realSize *= sizeof(wchar_t);
+ }
+#else // !wxUSE_UNICODE
+ if ( format == wxIPC_UNICODETEXT )
+ {
+ conv = &wxConvLibc;
+ }
+ else if ( format == wxIPC_UTF8TEXT )
+ {
+ // we could implement this in theory but it's not obvious how to pass
+ // the format information and, basically, why bother -- just use
+ // Unicode build
+ wxFAIL_MSG( wxT("UTF-8 text not supported in ANSI build") );
+
+ return false;
+ }
+ else // don't convert wxIPC_TEXT
+ {
+ realData = (LPBYTE)data;
+ realSize = size;
+ }
+
+ if ( conv )
+ {
+ const wchar_t * const wtext = (const wchar_t *)data;
+ const size_t len = size/sizeof(wchar_t);
+
+ realSize = conv->FromWChar(NULL, 0, wtext, len);
+ if ( realSize == wxCONV_FAILED )
+ return false;
+
+ realData = (LPBYTE)buffer.GetWriteBuf(realSize*sizeof(char));
+ if ( !realData )
+ return false;
+
+ realSize = conv->FromWChar((char*)realData, realSize, wtext, len);
+ if ( realSize == wxCONV_FAILED )
+ return false;
}
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE
+
+ DWORD result;
+ bool ok = DdeClientTransaction(realData,
+ realSize,
+ GetHConv(),
+ NULL,
+ // MSDN: if the transaction specified by
+ // the wType parameter does not pass data
+ // or is XTYP_EXECUTE, wFmt should be zero.
+ 0,
+ XTYP_EXECUTE,
+ DDE_TIMEOUT,
+ &result) != 0;
- bool ok = DdeClientTransaction((LPBYTE)data, size,
- GetHConv(),
- NULL,
- format,
- XTYP_EXECUTE,
- DDE_TIMEOUT,
- &result) != 0;
if ( !ok )
{
- DDELogError(_T("DDE execute request failed"));
+ DDELogError(wxT("DDE execute request failed"));
}
return ok;
}
-char *wxDDEConnection::Request(const wxString& item, int *size, wxIPCFormat format)
+const void *wxDDEConnection::Request(const wxString& item, size_t *size, wxIPCFormat format)
{
DWORD result;
+
HSZ atom = DDEGetAtom(item);
HDDEDATA returned_data = DdeClientTransaction(NULL, 0,
&result);
if ( !returned_data )
{
- DDELogError(_T("DDE data request failed"));
+ DDELogError(wxT("DDE data request failed"));
return NULL;
}
- DWORD len = DdeGetData(returned_data, (LPBYTE)m_bufPtr, m_bufSize, 0);
+ DWORD len = DdeGetData(returned_data, NULL, 0, 0);
+
+ void *data = GetBufferAtLeast(len);
+ wxASSERT_MSG(data != NULL,
+ wxT("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;
+ *size = (size_t)len;
- return m_bufPtr;
+ return data;
}
-bool wxDDEConnection::Poke(const wxString& item, wxChar *data, int size, wxIPCFormat format)
+bool wxDDEConnection::DoPoke(const wxString& item, const void *data, size_t size, wxIPCFormat format)
{
DWORD result;
- if (size < 0)
- {
- size = wxStrlen(data) + 1;
- }
HSZ item_atom = DDEGetAtom(item);
- bool ok = DdeClientTransaction((LPBYTE)data, size,
+ bool ok = DdeClientTransaction((LPBYTE)data,
+ size,
GetHConv(),
item_atom, format,
XTYP_POKE,
}
// Calls that SERVER can make
-bool wxDDEConnection::Advise(const wxString& item,
- wxChar *data,
- int size,
- wxIPCFormat format)
+bool wxDDEConnection::DoAdvise(const wxString& item,
+ const void *data,
+ size_t size,
+ wxIPCFormat format)
{
- if (size < 0)
- {
- size = wxStrlen(data) + 1;
- }
-
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;
+ // wxIPC_PRIVATE does not succeed, so use text instead
+ m_dataType = format == wxIPC_PRIVATE ? wxIPC_TEXT : format;
bool ok = DdePostAdvise(DDEIdInst, topic_atom, item_atom) != 0;
if ( !ok )
return ok;
}
-bool wxDDEConnection::OnDisconnect()
-{
- delete this;
- return TRUE;
-}
-
// ----------------------------------------------------------------------------
// _DDECallback
// ----------------------------------------------------------------------------
connection->m_hConv = 0;
connection->m_topicName = topic;
DDECurrentlyConnecting = connection;
- return (DDERETURN)(DWORD)TRUE;
+ return (DDERETURN)(DWORD)true;
}
}
break;
{
DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
DDECurrentlyConnecting = NULL;
- return (DDERETURN)(DWORD)TRUE;
+ return (DDERETURN)(DWORD)true;
}
break;
}
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;
}
if (connection)
{
- DWORD len = DdeGetData(hData,
- (LPBYTE)connection->m_bufPtr,
- connection->m_bufSize,
- 0);
+ DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+ void *data = connection->GetBufferAtLeast(len);
+ wxASSERT_MSG(data != NULL,
+ wxT("Buffer too small in _DDECallback (XTYP_EXECUTE)") );
+
+ DdeGetData(hData, (LPBYTE)data, len, 0);
+
DdeFreeDataHandle(hData);
+
+ // XTYP_EXECUTE can be used for text only and the text is
+ // always in ANSI format for ANSI build and Unicode format
+ // in Unicode build
+ #if wxUSE_UNICODE
+ wFmt = wxIPC_UNICODETEXT;
+ #else
+ wFmt = wxIPC_TEXT;
+ #endif
+
if ( connection->OnExecute(connection->m_topicName,
- connection->m_bufPtr,
+ data,
(int)len,
- (wxIPCFormat) wFmt) )
+ (wxIPCFormat)wFmt) )
{
return (DDERETURN)(DWORD)DDE_FACK;
}
{
wxString item_name = DDEStringFromAtom(hsz2);
- int user_size = -1;
- char *data = connection->OnRequest(connection->m_topicName,
- item_name,
- &user_size,
- (wxIPCFormat) wFmt);
+ size_t user_size = wxNO_LEN;
+ const void *data = connection->OnRequest(connection->m_topicName,
+ item_name,
+ &user_size,
+ (wxIPCFormat)wFmt);
if (data)
{
- if (user_size < 0)
- user_size = wxStrlen((wxChar*)data) + 1;
+ if (user_size == wxNO_LEN)
+ switch (wFmt)
+ {
+ case wxIPC_TEXT:
+ case wxIPC_UTF8TEXT:
+ user_size = strlen((const char*)data) + 1; // includes final NUL
+ break;
+ case wxIPC_UNICODETEXT:
+ user_size = (wcslen((const wchar_t*)data) + 1) * sizeof(wchar_t); // includes final NUL
+ break;
+ default:
+ user_size = 0;
+ }
HDDEDATA handle = DdeCreateDataHandle(DDEIdInst,
(LPBYTE)data,
{
wxString item_name = DDEStringFromAtom(hsz2);
- DWORD len = DdeGetData(hData,
- (LPBYTE)connection->m_bufPtr,
- connection->m_bufSize,
- 0);
+ DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+ void *data = connection->GetBufferAtLeast(len);
+ wxASSERT_MSG(data != NULL,
+ wxT("Buffer too small in _DDECallback (XTYP_POKE)") );
+
+ DdeGetData(hData, (LPBYTE)data, len, 0);
+
DdeFreeDataHandle(hData);
connection->OnPoke(connection->m_topicName,
item_name,
- (wxChar*)connection->m_bufPtr,
+ data,
(int)len,
(wxIPCFormat) wFmt);
{
wxString item_name = DDEStringFromAtom(hsz2);
- DWORD len = DdeGetData(hData,
- (LPBYTE)connection->m_bufPtr,
- connection->m_bufSize,
- 0);
+ DWORD len = DdeGetData(hData, NULL, 0, 0);
+
+ void *data = connection->GetBufferAtLeast(len);
+ wxASSERT_MSG(data != NULL,
+ wxT("Buffer too small in _DDECallback (XTYP_ADVDATA)") );
+
+ DdeGetData(hData, (LPBYTE)data, len, 0);
+
DdeFreeDataHandle(hData);
if ( connection->OnAdvise(connection->m_topicName,
item_name,
- connection->m_bufPtr,
+ data,
(int)len,
(wxIPCFormat) wFmt) )
{
// ----------------------------------------------------------------------------
// 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;
}
-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") );
+ wxASSERT_MSG( DDEIdInst, wxT("DDE not initialized") );
- HSZ hsz = DdeCreateStringHandle(DDEIdInst, (wxChar*) s.c_str(), DDE_CP);
+ HSZ hsz = DdeCreateStringHandle(DDEIdInst, const_cast<wxChar*>(static_cast<const wxChar*>(s.t_str())), DDE_CP);
if ( !hsz )
{
DDELogError(_("Failed to create DDE string"));
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;
}
+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 = DdeGetLastError(DDEIdInst);
}
- wxLogError(s + _T(": ") + DDEGetErrorMsg(error));
+ wxLogError(s + wxT(": ") + DDEGetErrorMsg(error));
}
static wxString DDEGetErrorMsg(UINT error)
projects / wxWidgets.git / blobdiff