Return to proghelp.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / ddeml / ddeprog

Annotation of mstools/samples/ddeml/ddeprog/proghelp.c, revision 1.1

1.1     ! root        1: /*****************************************************************************\
        !             2: * PROGHELP.C
        !             3: *
        !             4: * Main module to implement a simple DDEML service DLL that makes interaction
        !             5: * with progman simple.
        !             6: \*****************************************************************************/
        !             7: 
        !             8: #include <windows.h>
        !             9: #include <ddeml.h>
        !            10: #include <string.h>
        !            11: 
        !            12: typedef struct {
        !            13:     HCONV hConv;
        !            14:     DWORD idInst;
        !            15:     int cTransactionsInProgress;
        !            16: } THREADINFO;
        !            17: 
        !            18: DWORD TlsIndex;
        !            19: 
        !            20: /*
        !            21:  * This is the default DDEML callback function for ProgHelp
        !            22:  */
        !            23: HDDEDATA CALLBACK ProgHelpDdeCallback(
        !            24: UINT wType,
        !            25: UINT wFmt,
        !            26: HCONV hConv,
        !            27: HSZ hsz1,
        !            28: HSZ hsz2,
        !            29: HDDEDATA hData,
        !            30: DWORD dwData1,
        !            31: DWORD dwData2)
        !            32: {
        !            33:     THREADINFO *pti;
        !            34: 
        !            35:     switch (wType) {
        !            36:     case XTYP_XACT_COMPLETE:
        !            37:         pti = TlsGetValue(TlsIndex);
        !            38:         pti->cTransactionsInProgress--;
        !            39:         break;
        !            40:     }
        !            41:     return(0);
        !            42: }
        !            43: 
        !            44: 
        !            45: /*
        !            46:  * This is the DLL init routine called by the system at attach/detatch time.
        !            47:  *
        !            48:  * We allocate a Tls for each thread that calls this DLL so that their state
        !            49:  * can be tracked independently.
        !            50:  */
        !            51: BOOLEAN APIENTRY ProgHelpInit(
        !            52: IN PVOID hmod,
        !            53: ULONG Reason,
        !            54: IN PCONTEXT pctx OPTIONAL)
        !            55: {
        !            56:     THREADINFO *pti;
        !            57:     UNREFERENCED_PARAMETER(hmod);
        !            58:     UNREFERENCED_PARAMETER(pctx);
        !            59: 
        !            60:     switch (Reason) {
        !            61:     case DLL_THREAD_ATTACH:
        !            62:     case DLL_PROCESS_ATTACH:
        !            63:         TlsIndex = TlsAlloc();
        !            64:         pti = (THREADINFO *)LocalAlloc(LPTR, sizeof(THREADINFO));
        !            65:         if (!pti) {
        !            66:             return(FALSE);
        !            67:         }
        !            68:         TlsSetValue(TlsIndex, pti);
        !            69:         break;
        !            70: 
        !            71:     case DLL_THREAD_DETACH:
        !            72:     case DLL_PROCESS_DETACH:
        !            73:         pti = TlsGetValue(TlsIndex);
        !            74:         LocalFree(pti);
        !            75:         TlsFree(TlsIndex);
        !            76:         break;
        !            77:     }
        !            78:     return TRUE;
        !            79: }
        !            80: 
        !            81: /*
        !            82:  * An application must call this API first to establish a conversation
        !            83:  * with progman.  DDEML initialization is done automatically if needed.
        !            84:  */
        !            85: BOOL ConnectToProgman()
        !            86: {
        !            87:     THREADINFO *pti;
        !            88:     HSZ hszProgman;
        !            89: 
        !            90:     pti = TlsGetValue(TlsIndex);
        !            91: 
        !            92:     if (!pti->idInst) {
        !            93:         if (DdeInitialize(&(pti->idInst), ProgHelpDdeCallback,
        !            94:                 APPCMD_CLIENTONLY | CBF_SKIP_ALLNOTIFICATIONS,
        !            95:                 0L) != DMLERR_NO_ERROR) {
        !            96:             return(FALSE);
        !            97:         }
        !            98:     }
        !            99: 
        !           100:     if (pti->hConv == 0) {
        !           101:         hszProgman = DdeCreateStringHandle(pti->idInst, "Progman", 0);
        !           102:         pti->hConv = DdeConnect(pti->idInst, hszProgman, hszProgman, NULL);
        !           103:     }
        !           104:     return(pti->hConv != 0);
        !           105: }
        !           106: 
        !           107: /*
        !           108:  * This API should be called when operations with progman are complete.
        !           109:  * We shutdown DDEML here as well so we don't have to deal with it
        !           110:  * at DLL detatch time.  FALSE is returned if there are any transactions
        !           111:  * still in progress.  This lets the calling application know that it
        !           112:  * must wait awhile longer for progman to complete its processing and
        !           113:  * then try disconnecting again later.
        !           114:  */
        !           115: BOOL DisconnectFromProgman()
        !           116: {
        !           117:     THREADINFO *pti;
        !           118: 
        !           119:     pti = TlsGetValue(TlsIndex);
        !           120: 
        !           121:     if (pti->cTransactionsInProgress) {
        !           122:         return(FALSE);
        !           123:     }
        !           124: 
        !           125:     if (!pti->idInst) {
        !           126:         return(TRUE);
        !           127:     }
        !           128: 
        !           129:     if (pti->hConv) {
        !           130:         DdeDisconnect(pti->hConv);
        !           131:         pti->hConv = 0;
        !           132:     }
        !           133: 
        !           134:     DdeUninitialize(pti->idInst);
        !           135:     return(TRUE);
        !           136: }
        !           137: 
        !           138: 
        !           139: /*
        !           140:  * This API sends an ASCII execute string to progman.  It immediately returns
        !           141:  * and the results of the execute are not known.  Calling applications should
        !           142:  * be aware that these transactions are done asynchronously.  This allows
        !           143:  * this API to work under modal-loop conditions.  DisconnectFromProgman()
        !           144:  * will not succeed until all transactions are complete.
        !           145:  */
        !           146: BOOL ProgmanExecuteString(
        !           147: LPCSTR pszExec)
        !           148: {
        !           149:     THREADINFO *pti;
        !           150:     DWORD dwResult;
        !           151: 
        !           152:     pti = TlsGetValue(TlsIndex);
        !           153: 
        !           154:     if (!pti->idInst || !pti->hConv) {
        !           155:         return(FALSE);
        !           156:     }
        !           157:     if (!DdeClientTransaction((PBYTE)pszExec, strlen(pszExec) + 1,
        !           158:             pti->hConv, 0, 0, XTYP_EXECUTE, TIMEOUT_ASYNC, &dwResult)) {
        !           159:         return(FALSE);
        !           160:     }
        !           161:     pti->cTransactionsInProgress++;
        !           162:     return(TRUE);
        !           163: }
        !           164: 
        !           165: 
        !           166: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.