src/msw/dde.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dde.cpp
// Purpose:     DDE classes
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/defs.h"
#endif

#if wxUSE_IPC

#ifndef WX_PRECOMP
#include "wx/utils.h"
#include "wx/app.h"
#endif

#include "wx/module.h"
#include "wx/dde.h"

#include "wx/msw/private.h"
#include <windows.h>
#include <ddeml.h>

#ifndef __TWIN32__
#ifdef __GNUWIN32__
#include "wx/msw/gnuwin32/extra.h"
#endif
#endif

#include <string.h>

#ifdef __WIN32__
#define _EXPORT /**/
#else
#define _EXPORT _export
#endif

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxServerBase)
IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxClientBase)
IMPLEMENT_CLASS(wxDDEConnection, wxConnectionBase)
#endif

static wxDDEConnection *DDEFindConnection(HCONV hConv);
static void DDEDeleteConnection(HCONV hConv);
static wxDDEServer *DDEFindServer(const wxString& s);

extern "C" HDDEDATA EXPENTRY _EXPORT _DDECallback(
WORD wType,
WORD wFmt,
HCONV hConv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD lData1,
DWORD lData2);

// Add topic name to atom table before using in conversations
static HSZ DDEAddAtom(const wxString& string);
static HSZ DDEGetAtom(const wxString& string);
static void DDEPrintError(void);

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

static wxList wxAtomTable(wxKEY_STRING);
static wxList wxDDEClientObjects;
static wxList wxDDEServerObjects;

char *DDEDefaultIPCBuffer = NULL;
int DDEDefaultIPCBufferSize = 0;

/*
 * Initialization
 *
 */

static bool DDEInitialized = FALSE;

void wxDDEInitialize()
{
  if (DDEInitialized)
    return;
  DDEInitialized = TRUE;

  // Should insert filter flags
  DdeInitialize(&DDEIdInst, (PFNCALLBACK)MakeProcInstance(
               (FARPROC)_DDECallback, wxGetInstance()),
               APPCLASS_STANDARD,
               0L);
}

/*
 * CleanUp
 */

void wxDDECleanUp()
{
  if (DDEIdInst != 0)
  {
    DdeUninitialize(DDEIdInst);
    DDEIdInst = 0;
  }
  if (DDEDefaultIPCBuffer)
    delete [] DDEDefaultIPCBuffer ;
}

// A module to allow DDE initialization/cleanup
// without calling these functions from app.cpp or from
// the user's application.

class wxDDEModule: public wxModule
{
DECLARE_DYNAMIC_CLASS(wxDDEModule)
public:
    wxDDEModule() {}
    bool OnInit() { wxDDEInitialize(); return TRUE; };
    void OnExit() { wxDDECleanUp(); };
};

IMPLEMENT_DYNAMIC_CLASS(wxDDEModule, wxModule)

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

// 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 = wxDDEServerObjects.First();
  while (node && !found)
  {
    wxDDEClient *object = (wxDDEClient *)node->Data();
    found = object->DeleteConnection((WXHCONV) hConv);
    node = node->Next();
  }
}

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

/*
 * Server
 *
 */

wxDDEServer::wxDDEServer(void)
{
  m_serviceName = "";
  wxDDEServerObjects.Append(this);
}

bool wxDDEServer::Create(const wxString& server_name)
{
  m_serviceName = server_name;
  HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)server_name, CP_WINANSI);

  if (DdeNameService(DDEIdInst, serviceName, (HSZ) NULL, DNS_REGISTER) == 0)
  {
    DDEPrintError();
    return FALSE;
  }
  return TRUE;
}

wxDDEServer::~wxDDEServer(void)
{
  if (m_serviceName != "")
  {
    HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)m_serviceName, CP_WINANSI);
    if (DdeNameService(DDEIdInst, serviceName, NULL, DNS_UNREGISTER) == 0)
    {
      DDEPrintError();
    }
  }
  wxDDEServerObjects.DeleteObject(this);

  wxNode *node = m_connections.First();
  while (node)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    wxNode *next = node->Next();
    connection->OnDisconnect(); // May delete the node implicitly
    node = next;
  }

  // If any left after this, delete them
  node = m_connections.First();
  while (node)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    wxNode *next = node->Next();
    delete connection;
    node = next;
  }
}

wxConnectionBase *wxDDEServer::OnAcceptConnection(const wxString& /* topic */)
{
	return new wxDDEConnection;
}

wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
{
  wxNode *node = m_connections.First();
  wxDDEConnection *found = NULL;
  while (node && !found)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    if (connection->m_hConv == conv)
      found = connection;
    else node = node->Next();
  }
  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)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    if (connection->m_hConv == conv)
    {
      found = TRUE;
      delete node;
    }
    else node = node->Next();
  }
  return found;
}


/*
 * Client
 *
 */


wxDDEClient::wxDDEClient(void)
{
  wxDDEClientObjects.Append(this);
}

wxDDEClient::~wxDDEClient(void)
{
  wxDDEClientObjects.DeleteObject(this);
  wxNode *node = m_connections.First();
  while (node)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    delete connection;  // Deletes the node implicitly (see ~wxDDEConnection)
    node = m_connections.First();
  }
}

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

wxConnectionBase *wxDDEClient::MakeConnection(const wxString& /* host */, const wxString& server_name, const wxString& topic)
{
  HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)server_name, CP_WINANSI);
  HSZ topic_atom = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)topic, CP_WINANSI);

  HCONV hConv = DdeConnect(DDEIdInst, serviceName, topic_atom, (PCONVCONTEXT)NULL);
  if (hConv == (HCONV) NULL)
    return (wxConnectionBase*) NULL;
  else
  {
    wxDDEConnection *connection = (wxDDEConnection*) OnMakeConnection();
    if (connection)
    {
      connection->m_hConv = (WXHCONV) hConv;
      connection->m_topicName = topic;
	  connection->m_client = this;
      m_connections.Append(connection);
      return connection;
    }
    else return (wxConnectionBase*) NULL;
  }
}

wxConnectionBase *wxDDEClient::OnMakeConnection(void)
{
	return new wxDDEConnection;
}

wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
{
  wxNode *node = m_connections.First();
  wxDDEConnection *found = NULL;
  while (node && !found)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    if (connection->m_hConv == conv)
      found = connection;
    else node = node->Next();
  }
  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)
  {
    wxDDEConnection *connection = (wxDDEConnection *)node->Data();
    if (connection->m_hConv == conv)
    {
      found = TRUE;
      delete node;
    }
    else node = node->Next();
  }
  return found;
}

/*
 * Connection
 */

wxDDEConnection::wxDDEConnection(char *buffer, int 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_topicName = "";

  m_client = NULL;
  m_server = NULL;

  m_hConv = 0;
  m_sendingData = NULL;
}

wxDDEConnection::wxDDEConnection(void)
{
  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;
  m_topicName = "";
}

wxDDEConnection::~wxDDEConnection(void)
{
	if (m_server)
		m_server->GetConnections().DeleteObject(this);
	else
	    m_client->GetConnections().DeleteObject(this);
}

// Calls that CLIENT can make
bool wxDDEConnection::Disconnect(void)
{
  DDEDeleteConnection((HCONV) m_hConv);
  return (DdeDisconnect((HCONV) m_hConv) != 0);
}

bool wxDDEConnection::Execute(char *data, int size, wxIPCFormat format)
{
  DWORD result;
  if (size < 0)
    size = strlen(data);

  size ++;

  return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
    NULL, format, XTYP_EXECUTE, 5000, &result) ? TRUE : FALSE);
}

char *wxDDEConnection::Request(const wxString& item, int *size, wxIPCFormat format)
{
  DWORD result;
  HSZ atom = DDEGetAtom(item);

  HDDEDATA returned_data = DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
    atom, format, XTYP_REQUEST, 5000, &result);

  DWORD len = DdeGetData(returned_data, (LPBYTE)(m_bufPtr), m_bufSize, 0);

  DdeFreeDataHandle(returned_data);

  if (size) *size = (int)len;
  if (len > 0)
  {
    return m_bufPtr;
  }
  else return NULL;
}

bool wxDDEConnection::Poke(const wxString& item, char *data, int size, wxIPCFormat format)
{
  DWORD result;
  if (size < 0)
    size = strlen(data);

  size ++;

  HSZ item_atom = DDEGetAtom(item);
  return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
    item_atom, format, XTYP_POKE, 5000, &result) ? TRUE : FALSE);
}

bool wxDDEConnection::StartAdvise(const wxString& item)
{
  DWORD result;
  HSZ atom = DDEGetAtom(item);

  return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
    atom, CF_TEXT, XTYP_ADVSTART, 5000, &result) ? TRUE : FALSE);
}

bool wxDDEConnection::StopAdvise(const wxString& item)
{
  DWORD result;
  HSZ atom = DDEGetAtom(item);

  return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
    atom, CF_TEXT, XTYP_ADVSTOP, 5000, &result) ? TRUE : FALSE);
}

// Calls that SERVER can make
bool wxDDEConnection::Advise(const wxString& item, char *data, int size, wxIPCFormat format)
{
  if (size < 0)
    size = strlen(data);

  size ++;

  HSZ item_atom = DDEGetAtom(item);
  HSZ topic_atom = DDEGetAtom(m_topicName);
  m_sendingData = data;
  m_dataSize = size;
  m_dataType = format;
  return (DdePostAdvise(DDEIdInst, topic_atom, item_atom) != 0);
}

bool wxDDEConnection::OnDisconnect(void)
{
	delete this;
	return TRUE;
}


#define DDERETURN HDDEDATA

HDDEDATA EXPENTRY _EXPORT _DDECallback(
WORD wType,
WORD wFmt,
HCONV hConv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD /* lData1 */,
DWORD /* lData2 */)
{
  switch (wType)
  {
    case XTYP_CONNECT:
    {
      char topic_buf[100];
      char server_buf[100];
      DdeQueryString(DDEIdInst, hsz1, (LPSTR)topic_buf, sizeof(topic_buf),
                     CP_WINANSI);
      DdeQueryString(DDEIdInst, hsz2, (LPSTR)server_buf, sizeof(topic_buf),
                     CP_WINANSI);
      wxDDEServer *server = DDEFindServer(server_buf);
      if (server)
      {
        wxDDEConnection *connection =
          (wxDDEConnection*) server->OnAcceptConnection(wxString(topic_buf));
        if (connection)
        {
          connection->m_server = server;
          server->GetConnections().Append(connection);
          connection->m_hConv = 0;
          connection->m_topicName = topic_buf;
          DDECurrentlyConnecting = connection;
          return (DDERETURN)TRUE;
        }
      }
      else return (DDERETURN)0;
      break;
    }

    case XTYP_CONNECT_CONFIRM:
    {
      if (DDECurrentlyConnecting)
      {
        DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
        DDECurrentlyConnecting = NULL;
        return (DDERETURN)TRUE;
      }
      else return 0;
      break;
    }

    case XTYP_DISCONNECT:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);
      if (connection && connection->OnDisconnect())
      {
        DDEDeleteConnection(hConv);  // Delete mapping: hConv => connection
        return (DDERETURN)TRUE;
      }
      else return (DDERETURN)0;
      break;
    }

    case XTYP_EXECUTE:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
        DdeFreeDataHandle(hData);
        if (connection->OnExecute(connection->m_topicName, connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt))
          return (DDERETURN)DDE_FACK;
        else
          return (DDERETURN)DDE_FNOTPROCESSED;
      } else return (DDERETURN)DDE_FNOTPROCESSED;
      break;
    }

    case XTYP_REQUEST:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        char item_name[200];
        DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
                     CP_WINANSI);

        int user_size = -1;
        char *data = connection->OnRequest(connection->m_topicName, wxString(item_name), &user_size, (wxIPCFormat) wFmt);
        if (data)
        {
          if (user_size < 0) user_size = strlen(data);

          HDDEDATA handle = DdeCreateDataHandle(DDEIdInst,
                 (LPBYTE)data, user_size + 1, 0, hsz2, wFmt, 0);
          return (DDERETURN)handle;
        } else return (DDERETURN)0;
      } else return (DDERETURN)0;
      break;
    }

    case XTYP_POKE:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        char item_name[200];
        DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
                     CP_WINANSI);
        DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
        DdeFreeDataHandle(hData);
        connection->OnPoke(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt);
        return (DDERETURN)DDE_FACK;
      } else return (DDERETURN)DDE_FNOTPROCESSED;
      break;
    }

    case XTYP_ADVSTART:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        char item_name[200];
        DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
                     CP_WINANSI);

        return (DDERETURN)connection->OnStartAdvise(connection->m_topicName, wxString(item_name));
      } else return (DDERETURN)0;
      break;
    }

    case XTYP_ADVSTOP:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        char item_name[200];
        DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
                     CP_WINANSI);
        return (DDERETURN)connection->OnStopAdvise(connection->m_topicName, wxString(item_name));
      } else return (DDERETURN)0;
      break;
    }

    case XTYP_ADVREQ:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection && connection->m_sendingData)
      {
        HDDEDATA data = DdeCreateDataHandle(DDEIdInst,
                          (LPBYTE)connection->m_sendingData,
                          connection->m_dataSize, 0, hsz2, connection->m_dataType, 0);
        connection->m_sendingData = NULL;
        return (DDERETURN)data;
      } else return (DDERETURN)NULL;
      break;
    }

    case XTYP_ADVDATA:
    {
      wxDDEConnection *connection = DDEFindConnection(hConv);

      if (connection)
      {
        char item_name[200];
        DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
                     CP_WINANSI);

        DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
        DdeFreeDataHandle(hData);
        if (connection->OnAdvise(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt))
          return (DDERETURN)DDE_FACK;
        else
          return (DDERETURN)DDE_FNOTPROCESSED;
      } else return (DDERETURN)DDE_FNOTPROCESSED;
      break;
    }
  }
  return 0;
}

// Atom table stuff
static HSZ DDEAddAtom(const wxString& string)
{
  HSZ atom = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)string, CP_WINANSI);
  wxAtomTable.Append(string, (wxObject *)atom);
  return atom;
}

static HSZ DDEGetAtom(const wxString& string)
{
  wxNode *node = wxAtomTable.Find(string);
  if (node)
    return (HSZ)node->Data();
  else
  {
    DDEAddAtom(string);
    return (HSZ)(wxAtomTable.Find(string)->Data());
  }
}

void DDEPrintError(void)
{
  char *err = NULL;
  switch (DdeGetLastError(DDEIdInst))
  {
    case DMLERR_ADVACKTIMEOUT:
      err = "A request for a synchronous advise transaction has timed out.";
      break;
    case DMLERR_BUSY:
      err = "The response to the transaction caused the DDE_FBUSY bit to be set.";
      break;
    case DMLERR_DATAACKTIMEOUT:
      err = "A request for a synchronous data transaction has timed out.";
      break;
    case DMLERR_DLL_NOT_INITIALIZED:
      err = "A DDEML function was called without first calling the DdeInitialize function,\n\ror an invalid instance identifier\n\rwas passed to a DDEML function.";
      break;
    case DMLERR_DLL_USAGE:
      err = "An application initialized as APPCLASS_MONITOR has\n\rattempted to perform a DDE transaction,\n\ror an application initialized as APPCMD_CLIENTONLY has \n\rattempted to perform server transactions.";
      break;
    case DMLERR_EXECACKTIMEOUT:
      err = "A request for a synchronous execute transaction has timed out.";
      break;
    case DMLERR_INVALIDPARAMETER:
      err = "A parameter failed to be validated by the DDEML.";
      break;
    case DMLERR_LOW_MEMORY:
      err = "A DDEML application has created a prolonged race condition.";
      break;
    case DMLERR_MEMORY_ERROR:
      err = "A memory allocation failed.";
      break;
    case DMLERR_NO_CONV_ESTABLISHED:
      err = "A client's attempt to establish a conversation has failed.";
      break;
    case DMLERR_NOTPROCESSED:
      err = "A transaction failed.";
      break;
    case DMLERR_POKEACKTIMEOUT:
      err = "A request for a synchronous poke transaction has timed out.";
      break;
    case DMLERR_POSTMSG_FAILED:
      err = "An internal call to the PostMessage function has failed. ";
      break;
    case DMLERR_REENTRANCY:
      err = "Reentrancy problem.";
      break;
    case DMLERR_SERVER_DIED:
      err = "A server-side transaction was attempted on a conversation\n\rthat was terminated by the client, or the server\n\rterminated before completing a transaction.";
      break;
    case DMLERR_SYS_ERROR:
      err = "An internal error has occurred in the DDEML.";
      break;
    case DMLERR_UNADVACKTIMEOUT:
      err = "A request to end an advise transaction has timed out.";
      break;
    case DMLERR_UNFOUND_QUEUE_ID:
      err = "An invalid transaction identifier was passed to a DDEML function.\n\rOnce the application has returned from an XTYP_XACT_COMPLETE callback,\n\rthe transaction identifier for that callback is no longer valid.";
      break;
    default:
      err = "Unrecognised error type.";
      break;
  }
  MessageBox((HWND) NULL, (LPCSTR)err, "DDE Error", MB_OK | MB_ICONINFORMATION);
}

#endif
  // wxUSE_IPC
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dde.cpp
	3	// Purpose: DDE classes
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "dde.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/defs.h"
	25	#endif
	26
	27	#if wxUSE_IPC
	28
	29	#ifndef WX_PRECOMP
	30	#include "wx/utils.h"
	31	#include "wx/app.h"
	32	#endif
	33
	34	#include "wx/module.h"
	35	#include "wx/dde.h"
	36
	37	#include "wx/msw/private.h"
	38	#include <windows.h>
	39	#include <ddeml.h>
	40
	41	#ifndef __TWIN32__
	42	#ifdef __GNUWIN32__
	43	#include "wx/msw/gnuwin32/extra.h"
	44	#endif
	45	#endif
	46
	47	#include <string.h>
	48
	49	#ifdef __WIN32__
	50	#define _EXPORT /**/
	51	#else
	52	#define _EXPORT _export
	53	#endif
	54
	55	#if !USE_SHARED_LIBRARY
	56	IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxServerBase)
	57	IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxClientBase)
	58	IMPLEMENT_CLASS(wxDDEConnection, wxConnectionBase)
	59	#endif
	60
	61	static wxDDEConnection *DDEFindConnection(HCONV hConv);
	62	static void DDEDeleteConnection(HCONV hConv);
	63	static wxDDEServer *DDEFindServer(const wxString& s);
	64
	65	extern "C" HDDEDATA EXPENTRY _EXPORT _DDECallback(
	66	WORD wType,
	67	WORD wFmt,
	68	HCONV hConv,
	69	HSZ hsz1,
	70	HSZ hsz2,
	71	HDDEDATA hData,
	72	DWORD lData1,
	73	DWORD lData2);
	74
	75	// Add topic name to atom table before using in conversations
	76	static HSZ DDEAddAtom(const wxString& string);
	77	static HSZ DDEGetAtom(const wxString& string);
	78	static void DDEPrintError(void);
	79
	80	static DWORD DDEIdInst = 0L;
	81	static wxDDEConnection *DDECurrentlyConnecting = NULL;
	82
	83	static wxList wxAtomTable(wxKEY_STRING);
	84	static wxList wxDDEClientObjects;
	85	static wxList wxDDEServerObjects;
	86
	87	char *DDEDefaultIPCBuffer = NULL;
	88	int DDEDefaultIPCBufferSize = 0;
	89
	90	/*
	91	* Initialization
	92	*
	93	*/
	94
	95	static bool DDEInitialized = FALSE;
	96
	97	void wxDDEInitialize()
	98	{
	99	if (DDEInitialized)
	100	return;
	101	DDEInitialized = TRUE;
	102
	103	// Should insert filter flags
	104	DdeInitialize(&DDEIdInst, (PFNCALLBACK)MakeProcInstance(
	105	(FARPROC)_DDECallback, wxGetInstance()),
	106	APPCLASS_STANDARD,
	107	0L);
	108	}
	109
	110	/*
	111	* CleanUp
	112	*/
	113
	114	void wxDDECleanUp()
	115	{
	116	if (DDEIdInst != 0)
	117	{
	118	DdeUninitialize(DDEIdInst);
	119	DDEIdInst = 0;
	120	}
	121	if (DDEDefaultIPCBuffer)
	122	delete [] DDEDefaultIPCBuffer ;
	123	}
	124
	125	// A module to allow DDE initialization/cleanup
	126	// without calling these functions from app.cpp or from
	127	// the user's application.
	128
	129	class wxDDEModule: public wxModule
	130	{
	131	DECLARE_DYNAMIC_CLASS(wxDDEModule)
	132	public:
	133	wxDDEModule() {}
	134	bool OnInit() { wxDDEInitialize(); return TRUE; };
	135	void OnExit() { wxDDECleanUp(); };
	136	};
	137
	138	IMPLEMENT_DYNAMIC_CLASS(wxDDEModule, wxModule)
	139
	140	// Global find connection
	141	static wxDDEConnection *DDEFindConnection(HCONV hConv)
	142	{
	143	wxNode *node = wxDDEServerObjects.First();
	144	wxDDEConnection *found = NULL;
	145	while (node && !found)
	146	{
	147	wxDDEServer object = (wxDDEServer )node->Data();
	148	found = object->FindConnection((WXHCONV) hConv);
	149	node = node->Next();
	150	}
	151	if (found)
	152	return found;
	153
	154	node = wxDDEClientObjects.First();
	155	while (node && !found)
	156	{
	157	wxDDEClient object = (wxDDEClient )node->Data();
	158	found = object->FindConnection((WXHCONV) hConv);
	159	node = node->Next();
	160	}
	161	return found;
	162	}
	163
	164	// Global delete connection
	165	static void DDEDeleteConnection(HCONV hConv)
	166	{
	167	wxNode *node = wxDDEServerObjects.First();
	168	bool found = FALSE;
	169	while (node && !found)
	170	{
	171	wxDDEServer object = (wxDDEServer )node->Data();
	172	found = object->DeleteConnection((WXHCONV) hConv);
	173	node = node->Next();
	174	}
	175	if (found)
	176	return;
	177
	178	node = wxDDEServerObjects.First();
	179	while (node && !found)
	180	{
	181	wxDDEClient object = (wxDDEClient )node->Data();
	182	found = object->DeleteConnection((WXHCONV) hConv);
	183	node = node->Next();
	184	}
	185	}
	186
	187	// Find a server from a service name
	188	static wxDDEServer *DDEFindServer(const wxString& s)
	189	{
	190	wxNode *node = wxDDEServerObjects.First();
	191	wxDDEServer *found = NULL;
	192	while (node && !found)
	193	{
	194	wxDDEServer object = (wxDDEServer )node->Data();
	195
	196	if (object->GetServiceName() == s)
	197	found = object;
	198	else node = node->Next();
	199	}
	200	return found;
	201	}
	202
	203	/*
	204	* Server
	205	*
	206	*/
	207
	208	wxDDEServer::wxDDEServer(void)
	209	{
	210	m_serviceName = "";
	211	wxDDEServerObjects.Append(this);
	212	}
	213
	214	bool wxDDEServer::Create(const wxString& server_name)
	215	{
	216	m_serviceName = server_name;
	217	HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char) (const char )server_name, CP_WINANSI);
	218
	219	if (DdeNameService(DDEIdInst, serviceName, (HSZ) NULL, DNS_REGISTER) == 0)
	220	{
	221	DDEPrintError();
	222	return FALSE;
	223	}
	224	return TRUE;
	225	}
	226
	227	wxDDEServer::~wxDDEServer(void)
	228	{
	229	if (m_serviceName != "")
	230	{
	231	HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char) (const char )m_serviceName, CP_WINANSI);
	232	if (DdeNameService(DDEIdInst, serviceName, NULL, DNS_UNREGISTER) == 0)
	233	{
	234	DDEPrintError();
	235	}
	236	}
	237	wxDDEServerObjects.DeleteObject(this);
	238
	239	wxNode *node = m_connections.First();
	240	while (node)
	241	{
	242	wxDDEConnection connection = (wxDDEConnection )node->Data();
	243	wxNode *next = node->Next();
	244	connection->OnDisconnect(); // May delete the node implicitly
	245	node = next;
	246	}
	247
	248	// If any left after this, delete them
	249	node = m_connections.First();
	250	while (node)
	251	{
	252	wxDDEConnection connection = (wxDDEConnection )node->Data();
	253	wxNode *next = node->Next();
	254	delete connection;
	255	node = next;
	256	}
	257	}
	258
	259	wxConnectionBase wxDDEServer::OnAcceptConnection(const wxString& / topic */)
	260	{
	261	return new wxDDEConnection;
	262	}
	263
	264	wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
	265	{
	266	wxNode *node = m_connections.First();
	267	wxDDEConnection *found = NULL;
	268	while (node && !found)
	269	{
	270	wxDDEConnection connection = (wxDDEConnection )node->Data();
	271	if (connection->m_hConv == conv)
	272	found = connection;
	273	else node = node->Next();
	274	}
	275	return found;
	276	}
	277
	278	// Only delete the entry in the map, not the actual connection
	279	bool wxDDEServer::DeleteConnection(WXHCONV conv)
	280	{
	281	wxNode *node = m_connections.First();
	282	bool found = FALSE;
	283	while (node && !found)
	284	{
	285	wxDDEConnection connection = (wxDDEConnection )node->Data();
	286	if (connection->m_hConv == conv)
	287	{
	288	found = TRUE;
	289	delete node;
	290	}
	291	else node = node->Next();
	292	}
	293	return found;
	294	}
	295
	296
	297	/*
	298	* Client
	299	*
	300	*/
	301
	302
	303	wxDDEClient::wxDDEClient(void)
	304	{
	305	wxDDEClientObjects.Append(this);
	306	}
	307
	308	wxDDEClient::~wxDDEClient(void)
	309	{
	310	wxDDEClientObjects.DeleteObject(this);
	311	wxNode *node = m_connections.First();
	312	while (node)
	313	{
	314	wxDDEConnection connection = (wxDDEConnection )node->Data();
	315	delete connection; // Deletes the node implicitly (see ~wxDDEConnection)
	316	node = m_connections.First();
	317	}
	318	}
	319
	320	bool wxDDEClient::ValidHost(const wxString& /* host */)
	321	{
	322	return TRUE;
	323	}
	324
	325	wxConnectionBase wxDDEClient::MakeConnection(const wxString& / host */, const wxString& server_name, const wxString& topic)
	326	{
	327	HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char) (const char )server_name, CP_WINANSI);
	328	HSZ topic_atom = DdeCreateStringHandle(DDEIdInst, (char) (const char )topic, CP_WINANSI);
	329
	330	HCONV hConv = DdeConnect(DDEIdInst, serviceName, topic_atom, (PCONVCONTEXT)NULL);
	331	if (hConv == (HCONV) NULL)
	332	return (wxConnectionBase*) NULL;
	333	else
	334	{
	335	wxDDEConnection connection = (wxDDEConnection) OnMakeConnection();
	336	if (connection)
	337	{
	338	connection->m_hConv = (WXHCONV) hConv;
	339	connection->m_topicName = topic;
	340	connection->m_client = this;
	341	m_connections.Append(connection);
	342	return connection;
	343	}
	344	else return (wxConnectionBase*) NULL;
	345	}
	346	}
	347
	348	wxConnectionBase *wxDDEClient::OnMakeConnection(void)
	349	{
	350	return new wxDDEConnection;
	351	}
	352
	353	wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
	354	{
	355	wxNode *node = m_connections.First();
	356	wxDDEConnection *found = NULL;
	357	while (node && !found)
	358	{
	359	wxDDEConnection connection = (wxDDEConnection )node->Data();
	360	if (connection->m_hConv == conv)
	361	found = connection;
	362	else node = node->Next();
	363	}
	364	return found;
	365	}
	366
	367	// Only delete the entry in the map, not the actual connection
	368	bool wxDDEClient::DeleteConnection(WXHCONV conv)
	369	{
	370	wxNode *node = m_connections.First();
	371	bool found = FALSE;
	372	while (node && !found)
	373	{
	374	wxDDEConnection connection = (wxDDEConnection )node->Data();
	375	if (connection->m_hConv == conv)
	376	{
	377	found = TRUE;
	378	delete node;
	379	}
	380	else node = node->Next();
	381	}
	382	return found;
	383	}
	384
	385	/*
	386	* Connection
	387	*/
	388
	389	wxDDEConnection::wxDDEConnection(char *buffer, int size)
	390	{
	391	if (buffer == NULL)
	392	{
	393	if (DDEDefaultIPCBuffer == NULL)
	394	DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
	395	m_bufPtr = DDEDefaultIPCBuffer;
	396	m_bufSize = DDEDefaultIPCBufferSize;
	397	}
	398	else
	399	{
	400	m_bufPtr = buffer;
	401	m_bufSize = size;
	402	}
	403
	404	m_topicName = "";
	405
	406	m_client = NULL;
	407	m_server = NULL;
	408
	409	m_hConv = 0;
	410	m_sendingData = NULL;
	411	}
	412
	413	wxDDEConnection::wxDDEConnection(void)
	414	{
	415	m_hConv = 0;
	416	m_sendingData = NULL;
	417	m_server = NULL;
	418	m_client = NULL;
	419	if (DDEDefaultIPCBuffer == NULL)
	420	DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
	421
	422	m_bufPtr = DDEDefaultIPCBuffer;
	423	m_bufSize = DDEDefaultIPCBufferSize;
	424	m_topicName = "";
	425	}
	426
	427	wxDDEConnection::~wxDDEConnection(void)
	428	{
	429	if (m_server)
	430	m_server->GetConnections().DeleteObject(this);
	431	else
	432	m_client->GetConnections().DeleteObject(this);
	433	}
	434
	435	// Calls that CLIENT can make
	436	bool wxDDEConnection::Disconnect(void)
	437	{
	438	DDEDeleteConnection((HCONV) m_hConv);
	439	return (DdeDisconnect((HCONV) m_hConv) != 0);
	440	}
	441
	442	bool wxDDEConnection::Execute(char *data, int size, wxIPCFormat format)
	443	{
	444	DWORD result;
	445	if (size < 0)
	446	size = strlen(data);
	447
	448	size ++;
	449
	450	return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
	451	NULL, format, XTYP_EXECUTE, 5000, &result) ? TRUE : FALSE);
	452	}
	453
	454	char wxDDEConnection::Request(const wxString& item, int size, wxIPCFormat format)
	455	{
	456	DWORD result;
	457	HSZ atom = DDEGetAtom(item);
	458
	459	HDDEDATA returned_data = DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
	460	atom, format, XTYP_REQUEST, 5000, &result);
	461
	462	DWORD len = DdeGetData(returned_data, (LPBYTE)(m_bufPtr), m_bufSize, 0);
	463
	464	DdeFreeDataHandle(returned_data);
	465
	466	if (size) *size = (int)len;
	467	if (len > 0)
	468	{
	469	return m_bufPtr;
	470	}
	471	else return NULL;
	472	}
	473
	474	bool wxDDEConnection::Poke(const wxString& item, char *data, int size, wxIPCFormat format)
	475	{
	476	DWORD result;
	477	if (size < 0)
	478	size = strlen(data);
	479
	480	size ++;
	481
	482	HSZ item_atom = DDEGetAtom(item);
	483	return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
	484	item_atom, format, XTYP_POKE, 5000, &result) ? TRUE : FALSE);
	485	}
	486
	487	bool wxDDEConnection::StartAdvise(const wxString& item)
	488	{
	489	DWORD result;
	490	HSZ atom = DDEGetAtom(item);
	491
	492	return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
	493	atom, CF_TEXT, XTYP_ADVSTART, 5000, &result) ? TRUE : FALSE);
	494	}
	495
	496	bool wxDDEConnection::StopAdvise(const wxString& item)
	497	{
	498	DWORD result;
	499	HSZ atom = DDEGetAtom(item);
	500
	501	return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
	502	atom, CF_TEXT, XTYP_ADVSTOP, 5000, &result) ? TRUE : FALSE);
	503	}
	504
	505	// Calls that SERVER can make
	506	bool wxDDEConnection::Advise(const wxString& item, char *data, int size, wxIPCFormat format)
	507	{
	508	if (size < 0)
	509	size = strlen(data);
	510
	511	size ++;
	512
	513	HSZ item_atom = DDEGetAtom(item);
	514	HSZ topic_atom = DDEGetAtom(m_topicName);
	515	m_sendingData = data;
	516	m_dataSize = size;
	517	m_dataType = format;
	518	return (DdePostAdvise(DDEIdInst, topic_atom, item_atom) != 0);
	519	}
	520
	521	bool wxDDEConnection::OnDisconnect(void)
	522	{
	523	delete this;
	524	return TRUE;
	525	}
	526
	527
	528	#define DDERETURN HDDEDATA
	529
	530	HDDEDATA EXPENTRY _EXPORT _DDECallback(
	531	WORD wType,
	532	WORD wFmt,
	533	HCONV hConv,
	534	HSZ hsz1,
	535	HSZ hsz2,
	536	HDDEDATA hData,
	537	DWORD /* lData1 */,
	538	DWORD /* lData2 */)
	539	{
	540	switch (wType)
	541	{
	542	case XTYP_CONNECT:
	543	{
	544	char topic_buf[100];
	545	char server_buf[100];
	546	DdeQueryString(DDEIdInst, hsz1, (LPSTR)topic_buf, sizeof(topic_buf),
	547	CP_WINANSI);
	548	DdeQueryString(DDEIdInst, hsz2, (LPSTR)server_buf, sizeof(topic_buf),
	549	CP_WINANSI);
	550	wxDDEServer *server = DDEFindServer(server_buf);
	551	if (server)
	552	{
	553	wxDDEConnection *connection =
	554	(wxDDEConnection*) server->OnAcceptConnection(wxString(topic_buf));
	555	if (connection)
	556	{
	557	connection->m_server = server;
	558	server->GetConnections().Append(connection);
	559	connection->m_hConv = 0;
	560	connection->m_topicName = topic_buf;
	561	DDECurrentlyConnecting = connection;
	562	return (DDERETURN)TRUE;
	563	}
	564	}
	565	else return (DDERETURN)0;
	566	break;
	567	}
	568
	569	case XTYP_CONNECT_CONFIRM:
	570	{
	571	if (DDECurrentlyConnecting)
	572	{
	573	DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
	574	DDECurrentlyConnecting = NULL;
	575	return (DDERETURN)TRUE;
	576	}
	577	else return 0;
	578	break;
	579	}
	580
	581	case XTYP_DISCONNECT:
	582	{
	583	wxDDEConnection *connection = DDEFindConnection(hConv);
	584	if (connection && connection->OnDisconnect())
	585	{
	586	DDEDeleteConnection(hConv); // Delete mapping: hConv => connection
	587	return (DDERETURN)TRUE;
	588	}
	589	else return (DDERETURN)0;
	590	break;
	591	}
	592
	593	case XTYP_EXECUTE:
	594	{
	595	wxDDEConnection *connection = DDEFindConnection(hConv);
	596
	597	if (connection)
	598	{
	599	DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
	600	DdeFreeDataHandle(hData);
	601	if (connection->OnExecute(connection->m_topicName, connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt))
	602	return (DDERETURN)DDE_FACK;
	603	else
	604	return (DDERETURN)DDE_FNOTPROCESSED;
	605	} else return (DDERETURN)DDE_FNOTPROCESSED;
	606	break;
	607	}
	608
	609	case XTYP_REQUEST:
	610	{
	611	wxDDEConnection *connection = DDEFindConnection(hConv);
	612
	613	if (connection)
	614	{
	615	char item_name[200];
	616	DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
	617	CP_WINANSI);
	618
	619	int user_size = -1;
	620	char *data = connection->OnRequest(connection->m_topicName, wxString(item_name), &user_size, (wxIPCFormat) wFmt);
	621	if (data)
	622	{
	623	if (user_size < 0) user_size = strlen(data);
	624
	625	HDDEDATA handle = DdeCreateDataHandle(DDEIdInst,
	626	(LPBYTE)data, user_size + 1, 0, hsz2, wFmt, 0);
	627	return (DDERETURN)handle;
	628	} else return (DDERETURN)0;
	629	} else return (DDERETURN)0;
	630	break;
	631	}
	632
	633	case XTYP_POKE:
	634	{
	635	wxDDEConnection *connection = DDEFindConnection(hConv);
	636
	637	if (connection)
	638	{
	639	char item_name[200];
	640	DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
	641	CP_WINANSI);
	642	DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
	643	DdeFreeDataHandle(hData);
	644	connection->OnPoke(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt);
	645	return (DDERETURN)DDE_FACK;
	646	} else return (DDERETURN)DDE_FNOTPROCESSED;
	647	break;
	648	}
	649
	650	case XTYP_ADVSTART:
	651	{
	652	wxDDEConnection *connection = DDEFindConnection(hConv);
	653
	654	if (connection)
	655	{
	656	char item_name[200];
	657	DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
	658	CP_WINANSI);
	659
	660	return (DDERETURN)connection->OnStartAdvise(connection->m_topicName, wxString(item_name));
	661	} else return (DDERETURN)0;
	662	break;
	663	}
	664
	665	case XTYP_ADVSTOP:
	666	{
	667	wxDDEConnection *connection = DDEFindConnection(hConv);
	668
	669	if (connection)
	670	{
	671	char item_name[200];
	672	DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
	673	CP_WINANSI);
	674	return (DDERETURN)connection->OnStopAdvise(connection->m_topicName, wxString(item_name));
	675	} else return (DDERETURN)0;
	676	break;
	677	}
	678
	679	case XTYP_ADVREQ:
	680	{
	681	wxDDEConnection *connection = DDEFindConnection(hConv);
	682
	683	if (connection && connection->m_sendingData)
	684	{
	685	HDDEDATA data = DdeCreateDataHandle(DDEIdInst,
	686	(LPBYTE)connection->m_sendingData,
	687	connection->m_dataSize, 0, hsz2, connection->m_dataType, 0);
	688	connection->m_sendingData = NULL;
	689	return (DDERETURN)data;
	690	} else return (DDERETURN)NULL;
	691	break;
	692	}
	693
	694	case XTYP_ADVDATA:
	695	{
	696	wxDDEConnection *connection = DDEFindConnection(hConv);
	697
	698	if (connection)
	699	{
	700	char item_name[200];
	701	DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
	702	CP_WINANSI);
	703
	704	DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
	705	DdeFreeDataHandle(hData);
	706	if (connection->OnAdvise(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxIPCFormat) wFmt))
	707	return (DDERETURN)DDE_FACK;
	708	else
	709	return (DDERETURN)DDE_FNOTPROCESSED;
	710	} else return (DDERETURN)DDE_FNOTPROCESSED;
	711	break;
	712	}
	713	}
	714	return 0;
	715	}
	716
	717	// Atom table stuff
	718	static HSZ DDEAddAtom(const wxString& string)
	719	{
	720	HSZ atom = DdeCreateStringHandle(DDEIdInst, (char) (const char )string, CP_WINANSI);
	721	wxAtomTable.Append(string, (wxObject *)atom);
	722	return atom;
	723	}
	724
	725	static HSZ DDEGetAtom(const wxString& string)
	726	{
	727	wxNode *node = wxAtomTable.Find(string);
	728	if (node)
	729	return (HSZ)node->Data();
	730	else
	731	{
	732	DDEAddAtom(string);
	733	return (HSZ)(wxAtomTable.Find(string)->Data());
	734	}
	735	}
	736
	737	void DDEPrintError(void)
	738	{
	739	char *err = NULL;
	740	switch (DdeGetLastError(DDEIdInst))
	741	{
	742	case DMLERR_ADVACKTIMEOUT:
	743	err = "A request for a synchronous advise transaction has timed out.";
	744	break;
	745	case DMLERR_BUSY:
	746	err = "The response to the transaction caused the DDE_FBUSY bit to be set.";
	747	break;
	748	case DMLERR_DATAACKTIMEOUT:
	749	err = "A request for a synchronous data transaction has timed out.";
	750	break;
	751	case DMLERR_DLL_NOT_INITIALIZED:
	752	err = "A DDEML function was called without first calling the DdeInitialize function,\n\ror an invalid instance identifier\n\rwas passed to a DDEML function.";
	753	break;
	754	case DMLERR_DLL_USAGE:
	755	err = "An application initialized as APPCLASS_MONITOR has\n\rattempted to perform a DDE transaction,\n\ror an application initialized as APPCMD_CLIENTONLY has \n\rattempted to perform server transactions.";
	756	break;
	757	case DMLERR_EXECACKTIMEOUT:
	758	err = "A request for a synchronous execute transaction has timed out.";
	759	break;
	760	case DMLERR_INVALIDPARAMETER:
	761	err = "A parameter failed to be validated by the DDEML.";
	762	break;
	763	case DMLERR_LOW_MEMORY:
	764	err = "A DDEML application has created a prolonged race condition.";
	765	break;
	766	case DMLERR_MEMORY_ERROR:
	767	err = "A memory allocation failed.";
	768	break;
	769	case DMLERR_NO_CONV_ESTABLISHED:
	770	err = "A client's attempt to establish a conversation has failed.";
	771	break;
	772	case DMLERR_NOTPROCESSED:
	773	err = "A transaction failed.";
	774	break;
	775	case DMLERR_POKEACKTIMEOUT:
	776	err = "A request for a synchronous poke transaction has timed out.";
	777	break;
	778	case DMLERR_POSTMSG_FAILED:
	779	err = "An internal call to the PostMessage function has failed. ";
	780	break;
	781	case DMLERR_REENTRANCY:
	782	err = "Reentrancy problem.";
	783	break;
	784	case DMLERR_SERVER_DIED:
	785	err = "A server-side transaction was attempted on a conversation\n\rthat was terminated by the client, or the server\n\rterminated before completing a transaction.";
	786	break;
	787	case DMLERR_SYS_ERROR:
	788	err = "An internal error has occurred in the DDEML.";
	789	break;
	790	case DMLERR_UNADVACKTIMEOUT:
	791	err = "A request to end an advise transaction has timed out.";
	792	break;
	793	case DMLERR_UNFOUND_QUEUE_ID:
	794	err = "An invalid transaction identifier was passed to a DDEML function.\n\rOnce the application has returned from an XTYP_XACT_COMPLETE callback,\n\rthe transaction identifier for that callback is no longer valid.";
	795	break;
	796	default:
	797	err = "Unrecognised error type.";
	798	break;
	799	}
	800	MessageBox((HWND) NULL, (LPCSTR)err, "DDE Error", MB_OK \| MB_ICONINFORMATION);
	801	}
	802
	803	#endif
	804	// wxUSE_IPC