| /* |
| * DDEML library |
| * |
| * Copyright 1997 Alexandre Julliard |
| * Copyright 1997 Len White |
| */ |
| |
| /* Only empty stubs for now */ |
| |
| #include <stdlib.h> |
| #include <strings.h> |
| #include "ddeml.h" |
| #include "debug.h" |
| #include "windows.h" |
| #include "heap.h" |
| |
| /* FIXME: What are these values? */ |
| #define DMLERR_NO_ERROR 0 |
| |
| /* Has defined in atom.c file. |
| */ |
| #define MAX_ATOM_LEN 255 |
| |
| /* Maximum buffer size ( including the '\0' ). |
| */ |
| #define MAX_BUFFER_LEN (MAX_ATOM_LEN + 1) |
| |
| static LONG DDE_current_handle; |
| |
| /* This is a simple list to keep track of the strings created |
| * by DdeCreateStringHandle. The list is used to free |
| * the strings whenever DdeUninitialize is called. |
| * This mechanism is not complete and does not handle multiple instances. |
| * Most of the DDE API use a DWORD parameter indicating witch instance |
| * of a given program is calling them. The API are supposed to |
| * associate the data to the instance that created it. |
| */ |
| typedef struct tagHSZNode HSZNode; |
| struct tagHSZNode |
| { |
| HSZNode* next; |
| HSZ hsz; |
| }; |
| |
| /* Start off the list pointer with a NULL. |
| */ |
| static HSZNode* pHSZNodes = NULL; |
| |
| |
| /****************************************************************************** |
| * RemoveHSZNodes (INTERNAL) |
| * |
| * Remove a node from the list of HSZ nodes. |
| */ |
| static void RemoveHSZNode( DWORD idInst, HSZ hsz ) |
| { |
| HSZNode* pPrev = NULL; |
| HSZNode* pCurrent = NULL; |
| |
| /* Set the current node at the start of the list. |
| */ |
| pCurrent = pHSZNodes; |
| /* While we have more nodes. |
| */ |
| while( pCurrent != NULL ) |
| { |
| /* If we found the node we were looking for. |
| */ |
| if( pCurrent->hsz == hsz ) |
| { |
| /* Remove the node. |
| */ |
| /* If the first node in the list is to to be removed. |
| * Set the global list pointer to the next node. |
| */ |
| if( pCurrent == pHSZNodes ) |
| { |
| pHSZNodes = pCurrent->next; |
| } |
| /* Just fix the pointers has to skip the current |
| * node so we can delete it. |
| */ |
| else |
| { |
| pPrev->next = pCurrent->next; |
| } |
| /* Destroy this node. |
| */ |
| free( pCurrent ); |
| break; |
| } |
| /* Save the previous node pointer. |
| */ |
| pPrev = pCurrent; |
| /* Move on to the next node. |
| */ |
| pCurrent = pCurrent->next; |
| } |
| } |
| |
| /****************************************************************************** |
| * FreeAndRemoveHSZNodes (INTERNAL) |
| * |
| * Frees up all the strings still allocated in the list and |
| * remove all the nodes from the list of HSZ nodes. |
| */ |
| static void FreeAndRemoveHSZNodes( DWORD idInst ) |
| { |
| /* Free any strings created in this instance. |
| */ |
| while( pHSZNodes != NULL ) |
| { |
| DdeFreeStringHandle32( idInst, pHSZNodes->hsz ); |
| } |
| } |
| |
| /****************************************************************************** |
| * InsertHSZNode (INTERNAL) |
| * |
| * Insert a node to the head of the list. |
| */ |
| static void InsertHSZNode( DWORD idInst, HSZ hsz ) |
| { |
| if( hsz != 0 ) |
| { |
| HSZNode* pNew = NULL; |
| /* Create a new node for this HSZ. |
| */ |
| pNew = (HSZNode*) malloc( sizeof( HSZNode ) ); |
| if( pNew != NULL ) |
| { |
| /* Set the handle value. |
| */ |
| pNew->hsz = hsz; |
| /* Attach the node to the head of the list. |
| */ |
| pNew->next = pHSZNodes; |
| /* The new node is now at the head of the list |
| * so set the global list pointer to it. |
| */ |
| pHSZNodes = pNew; |
| } |
| } |
| } |
| |
| |
| /****************************************************************************** |
| * DdeInitialize16 (DDEML.2) |
| */ |
| UINT16 WINAPI DdeInitialize16( LPDWORD pidInst, PFNCALLBACK16 pfnCallback, |
| DWORD afCmd, DWORD ulRes) |
| { |
| return (UINT16)DdeInitialize32A(pidInst,(PFNCALLBACK32)pfnCallback, |
| afCmd, ulRes); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeInitialize32A (USER32.106) |
| */ |
| UINT32 WINAPI DdeInitialize32A( LPDWORD pidInst, PFNCALLBACK32 pfnCallback, |
| DWORD afCmd, DWORD ulRes ) |
| { |
| return DdeInitialize32W(pidInst,pfnCallback,afCmd,ulRes); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeInitialize32W [USER32.107] |
| * Registers an application with the DDEML |
| * |
| * PARAMS |
| * pidInst [I] Pointer to instance identifier |
| * pfnCallback [I] Pointer to callback function |
| * afCmd [I] Set of command and filter flags |
| * ulRes [I] Reserved |
| * |
| * RETURNS |
| * Success: DMLERR_NO_ERROR |
| * Failure: DMLERR_DLL_USAGE, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR |
| */ |
| UINT32 WINAPI DdeInitialize32W( LPDWORD pidInst, PFNCALLBACK32 pfnCallback, |
| DWORD afCmd, DWORD ulRes ) |
| { |
| FIXME(ddeml, "(%p,%p,0x%lx,%ld): stub\n",pidInst,pfnCallback,afCmd,ulRes); |
| |
| if(pidInst) |
| *pidInst = 0; |
| |
| if( ulRes ) |
| ERR(dde, "Reserved value not zero? What does this mean?\n"); |
| |
| return DMLERR_NO_ERROR; |
| } |
| |
| |
| /***************************************************************** |
| * DdeUninitialize16 (DDEML.3) |
| */ |
| BOOL16 WINAPI DdeUninitialize16( DWORD idInst ) |
| { |
| return (BOOL16)DdeUninitialize32( idInst ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeUninitialize32 [USER32.119] Frees DDEML resources |
| * |
| * PARAMS |
| * idInst [I] Instance identifier |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| BOOL32 WINAPI DdeUninitialize32( DWORD idInst ) |
| { |
| |
| FIXME(ddeml, "(%ld): stub\n", idInst); |
| |
| /* Free the nodes that were not freed by this instance |
| * and remove the nodes from the list of HSZ nodes. |
| */ |
| FreeAndRemoveHSZNodes( idInst ); |
| |
| return TRUE; |
| } |
| |
| |
| /***************************************************************** |
| * DdeConnectList16 [DDEML.4] |
| */ |
| HCONVLIST WINAPI DdeConnectList16( DWORD idInst, HSZ hszService, HSZ hszTopic, |
| HCONVLIST hConvList, LPCONVCONTEXT16 pCC ) |
| { |
| return DdeConnectList32(idInst, hszService, hszTopic, hConvList, |
| (LPCONVCONTEXT32)pCC); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeConnectList32 [USER32.93] Establishes conversation with DDE servers |
| * |
| * PARAMS |
| * idInst [I] Instance identifier |
| * hszService [I] Handle to service name string |
| * hszTopic [I] Handle to topic name string |
| * hConvList [I] Handle to conversation list |
| * pCC [I] Pointer to structure with context data |
| * |
| * RETURNS |
| * Success: Handle to new conversation list |
| * Failure: 0 |
| */ |
| HCONVLIST WINAPI DdeConnectList32( DWORD idInst, HSZ hszService, HSZ hszTopic, |
| HCONVLIST hConvList, LPCONVCONTEXT32 pCC ) |
| { |
| FIXME(ddeml, "(%ld,%ld,%ld,%ld,%p): stub\n", idInst, hszService, hszTopic, |
| hConvList,pCC); |
| return 1; |
| } |
| |
| |
| /***************************************************************** |
| * DdeQueryNextServer16 [DDEML.5] |
| */ |
| HCONV WINAPI DdeQueryNextServer16( HCONVLIST hConvList, HCONV hConvPrev ) |
| { |
| return DdeQueryNextServer32(hConvList, hConvPrev); |
| } |
| |
| |
| /***************************************************************** |
| * DdeQueryNextServer32 [USER32.112] |
| */ |
| HCONV WINAPI DdeQueryNextServer32( HCONVLIST hConvList, HCONV hConvPrev ) |
| { |
| FIXME(ddeml, "(%ld,%ld): stub\n",hConvList,hConvPrev); |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeQueryString32A [USER32.113] |
| */ |
| DWORD WINAPI DdeQueryString32A(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT32 iCodePage) |
| { |
| DWORD ret = 0; |
| CHAR pString[MAX_BUFFER_LEN]; |
| |
| FIXME(ddeml, |
| "(%ld, 0x%lx, %p, %ld, %d): stub\n", |
| idInst, |
| hsz, |
| psz, |
| cchMax, |
| iCodePage); |
| |
| if( iCodePage == CP_WINANSI ) |
| { |
| /* If psz is null, we have to return only the length |
| * of the string. |
| */ |
| if( psz == NULL ) |
| { |
| psz = pString; |
| cchMax = MAX_BUFFER_LEN; |
| } |
| |
| ret = GlobalGetAtomName32A( hsz, (LPSTR)psz, cchMax ); |
| } |
| |
| return ret; |
| } |
| |
| /***************************************************************** |
| * DdeQueryString32W [USER32.114] |
| */ |
| DWORD WINAPI DdeQueryString32W(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT32 iCodePage) |
| { |
| DWORD ret = 0; |
| WCHAR pString[MAX_BUFFER_LEN]; |
| int factor = 1; |
| |
| FIXME(ddeml, |
| "(%ld, 0x%lx, %p, %ld, %d): stub\n", |
| idInst, |
| hsz, |
| psz, |
| cchMax, |
| iCodePage); |
| |
| if( iCodePage == CP_WINUNICODE ) |
| { |
| /* If psz is null, we have to return only the length |
| * of the string. |
| */ |
| if( psz == NULL ) |
| { |
| psz = pString; |
| cchMax = MAX_BUFFER_LEN; |
| /* Note: According to documentation if the psz parameter |
| * was NULL this API must return the length of the string in bytes. |
| */ |
| factor = (int) sizeof(WCHAR)/sizeof(BYTE); |
| } |
| ret = GlobalGetAtomName32W( hsz, (LPWSTR)psz, cchMax ) * factor; |
| } |
| return ret; |
| } |
| |
| |
| /***************************************************************** |
| * DdeDisconnectList (DDEML.6) |
| */ |
| BOOL16 WINAPI DdeDisconnectList16( HCONVLIST hConvList ) |
| { |
| return (BOOL16)DdeDisconnectList32(hConvList); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeDisconnectList32 [USER32.98] Destroys list and terminates conversations |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| BOOL32 WINAPI DdeDisconnectList32( |
| HCONVLIST hConvList) /* [in] Handle to conversation list */ |
| { |
| FIXME(ddeml, "(%ld): stub\n", hConvList); |
| return TRUE; |
| } |
| |
| |
| /***************************************************************** |
| * DdeConnect16 (DDEML.7) |
| */ |
| HCONV WINAPI DdeConnect16( DWORD idInst, HSZ hszService, HSZ hszTopic, |
| LPCONVCONTEXT16 pCC ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeConnect32 (USER32.92) |
| */ |
| HCONV WINAPI DdeConnect32( DWORD idInst, HSZ hszService, HSZ hszTopic, |
| LPCONVCONTEXT32 pCC ) |
| { |
| FIXME(ddeml, "(0x%lx,%ld,%ld,%p): stub\n",idInst,hszService,hszTopic, |
| pCC); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeDisconnect16 (DDEML.8) |
| */ |
| BOOL16 WINAPI DdeDisconnect16( HCONV hConv ) |
| { |
| return (BOOL16)DdeDisconnect32( hConv ); |
| } |
| |
| /***************************************************************** |
| * DdeSetUserHandle (DDEML.10) |
| */ |
| BOOL16 WINAPI DdeSetUserHandle( HCONV hConv, DWORD id, DWORD hUser ) |
| { |
| FIXME( ddeml, "(%ld,%ld,%ld): stub\n",hConv,id, hUser ); |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeCreateDataHandle16 (DDEML.14) |
| */ |
| HDDEDATA WINAPI DdeCreateDataHandle16( DWORD idInst, LPBYTE pSrc, DWORD cb, |
| DWORD cbOff, HSZ hszItem, UINT16 wFmt, |
| UINT16 afCmd ) |
| { |
| return DdeCreateDataHandle32(idInst, |
| pSrc, |
| cb, |
| cbOff, |
| hszItem, |
| wFmt, |
| afCmd); |
| } |
| |
| /***************************************************************** |
| * DdeCreateDataHandle32 (USER32.94) |
| */ |
| HDDEDATA WINAPI DdeCreateDataHandle32( DWORD idInst, LPBYTE pSrc, DWORD cb, |
| DWORD cbOff, HSZ hszItem, UINT32 wFmt, |
| UINT32 afCmd ) |
| { |
| FIXME( ddeml, |
| "(%ld,%p,%ld,%ld,0x%lx,%d,%d): stub\n", |
| idInst, |
| pSrc, |
| cb, |
| cbOff, |
| hszItem, |
| wFmt, |
| afCmd ); |
| |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeDisconnect32 (USER32.97) |
| */ |
| BOOL32 WINAPI DdeDisconnect32( HCONV hConv ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeReconnect (DDEML.37) (USER32.115) |
| */ |
| HCONV WINAPI DdeReconnect( HCONV hConv ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeCreateStringHandle16 (DDEML.21) |
| */ |
| HSZ WINAPI DdeCreateStringHandle16( DWORD idInst, LPCSTR str, INT16 codepage ) |
| { |
| return DdeCreateStringHandle32A( idInst, str, codepage ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeCreateStringHandle32A [USER32.95] |
| * |
| * RETURNS |
| * Success: String handle |
| * Failure: 0 |
| */ |
| HSZ WINAPI DdeCreateStringHandle32A( DWORD idInst, LPCSTR psz, INT32 codepage ) |
| { |
| HSZ hsz = 0; |
| TRACE(ddeml, "(%ld,%s,%d): stub\n",idInst,debugstr_a(psz),codepage); |
| |
| if (codepage==CP_WINANSI) |
| { |
| hsz = GlobalAddAtom32A (psz); |
| /* Save the handle so we know to clean it when |
| * uninitialize is called. |
| */ |
| InsertHSZNode( idInst, hsz ); |
| return hsz; |
| } |
| return 0; |
| } |
| |
| |
| /****************************************************************************** |
| * DdeCreateStringHandle32W [USER32.96] Creates handle to identify string |
| * |
| * RETURNS |
| * Success: String handle |
| * Failure: 0 |
| */ |
| HSZ WINAPI DdeCreateStringHandle32W( |
| DWORD idInst, /* [in] Instance identifier */ |
| LPCWSTR psz, /* [in] Pointer to string */ |
| INT32 codepage) /* [in] Code page identifier */ |
| { |
| HSZ hsz = 0; |
| |
| FIXME(ddeml, "(%ld,%s,%d): stub\n",idInst,debugstr_w(psz),codepage); |
| |
| if (codepage==CP_WINUNICODE) |
| { |
| hsz = GlobalAddAtom32W (psz); |
| /* Save the handle so we know to clean it when |
| * uninitialize is called. |
| */ |
| InsertHSZNode( idInst, hsz ); |
| return hsz; |
| } |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeFreeStringHandle16 (DDEML.22) |
| */ |
| BOOL16 WINAPI DdeFreeStringHandle16( DWORD idInst, HSZ hsz ) |
| { |
| return (BOOL32)DdeFreeStringHandle32( idInst, hsz ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeFreeStringHandle32 (USER32.101) |
| * RETURNS: success: nonzero |
| * fail: zero |
| */ |
| BOOL32 WINAPI DdeFreeStringHandle32( DWORD idInst, HSZ hsz ) |
| { |
| TRACE( ddeml, "(%ld,%ld): stub\n",idInst, hsz ); |
| /* Remove the node associated with this HSZ. |
| */ |
| RemoveHSZNode( idInst, hsz ); |
| /* Free the string associated with this HSZ. |
| */ |
| return GlobalDeleteAtom (hsz) ? 0 : hsz; |
| } |
| |
| |
| /***************************************************************** |
| * DdeFreeDataHandle16 (DDEML.19) |
| */ |
| BOOL16 WINAPI DdeFreeDataHandle16( HDDEDATA hData ) |
| { |
| return (BOOL32)DdeFreeDataHandle32( hData ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeFreeDataHandle32 (USER32.100) |
| */ |
| BOOL32 WINAPI DdeFreeDataHandle32( HDDEDATA hData ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return TRUE; |
| } |
| |
| |
| |
| |
| /***************************************************************** |
| * DdeKeepStringHandle16 (DDEML.24) |
| */ |
| BOOL16 WINAPI DdeKeepStringHandle16( DWORD idInst, HSZ hsz ) |
| { |
| return (BOOL32)DdeKeepStringHandle32( idInst, hsz ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeKeepStringHandle32 (USER32.108) |
| */ |
| BOOL32 WINAPI DdeKeepStringHandle32( DWORD idInst, HSZ hsz ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return TRUE; |
| } |
| |
| |
| /***************************************************************** |
| * DdeClientTransaction16 (DDEML.11) |
| */ |
| HDDEDATA WINAPI DdeClientTransaction16( LPVOID pData, DWORD cbData, |
| HCONV hConv, HSZ hszItem, UINT16 wFmt, |
| UINT16 wType, DWORD dwTimeout, |
| LPDWORD pdwResult ) |
| { |
| return DdeClientTransaction32( (LPBYTE)pData, cbData, hConv, hszItem, |
| wFmt, wType, dwTimeout, pdwResult ); |
| } |
| |
| |
| /***************************************************************** |
| * DdeClientTransaction32 (USER32.90) |
| */ |
| HDDEDATA WINAPI DdeClientTransaction32( LPBYTE pData, DWORD cbData, |
| HCONV hConv, HSZ hszItem, UINT32 wFmt, |
| UINT32 wType, DWORD dwTimeout, |
| LPDWORD pdwResult ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeAbandonTransaction (DDEML.12) |
| */ |
| BOOL16 WINAPI DdeAbandonTransaction( DWORD idInst, HCONV hConv, |
| DWORD idTransaction ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdePostAdvise16 [DDEML.13] |
| */ |
| BOOL16 WINAPI DdePostAdvise16( DWORD idInst, HSZ hszTopic, HSZ hszItem ) |
| { |
| return (BOOL16)DdePostAdvise32(idInst, hszTopic, hszItem); |
| } |
| |
| |
| /****************************************************************************** |
| * DdePostAdvise32 [USER32.110] Send transaction to DDE callback function. |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| BOOL32 WINAPI DdePostAdvise32( |
| DWORD idInst, /* [in] Instance identifier */ |
| HSZ hszTopic, /* [in] Handle to topic name string */ |
| HSZ hszItem) /* [in] Handle to item name string */ |
| { |
| FIXME(ddeml, "(%ld,%ld,%ld): stub\n",idInst,hszTopic,hszItem); |
| return TRUE; |
| } |
| |
| |
| /***************************************************************** |
| * DdeAddData (DDEML.15) |
| */ |
| HDDEDATA WINAPI DdeAddData( HDDEDATA hData, LPBYTE pSrc, DWORD cb, |
| DWORD cbOff ) |
| { |
| FIXME( ddeml, "empty stub\n" ); |
| return 0; |
| } |
| |
| |
| /****************************************************************************** |
| * DdeGetData32 [USER32.102] Copies data from DDE object ot local buffer |
| * |
| * RETURNS |
| * Size of memory object associated with handle |
| */ |
| DWORD WINAPI DdeGetData32( |
| HDDEDATA hData, /* [in] Handle to DDE object */ |
| LPBYTE pDst, /* [in] Pointer to destination buffer */ |
| DWORD cbMax, /* [in] Amount of data to copy */ |
| DWORD cbOff) /* [in] Offset to beginning of data */ |
| { |
| FIXME(ddeml, "(%ld,%p,%ld,%ld): stub\n",hData,pDst,cbMax,cbOff); |
| return cbMax; |
| } |
| |
| |
| /***************************************************************** |
| * DdeGetData16 [DDEML.16] |
| */ |
| DWORD WINAPI DdeGetData16( |
| HDDEDATA hData, |
| LPBYTE pDst, |
| DWORD cbMax, |
| DWORD cbOff) |
| { |
| return DdeGetData32(hData, pDst, cbMax, cbOff); |
| } |
| |
| |
| /***************************************************************** |
| * DdeAccessData16 (DDEML.17) |
| */ |
| LPBYTE WINAPI DdeAccessData16( HDDEDATA hData, LPDWORD pcbDataSize ) |
| { |
| return DdeAccessData32(hData, pcbDataSize); |
| } |
| |
| /***************************************************************** |
| * DdeAccessData32 (USER32.88) |
| */ |
| LPBYTE WINAPI DdeAccessData32( HDDEDATA hData, LPDWORD pcbDataSize ) |
| { |
| FIXME( ddeml, "(%ld,%p): stub\n", hData, pcbDataSize); |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeUnaccessData16 (DDEML.18) |
| */ |
| BOOL16 WINAPI DdeUnaccessData16( HDDEDATA hData ) |
| { |
| return DdeUnaccessData32(hData); |
| } |
| |
| /***************************************************************** |
| * DdeUnaccessData32 (USER32.118) |
| */ |
| BOOL32 WINAPI DdeUnaccessData32( HDDEDATA hData ) |
| { |
| FIXME( ddeml, "(0x%lx): stub\n", hData); |
| |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeEnableCallback16 (DDEML.26) |
| */ |
| BOOL16 WINAPI DdeEnableCallback16( DWORD idInst, HCONV hConv, UINT16 wCmd ) |
| { |
| return DdeEnableCallback32(idInst, hConv, wCmd); |
| } |
| |
| /***************************************************************** |
| * DdeEnableCallback32 (USER32.99) |
| */ |
| BOOL32 WINAPI DdeEnableCallback32( DWORD idInst, HCONV hConv, UINT32 wCmd ) |
| { |
| FIXME( ddeml, "(%ld, 0x%lx, %d) stub\n", idInst, hConv, wCmd); |
| |
| return 0; |
| } |
| |
| /***************************************************************** |
| * DdeNameService16 (DDEML.27) |
| */ |
| HDDEDATA WINAPI DdeNameService16( DWORD idInst, HSZ hsz1, HSZ hsz2, |
| UINT16 afCmd ) |
| { |
| return DdeNameService32( idInst, hsz1, hsz2, afCmd ); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeNameService32 [USER32.109] {Un}registers service name of DDE server |
| * |
| * PARAMS |
| * idInst [I] Instance identifier |
| * hsz1 [I] Handle to service name string |
| * hsz2 [I] Reserved |
| * afCmd [I] Service name flags |
| * |
| * RETURNS |
| * Success: Non-zero |
| * Failure: 0 |
| */ |
| HDDEDATA WINAPI DdeNameService32( DWORD idInst, HSZ hsz1, HSZ hsz2, |
| UINT32 afCmd ) |
| { |
| FIXME(ddeml, "(%ld,%ld,%ld,%d): stub\n",idInst,hsz1,hsz2,afCmd); |
| return 1; |
| } |
| |
| |
| /***************************************************************** |
| * DdeGetLastError16 (DDEML.20) |
| */ |
| UINT16 WINAPI DdeGetLastError16( DWORD idInst ) |
| { |
| return (UINT16)DdeGetLastError32( idInst ); |
| } |
| |
| |
| /****************************************************************************** |
| * DdeGetLastError32 [USER32.103] Gets most recent error code |
| * |
| * PARAMS |
| * idInst [I] Instance identifier |
| * |
| * RETURNS |
| * Last error code |
| */ |
| UINT32 WINAPI DdeGetLastError32( DWORD idInst ) |
| { |
| FIXME(ddeml, "(%ld): stub\n",idInst); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * DdeCmpStringHandles16 (DDEML.36) |
| */ |
| int WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 ) |
| { |
| return DdeCmpStringHandles32A(hsz1, hsz2); |
| } |
| |
| /***************************************************************** |
| * DdeCmpStringHandles32A (USER32.91) |
| * |
| * Compares the value of two string handles. This comparison is |
| * not case sensitive. |
| * |
| * Returns: |
| * -1 The value of hsz1 is zero or less than hsz2 |
| * 0 The values of hsz 1 and 2 are the same or both zero. |
| * 1 The value of hsz2 is zero of less than hsz1 |
| */ |
| int WINAPI DdeCmpStringHandles32A( HSZ hsz1, HSZ hsz2 ) |
| { |
| CHAR psz1[MAX_BUFFER_LEN]; |
| CHAR psz2[MAX_BUFFER_LEN]; |
| int ret = 0; |
| int ret1, ret2; |
| |
| TRACE( ddeml, "handle 1, handle 2\n" ); |
| |
| ret1 = GlobalGetAtomName32A( hsz1, psz1, MAX_BUFFER_LEN ); |
| ret2 = GlobalGetAtomName32A( hsz2, psz2, MAX_BUFFER_LEN ); |
| /* Make sure we found both strings. |
| */ |
| if( ret1 == 0 && ret2 == 0 ) |
| { |
| /* If both are not found, return both "zero strings". |
| */ |
| ret = 0; |
| } |
| else if( ret1 == 0 ) |
| { |
| /* If hsz1 is a not found, return hsz1 is "zero string". |
| */ |
| ret = -1; |
| } |
| else if( ret2 == 0 ) |
| { |
| /* If hsz2 is a not found, return hsz2 is "zero string". |
| */ |
| ret = 1; |
| } |
| else |
| { |
| /* Compare the two strings we got ( case insensitive ). |
| */ |
| ret = strcasecmp( psz1, psz2 ); |
| /* Since strcmp returns any number smaller than |
| * 0 when the first string is found to be less than |
| * the second one we must make sure we are returning |
| * the proper values. |
| */ |
| if( ret < 0 ) |
| { |
| ret = -1; |
| } |
| else if( ret > 0 ) |
| { |
| ret = 1; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /***************************************************************** |
| * DdeCmpStringHandles32W (USER32.623) |
| * |
| * Compares the value of two string handles. This comparison is |
| * not case sensitive. |
| * |
| * Returns: |
| * -1 The value of hsz1 is zero or less than hsz2 |
| * 0 The values of hsz 1 and 2 are the same or both zero. |
| * 1 The value of hsz2 is zero of less than hsz1 |
| */ |
| int WINAPI DdeCmpStringHandles32W( HSZ hsz1, HSZ hsz2 ) |
| { |
| WCHAR pwsz1[MAX_BUFFER_LEN]; |
| WCHAR pwsz2[MAX_BUFFER_LEN]; |
| int ret = 0; |
| int ret1, ret2; |
| |
| TRACE( ddeml, "handle 1, handle 2\n" ); |
| |
| ret1 = GlobalGetAtomName32W( hsz1, pwsz1, MAX_BUFFER_LEN ); |
| ret2 = GlobalGetAtomName32W( hsz2, pwsz2, MAX_BUFFER_LEN ); |
| /* Make sure we found both strings. |
| */ |
| if( ret1 == 0 && ret2 == 0 ) |
| { |
| /* If both are not found, return both "zero strings". |
| */ |
| ret = 0; |
| } |
| else if( ret1 == 0 ) |
| { |
| /* If hsz1 is a not found, return hsz1 is "zero string". |
| */ |
| ret = -1; |
| } |
| else if( ret2 == 0 ) |
| { |
| /* If hsz2 is a not found, return hsz2 is "zero string". |
| */ |
| ret = 1; |
| } |
| else |
| { |
| LPSTR psz1, psz2; |
| psz1 = HEAP_strdupWtoA( GetProcessHeap(), 0, pwsz1 ); |
| psz2 = HEAP_strdupWtoA( GetProcessHeap(), 0, pwsz2 ); |
| if( psz1 != NULL && psz2 != NULL ) |
| { |
| /* Compare the two strings we got ( case insensitive ). |
| */ |
| ret = strcasecmp( psz1, psz2 ); |
| /* Since strcmp returns any number smaller than |
| * 0 when the first string is found to be less than |
| * the second one we must make sure we are returning |
| * the proper values. |
| */ |
| if( ret < 0 ) |
| { |
| ret = -1; |
| } |
| else if( ret > 0 ) |
| { |
| ret = 1; |
| } |
| } |
| HeapFree( GetProcessHeap(), 0, psz1 ); |
| HeapFree( GetProcessHeap(), 0, psz2 ); |
| } |
| return ret; |
| } |
| |
| |
| /***************************************************************** |
| * PackDDElParam (USER32.414) |
| * |
| * RETURNS |
| * success: nonzero |
| * failure: zero |
| */ |
| UINT32 WINAPI PackDDElParam(UINT32 msg, UINT32 uiLo, UINT32 uiHi) |
| { |
| FIXME(ddeml, "stub.\n"); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * UnpackDDElParam (USER32.562) |
| * |
| * RETURNS |
| * success: nonzero |
| * failure: zero |
| */ |
| UINT32 WINAPI UnpackDDElParam(UINT32 msg, UINT32 lParam, |
| UINT32 *uiLo, UINT32 *uiHi) |
| { |
| FIXME(ddeml, "stub.\n"); |
| return 0; |
| } |
| |
| |
| /***************************************************************** |
| * FreeDDElParam (USER32.204) |
| * |
| * RETURNS |
| * success: nonzero |
| * failure: zero |
| */ |
| UINT32 WINAPI FreeDDElParam(UINT32 msg, UINT32 lParam) |
| { |
| FIXME(ddeml, "stub.\n"); |
| return 0; |
| } |
| |
| /***************************************************************** |
| * ReuseDDElParam (USER32.446) |
| * |
| */ |
| UINT32 WINAPI ReuseDDElParam(UINT32 lParam, UINT32 msgIn, UINT32 msgOut, |
| UINT32 uiLi, UINT32 uiHi) |
| { |
| FIXME(ddeml, "stub.\n"); |
| return 0; |
| } |
