dde_private.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	WINE_DDEHEAD
struct	tagHSZNode
struct	tagWDML_SERVER
struct	tagWDML_XACT
struct	tagWDML_CONV
struct	tagWDML_LINK
struct	tagWDML_INSTANCE
struct	tagDDE_DATAHANDLE_HEAD

Macros
#define	MAX_ATOM_LEN   255
#define	MAX_BUFFER_LEN   (MAX_ATOM_LEN + 1)
#define	WDML_CONV_MAGIC   0xbabe1234
#define	WM_WDML_REGISTER   (WM_USER + 0x200)
#define	WM_WDML_UNREGISTER   (WM_USER + 0x201)
#define	WM_WDML_CONNECT_CONFIRM   (WM_USER + 0x202)
#define	GWL_WDML_INSTANCE   (0)
#define	GWL_WDML_CONVERSATION   (sizeof(ULONG_PTR))
#define	GWL_WDML_SERVER   (sizeof(ULONG_PTR))

Typedefs
typedef struct tagHSZNode	HSZNode
typedef struct tagWDML_SERVER	WDML_SERVER
typedef struct tagWDML_XACT	WDML_XACT
typedef struct tagWDML_CONV	WDML_CONV
typedef struct tagWDML_LINK	WDML_LINK
typedef struct tagWDML_INSTANCE	WDML_INSTANCE
typedef struct tagDDE_DATAHANDLE_HEAD	DDE_DATAHANDLE_HEAD
typedef enum tagWDML_SIDE	WDML_SIDE

Enumerations
enum	tagWDML_SIDE { WDML_CLIENT_SIDE = 0 , WDML_SERVER_SIDE = 1 }
enum	WDML_QUEUE_STATE {   WDML_QS_ERROR , WDML_QS_HANDLED , WDML_QS_PASS , WDML_QS_SWALLOWED ,   WDML_QS_BLOCK }

Functions
HDDEDATA	WDML_InvokeCallback (WDML_INSTANCE *pInst, UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA hdata, ULONG_PTR dwData1, ULONG_PTR dwData2) DECLSPEC_HIDDEN
WDML_SERVER *	WDML_AddServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic) DECLSPEC_HIDDEN
void	WDML_RemoveServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic) DECLSPEC_HIDDEN
WDML_SERVER *	WDML_FindServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic) DECLSPEC_HIDDEN
WDML_QUEUE_STATE	WDML_ServerHandle (WDML_CONV *pConv, WDML_XACT *pXAct) DECLSPEC_HIDDEN
HDDEDATA	WDML_ClientHandle (WDML_CONV *pConv, WDML_XACT *pXAct, DWORD dwTimeout, LPDWORD pdwResult) DECLSPEC_HIDDEN
WDML_CONV *	WDML_AddConv (WDML_INSTANCE *pInstance, WDML_SIDE side, HSZ hszService, HSZ hszTopic, HWND hwndClient, HWND hwndServer) DECLSPEC_HIDDEN
void	WDML_RemoveConv (WDML_CONV *pConv, WDML_SIDE side) DECLSPEC_HIDDEN
WDML_CONV *	WDML_GetConv (HCONV hConv, BOOL checkConnected) DECLSPEC_HIDDEN
WDML_CONV *	WDML_GetConvFromWnd (HWND hWnd) DECLSPEC_HIDDEN
WDML_CONV *	WDML_FindConv (WDML_INSTANCE *pInstance, WDML_SIDE side, HSZ hszService, HSZ hszTopic) DECLSPEC_HIDDEN
BOOL	WDML_PostAck (WDML_CONV *pConv, WDML_SIDE side, WORD appRetCode, BOOL fBusy, BOOL fAck, UINT_PTR pmt, LPARAM lParam, UINT oldMsg) DECLSPEC_HIDDEN
void	WDML_AddLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, UINT wType, HSZ hszItem, UINT wFmt) DECLSPEC_HIDDEN
WDML_LINK *	WDML_FindLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, HSZ hszItem, BOOL use_fmt, UINT uFmt) DECLSPEC_HIDDEN
void	WDML_RemoveLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, HSZ hszItem, UINT wFmt) DECLSPEC_HIDDEN
BOOL	WDML_DecHSZ (WDML_INSTANCE *pInstance, HSZ hsz) DECLSPEC_HIDDEN
BOOL	WDML_IncHSZ (WDML_INSTANCE *pInstance, HSZ hsz) DECLSPEC_HIDDEN
ATOM	WDML_MakeAtomFromHsz (HSZ hsz) DECLSPEC_HIDDEN
HSZ	WDML_MakeHszFromAtom (const WDML_INSTANCE *pInstance, ATOM atom) DECLSPEC_HIDDEN
WDML_XACT *	WDML_AllocTransaction (WDML_INSTANCE *pInstance, UINT ddeMsg, UINT wFmt, HSZ hszItem) DECLSPEC_HIDDEN
void	WDML_QueueTransaction (WDML_CONV *pConv, WDML_XACT *pXAct) DECLSPEC_HIDDEN
BOOL	WDML_UnQueueTransaction (WDML_CONV *pConv, WDML_XACT *pXAct) DECLSPEC_HIDDEN
void	WDML_FreeTransaction (WDML_INSTANCE *pInstance, WDML_XACT *pXAct, BOOL doFreePmt) DECLSPEC_HIDDEN
HGLOBAL	WDML_DataHandle2Global (HDDEDATA hDdeData, BOOL fResponse, BOOL fRelease, BOOL fDeferUpd, BOOL dAckReq) DECLSPEC_HIDDEN
HDDEDATA	WDML_Global2DataHandle (WDML_CONV *pConv, HGLOBAL hMem, WINE_DDEHEAD *da) DECLSPEC_HIDDEN
BOOL	WDML_IsAppOwned (HDDEDATA hDdeData) DECLSPEC_HIDDEN
WDML_INSTANCE *	WDML_GetInstance (DWORD InstId) DECLSPEC_HIDDEN
WDML_INSTANCE *	WDML_GetInstanceFromWnd (HWND hWnd) DECLSPEC_HIDDEN
void	WDML_BroadcastDDEWindows (LPCWSTR clsName, UINT uMsg, WPARAM wParam, LPARAM lParam) DECLSPEC_HIDDEN
void	WDML_NotifyThreadExit (DWORD tid) DECLSPEC_HIDDEN
void	WDML_NotifyThreadDetach (void) DECLSPEC_HIDDEN
static __inline void	WDML_ExtractAck (WORD status, DDEACK *da)

Variables
const WCHAR WDML_szEventClass[]	DECLSPEC_HIDDEN

Macro Definition Documentation

GWL_WDML_CONVERSATION

#define GWL_WDML_CONVERSATION   (sizeof(ULONG_PTR))

Definition at line 260 of file dde_private.h.

GWL_WDML_INSTANCE

#define GWL_WDML_INSTANCE   (0)

Definition at line 259 of file dde_private.h.

GWL_WDML_SERVER

#define GWL_WDML_SERVER   (sizeof(ULONG_PTR))

Definition at line 261 of file dde_private.h.

MAX_ATOM_LEN

#define MAX_ATOM_LEN   255

Definition at line 30 of file dde_private.h.

MAX_BUFFER_LEN

#define MAX_BUFFER_LEN   (MAX_ATOM_LEN + 1)

Definition at line 34 of file dde_private.h.

WDML_CONV_MAGIC

#define WDML_CONV_MAGIC   0xbabe1234

Definition at line 141 of file dde_private.h.

WM_WDML_CONNECT_CONFIRM

#define WM_WDML_CONNECT_CONFIRM   (WM_USER + 0x202)

Definition at line 250 of file dde_private.h.

WM_WDML_REGISTER

#define WM_WDML_REGISTER   (WM_USER + 0x200)

Definition at line 248 of file dde_private.h.

WM_WDML_UNREGISTER

#define WM_WDML_UNREGISTER   (WM_USER + 0x201)

Definition at line 249 of file dde_private.h.

Typedef Documentation

DDE_DATAHANDLE_HEAD

typedef struct tagDDE_DATAHANDLE_HEAD DDE_DATAHANDLE_HEAD

HSZNode

typedef struct tagHSZNode HSZNode

WDML_CONV

typedef struct tagWDML_CONV WDML_CONV

WDML_INSTANCE

typedef struct tagWDML_INSTANCE WDML_INSTANCE

WDML_LINK

typedef struct tagWDML_LINK WDML_LINK

WDML_SERVER

typedef struct tagWDML_SERVER WDML_SERVER

WDML_SIDE

typedef enum tagWDML_SIDE WDML_SIDE

WDML_XACT

typedef struct tagWDML_XACT WDML_XACT

Enumeration Type Documentation

tagWDML_SIDE

enum tagWDML_SIDE

Enumerator
WDML_CLIENT_SIDE
WDML_SERVER_SIDE

Definition at line 179 of file dde_private.h.

{
    WDML_CLIENT_SIDE = 0, WDML_SERVER_SIDE = 1
} WDML_SIDE;

WDML_QUEUE_STATE

enum WDML_QUEUE_STATE

Enumerator
WDML_QS_ERROR
WDML_QS_HANDLED
WDML_QS_PASS
WDML_QS_SWALLOWED
WDML_QS_BLOCK

Definition at line 184 of file dde_private.h.

             {
    WDML_QS_ERROR, WDML_QS_HANDLED, WDML_QS_PASS, WDML_QS_SWALLOWED, WDML_QS_BLOCK,
} WDML_QUEUE_STATE;

Function Documentation

WDML_AddConv()

WDML_CONV * WDML_AddConv	(	WDML_INSTANCE *	pInstance,
		WDML_SIDE	side,
		HSZ	hszService,
		HSZ	hszTopic,
		HWND	hwndClient,
		HWND	hwndServer
	)

Definition at line 2008 of file ddemisc.c.

{
    WDML_CONV*  pConv;
 
    /* no conversation yet, add it */
    pConv = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_CONV));
    if (!pConv) return NULL;
 
    pConv->instance = pInstance;
    WDML_IncHSZ(pInstance, pConv->hszService = hszService);
    WDML_IncHSZ(pInstance, pConv->hszTopic = hszTopic);
    pConv->magic = WDML_CONV_MAGIC;
    pConv->hwndServer = hwndServer;
    pConv->hwndClient = hwndClient;
    pConv->transactions = NULL;
    pConv->hUser = 0;
    pConv->wStatus = (side == WDML_CLIENT_SIDE) ? ST_CLIENT : 0L;
    pConv->wStatus |= pInstance->wStatus;
    /* check if both side of the conversation are of the same instance */
    if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
    WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
    {
    pConv->wStatus |= ST_ISSELF;
    }
    pConv->wConvst = XST_NULL;
 
    pConv->next = pInstance->convs[side];
    pInstance->convs[side] = pConv;
 
    TRACE("pConv->wStatus %04x pInstance(%p)\n", pConv->wStatus, pInstance);
 
    return pConv;
}

Referenced by WDML_ClientProc(), and WDML_CreateServerConv().

WDML_AddLink()

void WDML_AddLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		UINT	wType,
		HSZ	hszItem,
		UINT	wFmt
	)

Definition at line 1755 of file ddemisc.c.

{
    WDML_LINK*  pLink;
 
    pLink = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_LINK));
    if (pLink == NULL)
    {
    ERR("OOM\n");
    return;
    }
 
    pLink->hConv = hConv;
    pLink->transactionType = wType;
    WDML_IncHSZ(pInstance, pLink->hszItem = hszItem);
    pLink->uFmt = wFmt;
    pLink->next = pInstance->links[side];
    pInstance->links[side] = pLink;
}

Referenced by WDML_HandleAdviseReply(), and WDML_ServerHandleAdvise().

WDML_AddServer()

WDML_SERVER * WDML_AddServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1638 of file ddemisc.c.

{
    static const WCHAR fmtW[] = {'%','s','(','0','x','%','*','x',')',0};
    WDML_SERVER*    pServer;
    WCHAR       buf1[256];
    WCHAR       buf2[256];
 
    pServer = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_SERVER));
    if (pServer == NULL) return NULL;
 
    pServer->hszService = hszService;
    WDML_IncHSZ(pInstance, hszService);
 
    DdeQueryStringW(pInstance->instanceID, hszService, buf1, 256, CP_WINUNICODE);
    snprintfW(buf2, 256, fmtW, buf1, 2*sizeof(ULONG_PTR), GetCurrentProcessId());
    pServer->hszServiceSpec = DdeCreateStringHandleW(pInstance->instanceID, buf2, CP_WINUNICODE);
 
    pServer->atomService = WDML_MakeAtomFromHsz(pServer->hszService);
    pServer->atomServiceSpec = WDML_MakeAtomFromHsz(pServer->hszServiceSpec);
 
    pServer->filterOn = TRUE;
 
    pServer->next = pInstance->servers;
    pInstance->servers = pServer;
    return pServer;
}

Referenced by DdeNameService().

WDML_AllocTransaction()

WDML_XACT * WDML_AllocTransaction	(	WDML_INSTANCE *	pInstance,
		UINT	ddeMsg,
		UINT	wFmt,
		HSZ	hszItem
	)

Definition at line 1900 of file ddemisc.c.

{
    WDML_XACT*      pXAct;
    static WORD     tid = 1;    /* FIXME: wrap around */
 
    pXAct = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_XACT));
    if (!pXAct)
    {
    pInstance->lastError = DMLERR_MEMORY_ERROR;
    return NULL;
    }
 
    pXAct->xActID = tid++;
    pXAct->ddeMsg = ddeMsg;
    pXAct->hDdeData = 0;
    pXAct->hUser = 0;
    pXAct->next = NULL;
    pXAct->wType = 0;
    pXAct->wFmt = wFmt;
    if ((pXAct->hszItem = hszItem)) WDML_IncHSZ(pInstance, pXAct->hszItem);
    pXAct->atom = 0;
    pXAct->hMem = 0;
    pXAct->lParam = 0;
 
    return pXAct;
}

Referenced by WDML_ClientQueueAdvise(), WDML_ClientQueueExecute(), WDML_ClientQueuePoke(), WDML_ClientQueueRequest(), WDML_ClientQueueTerminate(), WDML_ClientQueueUnadvise(), WDML_ServerQueueAdvise(), WDML_ServerQueueExecute(), WDML_ServerQueuePoke(), WDML_ServerQueueRequest(), WDML_ServerQueueTerminate(), and WDML_ServerQueueUnadvise().

WDML_BroadcastDDEWindows()

void WDML_BroadcastDDEWindows	(	LPCWSTR	clsName,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2502 of file ddemisc.c.

{
    struct tagWDML_BroadcastPmt s;
 
    s.clsName = clsName;
    s.uMsg    = uMsg;
    s.wParam  = wParam;
    s.lParam  = lParam;
    EnumWindows(WDML_BroadcastEnumProc, (LPARAM)&s);
}

Referenced by DdeNameService(), and WDML_RemoveServer().

WDML_ClientHandle()

HDDEDATA WDML_ClientHandle	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct,
		DWORD	dwTimeout,
		LPDWORD	pdwResult
	)

Definition at line 1090 of file ddeclient.c.

{
    HDDEDATA hDdeData;
 
    if (!PostMessageW(pConv->hwndServer, pXAct->ddeMsg, (WPARAM)pConv->hwndClient, pXAct->lParam))
    {
        WARN("Failed posting message %x to %p (error=0x%x)\n",
              pXAct->ddeMsg, pConv->hwndServer, GetLastError());
        pConv->wStatus &= ~ST_CONNECTED;
        pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
        return 0;
    }
    pXAct->dwTimeout = dwTimeout;
    /* FIXME: should set the app bits on *pdwResult */
 
    if (dwTimeout == TIMEOUT_ASYNC)
    {
        if (pdwResult)
            *pdwResult = MAKELONG(0, pXAct->xActID);
 
        hDdeData = (HDDEDATA)1;
    }
    else
        hDdeData = WDML_SyncWaitTransactionReply((HCONV)pConv, dwTimeout, pXAct, pdwResult);
 
    return hDdeData;
}

Referenced by DdeClientTransaction(), and WDML_EnableCallback().

WDML_DataHandle2Global()

HGLOBAL WDML_DataHandle2Global	(	HDDEDATA	hDdeData,
		BOOL	fResponse,
		BOOL	fRelease,
		BOOL	fDeferUpd,
		BOOL	dAckReq
	)

Definition at line 1563 of file ddemisc.c.

{
    DDE_DATAHANDLE_HEAD*    pDdh;
    DWORD                       dwSize;
    HGLOBAL                     hMem = 0;
 
    dwSize = GlobalSize(hDdeData) - sizeof(DDE_DATAHANDLE_HEAD);
    pDdh = GlobalLock(hDdeData);
    if (dwSize && pDdh)
    {
        WINE_DDEHEAD*    wdh = NULL;
 
        switch (pDdh->cfFormat)
        {
        default:
            FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
                   pDdh->cfFormat, hDdeData);
            /* fall through */
        case 0:
        case CF_TEXT:
            hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(WINE_DDEHEAD) + dwSize);
            if (hMem && (wdh = GlobalLock(hMem)))
            {
                memcpy(wdh + 1, pDdh + 1, dwSize);
            }
            break;
        case CF_BITMAP:
            if (dwSize >= sizeof(HBITMAP))
            {
                BITMAP  bmp;
                DWORD   count;
                HBITMAP hbmp = *(HBITMAP*)(pDdh + 1);
 
                if (GetObjectW(hbmp, sizeof(bmp), &bmp))
                {
                    count = bmp.bmWidthBytes * bmp.bmHeight;
                    hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
                                       sizeof(WINE_DDEHEAD) + sizeof(bmp) + count);
                    if (hMem && (wdh = GlobalLock(hMem)))
                    {
                        memcpy(wdh + 1, &bmp, sizeof(bmp));
                        GetBitmapBits(hbmp, count, ((char*)(wdh + 1)) + sizeof(bmp));
                    }
                }
            }
            break;
        }
        if (wdh)
        {
            wdh->unused = 0;
            wdh->fResponse = fResponse;
            wdh->fRelease = fRelease;
            wdh->fDeferUpd = fDeferUpd;
            wdh->fAckReq = fAckReq;
            wdh->cfFormat = pDdh->cfFormat;
            GlobalUnlock(hMem);
        }
        GlobalUnlock(hDdeData);
    }
 
    return hMem;
}

Referenced by DdePostAdvise(), and WDML_ServerHandleRequest().

WDML_DecHSZ()

BOOL WDML_DecHSZ	(	WDML_INSTANCE *	pInstance,
		HSZ	hsz
	)

Definition at line 380 of file ddemisc.c.

{
    HSZNode*    pPrev = NULL;
    HSZNode*    pCurrent;
 
    for (pCurrent = pInstance->nodeList; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
    {
    /* If we found the node we were looking for and its ref count is one,
     * we can remove it
     */
    if (pCurrent->hsz == hsz)
    {
        if (--pCurrent->refCount == 0)
        {
        if (pCurrent == pInstance->nodeList)
        {
            pInstance->nodeList = pCurrent->next;
        }
        else
        {
            pPrev->next = pCurrent->next;
        }
        HeapFree(GetProcessHeap(), 0, pCurrent);
        DeleteAtom(HSZ2ATOM(hsz));
        }
        return TRUE;
    }
    }
    WARN("HSZ %p not found\n", hsz);
 
    return FALSE;
}

Referenced by DdeFreeStringHandle(), WDML_EventProc(), WDML_FreeTransaction(), WDML_HandleIncomingData(), WDML_RemoveAllLinks(), WDML_RemoveConv(), WDML_RemoveLink(), WDML_RemoveServer(), WDML_ServerHandleAdvise(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), and WDML_ServerHandleUnadvise().

WDML_ExtractAck()

static __inline void WDML_ExtractAck ( WORD  status, DDEACK *  da  )

static

Definition at line 237 of file dde_private.h.

{
    *da = *((DDEACK*)&status);
}

Referenced by WDML_HandleAdviseReply(), WDML_HandleExecuteReply(), WDML_HandleRequestReply(), and WDML_HandleUnadviseReply().

WDML_FindConv()

WDML_CONV * WDML_FindConv	(	WDML_INSTANCE *	pInstance,
		WDML_SIDE	side,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 2048 of file ddemisc.c.

{
    WDML_CONV*  pCurrent;
 
    for (pCurrent = pInstance->convs[side]; pCurrent != NULL; pCurrent = pCurrent->next)
    {
    if (DdeCmpStringHandles(pCurrent->hszService, hszService) == 0 &&
        DdeCmpStringHandles(pCurrent->hszTopic, hszTopic) == 0)
    {
        return pCurrent;
    }
 
    }
    return NULL;
}

Referenced by DdeConnect().

WDML_FindLink()

WDML_LINK * WDML_FindLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		HSZ	hszItem,
		BOOL	use_fmt,
		UINT	uFmt
	)

Definition at line 1868 of file ddemisc.c.

{
    WDML_LINK*  pCurrent;
 
    for (pCurrent = pInstance->links[side]; pCurrent != NULL; pCurrent = pCurrent->next)
    {
    /* we don't need to check for transaction type as it can be altered */
 
    if (pCurrent->hConv == hConv &&
        DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
        (!use_fmt || pCurrent->uFmt == uFmt))
    {
        break;
    }
 
    }
 
    return pCurrent;
}

Referenced by WDML_HandleAdviseReply(), WDML_HandleIncomingData(), WDML_ServerHandleAdvise(), and WDML_ServerHandleUnadvise().

WDML_FindServer()

WDML_SERVER * WDML_FindServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1729 of file ddemisc.c.

{
    WDML_SERVER*    pServer;
 
    for (pServer = pInstance->servers; pServer != NULL; pServer = pServer->next)
    {
    if (hszService == pServer->hszService)
    {
        return pServer;
    }
    }
    TRACE("Service name missing\n");
    return NULL;
}

Referenced by DdeNameService().

WDML_FreeTransaction()

void WDML_FreeTransaction	(	WDML_INSTANCE *	pInstance,
		WDML_XACT *	pXAct,
		BOOL	doFreePmt
	)

Definition at line 1967 of file ddemisc.c.

{
    /* free pmt(s) in pXAct too. check against one for not deleting TRUE return values */
    if (doFreePmt && (ULONG_PTR)pXAct->hMem > 1)
    {
    GlobalFree(pXAct->hMem);
    }
    if (pXAct->hszItem) WDML_DecHSZ(pInstance, pXAct->hszItem);
 
    HeapFree(GetProcessHeap(), 0, pXAct);
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), DdeDisconnect(), WDML_EnableCallback(), WDML_RemoveConv(), and WDML_ServerConvProc().

WDML_GetConv()

WDML_CONV * WDML_GetConv	(	HCONV	hConv,
		BOOL	checkConnected
	)

Definition at line 2230 of file ddemisc.c.

{
    WDML_CONV*  pConv = (WDML_CONV*)hConv;
 
    /* FIXME: should do better checking */
    if (pConv == NULL || pConv->magic != WDML_CONV_MAGIC) return NULL;
 
    if (!pConv->instance)
    {
        WARN("wrong thread ID, no instance\n");
    return NULL;
    }
 
    if (pConv->instance->threadID != GetCurrentThreadId())
    {
        WARN("wrong thread ID\n");
        pConv->instance->lastError = DMLERR_INVALIDPARAMETER; /* FIXME: check */
    return NULL;
    }
 
    if (checkConnected && !(pConv->wStatus & ST_CONNECTED))
    {
        WARN("found conv but ain't connected\n");
        pConv->instance->lastError = DMLERR_NO_CONV_ESTABLISHED;
    return NULL;
    }
 
    return pConv;
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), DdeDisconnect(), DdeEnableCallback(), DdeImpersonateClient(), DdePostAdvise(), DdeQueryConvInfo(), DdeReconnect(), DdeSetUserHandle(), and WDML_SyncWaitTransactionReply().

WDML_GetConvFromWnd()

WDML_CONV * WDML_GetConvFromWnd

(

HWND

hWnd

)

Definition at line 2265 of file ddemisc.c.

{
    return (WDML_CONV*)GetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION);
}

Referenced by DdeConnect(), DdeReconnect(), WDML_ClientProc(), and WDML_ServerConvProc().

WDML_GetInstance()

WDML_INSTANCE * WDML_GetInstance

(

DWORD

InstId

)

Definition at line 1230 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
 
    EnterCriticalSection(&WDML_CritSect);
 
    for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = pInstance->next)
    {
    if (pInstance->instanceID == instId)
    {
        if (GetCurrentThreadId() != pInstance->threadID)
        {
        FIXME("Tried to get instance from wrong thread\n");
        continue;
        }
        break;
    }
    }
 
    LeaveCriticalSection(&WDML_CritSect);
 
    if (!pInstance)
        WARN("Instance entry missing for id %04x\n", instId);
    return pInstance;
}

Referenced by DdeAbandonTransaction(), DdeConnect(), DdeCreateDataHandle(), DdeCreateStringHandleA(), DdeCreateStringHandleW(), DdeEnableCallback(), DdeFreeStringHandle(), DdeGetLastError(), DdeKeepStringHandle(), DdeNameService(), DdePostAdvise(), DdeQueryStringA(), DdeQueryStringW(), and DdeUninitialize().

WDML_GetInstanceFromWnd()

WDML_INSTANCE * WDML_GetInstanceFromWnd

(

HWND

hWnd

)

Definition at line 1261 of file ddemisc.c.

{
    return (WDML_INSTANCE*)GetWindowLongPtrW(hWnd, GWL_WDML_INSTANCE);
}

Referenced by WDML_AddConv(), WDML_ClientProc(), WDML_EventProc(), WDML_ServerConvProc(), and WDML_ServerNameProc().

WDML_Global2DataHandle()

HDDEDATA WDML_Global2DataHandle	(	WDML_CONV *	pConv,
		HGLOBAL	hMem,
		WINE_DDEHEAD *	da
	)

Definition at line 1504 of file ddemisc.c.

{
    DDEDATA*    pDd;
    HDDEDATA    ret = 0;
    DWORD       size;
 
    if (hMem)
    {
        pDd = GlobalLock(hMem);
        size = GlobalSize(hMem) - sizeof(WINE_DDEHEAD);
        if (pDd)
        {
        if (p) memcpy(p, pDd, sizeof(WINE_DDEHEAD));
            switch (pDd->cfFormat)
            {
            default:
                FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
                      pDd->cfFormat, hMem);
                /* fall through */
            case 0:
            case CF_TEXT:
                ret = DdeCreateDataHandle(pConv->instance->instanceID, pDd->Value, size, 0, 0, pDd->cfFormat, 0);
                break;
            case CF_BITMAP:
                if (size >= sizeof(BITMAP))
                {
                    BITMAP*     bmp = (BITMAP*)pDd->Value;
                    int         count = bmp->bmWidthBytes * bmp->bmHeight * bmp->bmPlanes;
                    if (size >= sizeof(BITMAP) + count)
                    {
                        HBITMAP hbmp;
 
                        if ((hbmp = CreateBitmap(bmp->bmWidth, bmp->bmHeight,
                                                 bmp->bmPlanes, bmp->bmBitsPixel,
                                                 pDd->Value + sizeof(BITMAP))))
                        {
                            ret = DdeCreateDataHandle(pConv->instance->instanceID, (LPBYTE)&hbmp, sizeof(hbmp),
                                                      0, 0, CF_BITMAP, 0);
                        }
                        else ERR("Can't create bmp\n");
                    }
                    else
                    {
                        ERR("Wrong count: %u / %d\n", size, count);
                    }
                } else ERR("No bitmap header\n");
                break;
            }
            GlobalUnlock(hMem);
        }
    }
    return ret;
}

Referenced by WDML_HandleIncomingData(), and WDML_HandleRequestReply().

WDML_IncHSZ()

BOOL WDML_IncHSZ	(	WDML_INSTANCE *	pInstance,
		HSZ	hsz
	)

Definition at line 362 of file ddemisc.c.

{
    HSZNode*    pNode;
 
    pNode = WDML_FindNode(pInstance, hsz);
    if (!pNode) return FALSE;
 
    pNode->refCount++;
    return TRUE;
}

Referenced by DdeKeepStringHandle(), DdeNameService(), WDML_AddConv(), WDML_AddLink(), WDML_AddServer(), and WDML_AllocTransaction().

WDML_InvokeCallback()

HDDEDATA WDML_InvokeCallback	(	WDML_INSTANCE *	pInst,
		UINT	uType,
		UINT	uFmt,
		HCONV	hConv,
		HSZ	hsz1,
		HSZ	hsz2,
		HDDEDATA	hdata,
		ULONG_PTR	dwData1,
		ULONG_PTR	dwData2
	)

Definition at line 1206 of file ddemisc.c.

{
    HDDEDATA    ret;
 
    if (pInstance == NULL)
    return NULL;
 
    TRACE("invoking CB[%p] (%x %x %p %p %p %p %lx %lx)\n",
      pInstance->callback, uType, uFmt,
      hConv, hsz1, hsz2, hdata, dwData1, dwData2);
    ret = pInstance->callback(uType, uFmt, hConv, hsz1, hsz2, hdata, dwData1, dwData2);
    TRACE("done => %p\n", ret);
    return ret;
}

Referenced by DdePostAdvise(), WDML_EventProc(), WDML_HandleIncomingData(), WDML_HandleReply(), WDML_HandleTerminateReply(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), WDML_ServerHandleTerminate(), WDML_ServerHandleUnadvise(), and WDML_ServerNameProc().

WDML_IsAppOwned()

BOOL WDML_IsAppOwned

(

HDDEDATA

hDdeData

)

Definition at line 1477 of file ddemisc.c.

{
    DDE_DATAHANDLE_HEAD*    pDdh;
    BOOL                        ret = FALSE;
 
    pDdh = GlobalLock(hData);
    if (pDdh != NULL)
    {
        ret = pDdh->bAppOwned;
        GlobalUnlock(hData);
    }
    return ret;
}

Referenced by DdePostAdvise(), and WDML_ServerNameProc().

WDML_MakeAtomFromHsz()

ATOM WDML_MakeAtomFromHsz

(

HSZ

hsz

)

Definition at line 325 of file ddemisc.c.

{
    WCHAR nameBuffer[MAX_BUFFER_LEN];
 
    if (GetAtomNameW(HSZ2ATOM(hsz), nameBuffer, MAX_BUFFER_LEN))
    return GlobalAddAtomW(nameBuffer);
    WARN("HSZ %p not found\n", hsz);
    return 0;
}

Referenced by DdeConnect(), DdePostAdvise(), DdeReconnect(), WDML_AddServer(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_ClientQueueRequest(), WDML_ClientQueueUnadvise(), and WDML_CreateServerConv().

WDML_MakeHszFromAtom()

HSZ WDML_MakeHszFromAtom	(	const WDML_INSTANCE *	pInstance,
		ATOM	atom
	)

Definition at line 342 of file ddemisc.c.

{
    WCHAR nameBuffer[MAX_BUFFER_LEN];
 
    if (!atom) return NULL;
 
    if (GlobalGetAtomNameW(atom, nameBuffer, MAX_BUFFER_LEN))
    {
    TRACE("%x => %s\n", atom, debugstr_w(nameBuffer));
    return DdeCreateStringHandleW(pInstance->instanceID, nameBuffer, CP_WINUNICODE);
    }
    WARN("ATOM 0x%x not found\n", atom);
    return 0;
}

Referenced by WDML_ClientProc(), WDML_EventProc(), WDML_HandleAdviseReply(), WDML_HandleIncomingData(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_HandleUnadviseReply(), WDML_ServerNameProc(), WDML_ServerQueueAdvise(), WDML_ServerQueuePoke(), WDML_ServerQueueRequest(), and WDML_ServerQueueUnadvise().

WDML_NotifyThreadDetach()

void WDML_NotifyThreadDetach

(

void

)

Definition at line 1181 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    WDML_INSTANCE*  next;
    DWORD       tid = GetCurrentThreadId();
 
    EnterCriticalSection(&WDML_CritSect);
    for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = next)
    {
    next = pInstance->next;
    if (pInstance->threadID == tid)
    {
            LeaveCriticalSection(&WDML_CritSect);
        DdeUninitialize(pInstance->instanceID);
            EnterCriticalSection(&WDML_CritSect);
    }
    }
    LeaveCriticalSection(&WDML_CritSect);
}

WDML_NotifyThreadExit()

void WDML_NotifyThreadExit

(

DWORD

tid

)

WDML_PostAck()

BOOL WDML_PostAck	(	WDML_CONV *	pConv,
		WDML_SIDE	side,
		WORD	appRetCode,
		BOOL	fBusy,
		BOOL	fAck,
		UINT_PTR	pmt,
		LPARAM	lParam,
		UINT	oldMsg
	)

Definition at line 2275 of file ddemisc.c.

{
    DDEACK  ddeAck;
    HWND    from, to;
 
    if (side == WDML_SERVER_SIDE)
    {
    from = pConv->hwndServer;
    to   = pConv->hwndClient;
    }
    else
    {
    to   = pConv->hwndServer;
    from = pConv->hwndClient;
    }
 
    ddeAck.bAppReturnCode = appRetCode;
    ddeAck.reserved       = 0;
    ddeAck.fBusy          = fBusy;
    ddeAck.fAck           = fAck;
 
    TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
 
    lParam = (lParam) ? ReuseDDElParam(lParam, oldMsg, WM_DDE_ACK, *(WORD*)&ddeAck, pmt) :
        PackDDElParam(WM_DDE_ACK, *(WORD*)&ddeAck, pmt);
    if (!PostMessageW(to, WM_DDE_ACK, (WPARAM)from, lParam))
    {
    pConv->wStatus &= ~ST_CONNECTED;
        pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
        FreeDDElParam(WM_DDE_ACK, lParam);
        return FALSE;
    }
    return TRUE;
}

Referenced by WDML_HandleIncomingData(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), and WDML_ServerHandleUnadvise().

WDML_QueueTransaction()

void WDML_QueueTransaction	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 1933 of file ddemisc.c.

{
    WDML_XACT** pt;
 
    /* advance to last in queue */
    for (pt = &pConv->transactions; *pt != NULL; pt = &(*pt)->next);
    *pt = pXAct;
}

Referenced by DdeClientTransaction(), and WDML_ServerConvProc().

WDML_RemoveConv()

void WDML_RemoveConv	(	WDML_CONV *	pConv,
		WDML_SIDE	side
	)

Definition at line 2070 of file ddemisc.c.

{
    WDML_CONV*  pPrev = NULL;
    WDML_CONV*  pCurrent;
    WDML_XACT*  pXAct;
    WDML_XACT*  pXActNext;
    HWND    hWnd;
 
    if (!pRef)
    return;
 
    /* remove any pending transaction */
    for (pXAct = pRef->transactions; pXAct != NULL; pXAct = pXActNext)
    {
    pXActNext = pXAct->next;
    WDML_FreeTransaction(pRef->instance, pXAct, TRUE);
    }
 
    WDML_RemoveAllLinks(pRef->instance, pRef, side);
 
    /* FIXME: should we keep the window around ? it seems so (at least on client side
     * to let QueryConvInfo work after conv termination, but also to implement
     * DdeReconnect...
     */
    /* destroy conversation window, but first remove pConv from hWnd.
     * this would help the wndProc do appropriate handling upon a WM_DESTROY message
     */
    hWnd = (side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer;
    SetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION, 0);
 
    DestroyWindow((side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer);
 
    WDML_DecHSZ(pRef->instance, pRef->hszService);
    WDML_DecHSZ(pRef->instance, pRef->hszTopic);
 
    for (pCurrent = pRef->instance->convs[side]; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
    {
    if (pCurrent == pRef)
    {
        if (pCurrent == pRef->instance->convs[side])
        {
        pRef->instance->convs[side] = pCurrent->next;
        }
        else
        {
        pPrev->next = pCurrent->next;
        }
        pCurrent->magic = 0;
        HeapFree(GetProcessHeap(), 0, pCurrent);
        break;
    }
    }
}

Referenced by DdeDisconnect(), WDML_HandleTerminateReply(), WDML_RemoveServer(), and WDML_ServerHandleTerminate().

WDML_RemoveLink()

void WDML_RemoveLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		HSZ	hszItem,
		UINT	wFmt
	)

Definition at line 1780 of file ddemisc.c.

{
    WDML_LINK* pPrev = NULL;
    WDML_LINK* pCurrent = NULL;
 
    pCurrent = pInstance->links[side];
 
    while (pCurrent != NULL)
    {
    if (pCurrent->hConv == hConv &&
        DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
        pCurrent->uFmt == uFmt)
    {
        if (pCurrent == pInstance->links[side])
        {
        pInstance->links[side] = pCurrent->next;
        }
        else
        {
        pPrev->next = pCurrent->next;
        }
 
        WDML_DecHSZ(pInstance, pCurrent->hszItem);
        HeapFree(GetProcessHeap(), 0, pCurrent);
        break;
    }
 
    pPrev = pCurrent;
    pCurrent = pCurrent->next;
    }
}

Referenced by WDML_HandleUnadviseReply(), and WDML_ServerHandleUnadvise().

WDML_RemoveServer()

void WDML_RemoveServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1670 of file ddemisc.c.

{
    WDML_SERVER*    pPrev = NULL;
    WDML_SERVER*    pServer = NULL;
    WDML_CONV*      pConv;
    WDML_CONV*      pConvNext;
 
    pServer = pInstance->servers;
 
    while (pServer != NULL)
    {
    if (DdeCmpStringHandles(pServer->hszService, hszService) == 0)
    {
        WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_UNREGISTER,
                     pServer->atomService, pServer->atomServiceSpec);
        /* terminate all conversations for given topic */
        for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConvNext)
        {
        pConvNext = pConv->next;
        if (DdeCmpStringHandles(pConv->hszService, hszService) == 0)
        {
                    HWND client = pConv->hwndClient, server = pConv->hwndServer;
            WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
            /* don't care about return code (whether client window is present or not) */
            PostMessageW(client, WM_DDE_TERMINATE, (WPARAM)server, 0);
        }
        }
        if (pServer == pInstance->servers)
        {
        pInstance->servers = pServer->next;
        }
        else
        {
        pPrev->next = pServer->next;
        }
 
        DestroyWindow(pServer->hwndServer);
        WDML_DecHSZ(pInstance, pServer->hszServiceSpec);
        WDML_DecHSZ(pInstance, pServer->hszService);
 
        GlobalDeleteAtom(pServer->atomService);
        GlobalDeleteAtom(pServer->atomServiceSpec);
 
        HeapFree(GetProcessHeap(), 0, pServer);
        break;
    }
 
    pPrev = pServer;
    pServer = pServer->next;
    }
}

Referenced by DdeNameService().

WDML_ServerHandle()

WDML_QUEUE_STATE WDML_ServerHandle	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 968 of file ddeserver.c.

{
    WDML_QUEUE_STATE    qs = WDML_QS_ERROR;
 
    switch (pXAct->ddeMsg)
    {
    case WM_DDE_INITIATE:
    FIXME("WM_DDE_INITIATE shouldn't be there!\n");
    break;
    case WM_DDE_REQUEST:
    qs = WDML_ServerHandleRequest(pConv, pXAct);
    break;
 
    case WM_DDE_ADVISE:
    qs = WDML_ServerHandleAdvise(pConv, pXAct);
    break;
 
    case WM_DDE_UNADVISE:
    qs = WDML_ServerHandleUnadvise(pConv, pXAct);
    break;
 
    case WM_DDE_EXECUTE:
    qs = WDML_ServerHandleExecute(pConv, pXAct);
    break;
 
    case WM_DDE_POKE:
    qs = WDML_ServerHandlePoke(pConv, pXAct);
    break;
 
    case WM_DDE_TERMINATE:
    qs = WDML_ServerHandleTerminate(pConv, pXAct);
    break;
 
    case WM_DDE_ACK:
    WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
    break;
 
    default:
    FIXME("Unsupported message %d\n", pXAct->ddeMsg);
    }
    return qs;
}

Referenced by WDML_EnableCallback(), and WDML_ServerConvProc().

WDML_UnQueueTransaction()

BOOL WDML_UnQueueTransaction	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 1947 of file ddemisc.c.

{
    WDML_XACT** pt;
 
    for (pt = &pConv->transactions; *pt; pt = &(*pt)->next)
    {
    if (*pt == pXAct)
    {
        *pt = pXAct->next;
        return TRUE;
    }
    }
    return FALSE;
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), and WDML_EnableCallback().

Variable Documentation

DECLSPEC_HIDDEN

const WCHAR WDML_szClientConvClassW [] DECLSPEC_HIDDEN

extern

Definition at line 243 of file dde_private.h.