Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

ntcb.h File Reference

Go to the source code of this file.

Classes

struct  _GENERICHOOKHEADER
struct  _FNOUTDWORDDWORDMSG
struct  _FNOUTDWORDINDWORDMSG
struct  _FNOPTOUTLPDWORDOPTOUTLPDWORDMSG
struct  _FNDWORDOPTINLPMSGMSG
struct  _FNCOPYGLOBALDATAMSG
struct  _FNCOPYDATAMSG
struct  _FNSENTDDEMSGMSG
struct  _FNDWORDMSG
struct  _FNINWPARAMCHARMSG
struct  _FNINWPARAMDBCSCHARMSG
struct  _FNINOUTDRAGMSG
struct  _FNGETTEXTLENGTHSMSG
struct  _FNINLPCREATESTRUCTMSG
struct  _FNINLPMDICREATESTRUCTMSG
struct  _FNINPAINTCLIPBRDMSG
struct  _FNINSIZECLIPBRDMSG
struct  _FNINDESTROYCLIPBRDMSG
struct  _FNINOUTLPSCROLLINFOMSG
struct  _FNINOUTLPPOINT5MSG
struct  _FNINOUTLPRECTMSG
struct  _FNINOUTNCCALCSIZEMSG
struct  _OUTNCCALCSIZE
struct  _FNINOUTSTYLECHANGEMSG
struct  _FNOUTLPRECTMSG
struct  _FNINLPCOMPAREITEMSTRUCTMSG
struct  _FNINLPDELETEITEMSTRUCTMSG
struct  _FNINLPHLPSTRUCTMSG
struct  _FNINLPHELPFINFOSTRUCTMSG
struct  _FNINLPDRAWITEMSTRUCTMSG
struct  _FNINOUTLPMEASUREITEMSTRUCTMSG
struct  _FNINSTRINGMSG
struct  _FNINSTRINGNULLMSG
struct  _FNINLPKDRAWSWITCHWNDMSG
struct  _FNINDEVICECHANGEMSG
struct  _FNOUTSTRINGMSG
struct  _FNINCNTOUTSTRING
struct  _FNINCNTOUTSTRINGNULL
struct  _FNPOUTLPINTMSG
struct  _FNPOPTINLPUINTMSG
struct  _FNINOUTLPWINDOWPOSMSG
struct  _FNINLPWINDOWPOSMSG
struct  _FNINOUTNEXTMENUMSG
struct  _CREATESTRUCTDATA
struct  _FNHKINLPCBTCREATESTRUCTMSG
struct  _FNHKINLPRECTMSG
struct  _FNHKINDWORDMSG
struct  _FNHKINLPMSGDATA
struct  _FNHKINLPMSGMSG
struct  _FNHKINLPMOUSEHOOKSTRUCTEXMSG
struct  _FNHKINLPKBDLLHOOKSTRUCTMSG
struct  _FNHKINLPMSLLHOOKSTRUCTMSG
struct  _FNHKOPTINLPEVENTMSGMSG
union  _DEBUGLPARAM
struct  _FNHKINLPDEBUGHOOKSTRUCTMSG
struct  _FNHKINLPCBTACTIVATESTRUCTMSG
struct  _CLIENTLOADMENUMSG
struct  _CLIENTLOADIMAGEMSG
struct  _CLIENTCOPYIMAGEMSG
struct  _CLIENTGETLISTBOXSTRINGMSG
struct  _CLIENTLOADLIBRARYMSG
struct  _CLIENTFREELIBRARYMSG
struct  _CLIENTGETCHARSETINFOMSG
struct  _CLIENTFREEDDEHANDLEMSG
struct  _CLIENTGETDDEFLAGSMSG
struct  _CLIENTCOPYDDEIN1MSG
struct  _CLIENTCOPYDDEIN2MSG
struct  _CLIENTCOPYDDEOUT2MSG
struct  _CLIENTCOPYDDEOUT1MSG
struct  _CLIENTEVENTCALLBACKMSG
struct  _CLIENTGETDDEHOOKDATAMSG
struct  _CLIENTCHARTOWCHARMSG
struct  _CLIENTFINDMNEMCHARMSG
struct  _CLIENTPSMTEXTOUTMSG
struct  _CLIENTLPKDRAWTEXTEXMSG
struct  _CLIENTEXTTEXTOUTW
struct  _CLIENTGETTEXTEXTENTPOINTW
struct  _CLIENTADDFONTRESOURCEWMSG
struct  _CLIENTIMMLOADLAYOUTMSG
struct  _CLIENTIMMPROCESSKEYMSG
struct  _FNIMECONTROL
struct  _FNGETDBCSTEXTLENGTHSMSG
struct  _CLIENTMONITORENUMPROCMSG
struct  _FNINOUTMENUGETOBJECTMSG
struct  _FNLOGONNOTIFYMSG
struct  _CLIENTCALLWINEVENTPROCMSG
struct  _CLIENTWOWGETPROCMODULEMSG

Defines

#define CLIENTPRINTERTHUNKMSG   UMTHDR

Typedefs

typedef _GENERICHOOKHEADER GENERICHOOKHEADER
typedef _GENERICHOOKHEADER * LPGENERICHOOKHEADER
typedef _FNOUTDWORDDWORDMSG FNOUTDWORDDWORDMSG
typedef _FNOUTDWORDINDWORDMSG FNOUTDWORDINDWORDMSG
typedef _FNOPTOUTLPDWORDOPTOUTLPDWORDMSG FNOPTOUTLPDWORDOPTOUTLPDWORDMSG
typedef _FNDWORDOPTINLPMSGMSG FNDWORDOPTINLPMSGMSG
typedef _FNCOPYGLOBALDATAMSG FNCOPYGLOBALDATAMSG
typedef _FNCOPYDATAMSG FNCOPYDATAMSG
typedef _FNSENTDDEMSGMSG FNSENTDDEMSGMSG
typedef _FNDWORDMSG FNDWORDMSG
typedef _FNINWPARAMCHARMSG FNINWPARAMCHARMSG
typedef _FNINWPARAMDBCSCHARMSG FNINWPARAMDBCSCHARMSG
typedef _FNINOUTDRAGMSG FNINOUTDRAGMSG
typedef _FNGETTEXTLENGTHSMSG FNGETTEXTLENGTHSMSG
typedef _FNINLPCREATESTRUCTMSG FNINLPCREATESTRUCTMSG
typedef _FNINLPMDICREATESTRUCTMSG FNINLPMDICREATESTRUCTMSG
typedef _FNINPAINTCLIPBRDMSG FNINPAINTCLIPBRDMSG
typedef _FNINSIZECLIPBRDMSG FNINSIZECLIPBRDMSG
typedef _FNINDESTROYCLIPBRDMSG FNINDESTROYCLIPBRDMSG
typedef _FNINOUTLPSCROLLINFOMSG FNINOUTLPSCROLLINFOMSG
typedef _FNINOUTLPPOINT5MSG FNINOUTLPPOINT5MSG
typedef _FNINOUTLPRECTMSG FNINOUTLPRECTMSG
typedef _FNINOUTNCCALCSIZEMSG FNINOUTNCCALCSIZEMSG
typedef _OUTNCCALCSIZE OUTNCCALCSIZE
typedef _OUTNCCALCSIZE * POUTNCCALCSIZE
typedef _FNINOUTSTYLECHANGEMSG FNINOUTSTYLECHANGEMSG
typedef _FNOUTLPRECTMSG FNOUTLPRECTMSG
typedef _FNINLPCOMPAREITEMSTRUCTMSG FNINLPCOMPAREITEMSTRUCTMSG
typedef _FNINLPDELETEITEMSTRUCTMSG FNINLPDELETEITEMSTRUCTMSG
typedef _FNINLPHLPSTRUCTMSG FNINLPHLPSTRUCTMSG
typedef _FNINLPHELPFINFOSTRUCTMSG FNINLPHELPINFOSTRUCTMSG
typedef _FNINLPDRAWITEMSTRUCTMSG FNINLPDRAWITEMSTRUCTMSG
typedef _FNINOUTLPMEASUREITEMSTRUCTMSG FNINOUTLPMEASUREITEMSTRUCTMSG
typedef _FNINSTRINGMSG FNINSTRINGMSG
typedef _FNINSTRINGNULLMSG FNINSTRINGNULLMSG
typedef _FNINLPKDRAWSWITCHWNDMSG FNINLPKDRAWSWITCHWNDMSG
typedef _FNINDEVICECHANGEMSG FNINDEVICECHANGEMSG
typedef _FNOUTSTRINGMSG FNOUTSTRINGMSG
typedef _FNINCNTOUTSTRING FNINCNTOUTSTRINGMSG
typedef _FNINCNTOUTSTRINGNULL FNINCNTOUTSTRINGNULLMSG
typedef _FNPOUTLPINTMSG FNPOUTLPINTMSG
typedef _FNPOPTINLPUINTMSG FNPOPTINLPUINTMSG
typedef _FNINOUTLPWINDOWPOSMSG FNINOUTLPWINDOWPOSMSG
typedef _FNINLPWINDOWPOSMSG FNINLPWINDOWPOSMSG
typedef _FNINOUTNEXTMENUMSG FNINOUTNEXTMENUMSG
typedef _CREATESTRUCTDATA CREATESTRUCTDATA
typedef _FNHKINLPCBTCREATESTRUCTMSG FNHKINLPCBTCREATESTRUCTMSG
typedef _FNHKINLPRECTMSG FNHKINLPRECTMSG
typedef _FNHKINDWORDMSG FNHKINDWORDMSG
typedef _FNHKINLPMSGDATA FNHKINLPMSGDATA
typedef _FNHKINLPMSGMSG FNHKINLPMSGMSG
typedef _FNHKINLPMOUSEHOOKSTRUCTEXMSG FNHKINLPMOUSEHOOKSTRUCTEXMSG
typedef _FNHKINLPKBDLLHOOKSTRUCTMSG FNHKINLPKBDLLHOOKSTRUCTMSG
typedef _FNHKINLPMSLLHOOKSTRUCTMSG FNHKINLPMSLLHOOKSTRUCTMSG
typedef _FNHKOPTINLPEVENTMSGMSG FNHKOPTINLPEVENTMSGMSG
typedef _DEBUGLPARAM DEBUGLPARAM
typedef _FNHKINLPDEBUGHOOKSTRUCTMSG FNHKINLPDEBUGHOOKSTRUCTMSG
typedef _FNHKINLPCBTACTIVATESTRUCTMSG FNHKINLPCBTACTIVATESTRUCTMSG
typedef _CLIENTLOADMENUMSG CLIENTLOADMENUMSG
typedef _CLIENTLOADIMAGEMSG CLIENTLOADIMAGEMSG
typedef _CLIENTCOPYIMAGEMSG CLIENTCOPYIMAGEMSG
typedef _CLIENTGETLISTBOXSTRINGMSG CLIENTGETLISTBOXSTRINGMSG
typedef _CLIENTLOADLIBRARYMSG CLIENTLOADLIBRARYMSG
typedef _CLIENTFREELIBRARYMSG CLIENTFREELIBRARYMSG
typedef _CLIENTGETCHARSETINFOMSG CLIENTGETCHARSETINFOMSG
typedef _CLIENTFREEDDEHANDLEMSG CLIENTFREEDDEHANDLEMSG
typedef _CLIENTGETDDEFLAGSMSG CLIENTGETDDEFLAGSMSG
typedef _CLIENTCOPYDDEIN1MSG CLIENTCOPYDDEIN1MSG
typedef _CLIENTCOPYDDEIN2MSG CLIENTCOPYDDEIN2MSG
typedef _CLIENTCOPYDDEOUT2MSG CLIENTCOPYDDEOUT2MSG
typedef _CLIENTCOPYDDEOUT1MSG CLIENTCOPYDDEOUT1MSG
typedef _CLIENTEVENTCALLBACKMSG CLIENTEVENTCALLBACKMSG
typedef _CLIENTGETDDEHOOKDATAMSG CLIENTGETDDEHOOKDATAMSG
typedef _CLIENTCHARTOWCHARMSG CLIENTCHARTOWCHARMSG
typedef _CLIENTFINDMNEMCHARMSG CLIENTFINDMNEMCHARMSG
typedef _CLIENTPSMTEXTOUTMSG CLIENTPSMTEXTOUTMSG
typedef _CLIENTLPKDRAWTEXTEXMSG CLIENTLPKDRAWTEXTEXMSG
typedef _CLIENTEXTTEXTOUTW CLIENTEXTTEXTOUTWMSG
typedef _CLIENTGETTEXTEXTENTPOINTW CLIENTGETTEXTEXTENTPOINTWMSG
typedef _CLIENTADDFONTRESOURCEWMSG CLIENTADDFONTRESOURCEWMSG
typedef _CLIENTIMMLOADLAYOUTMSG CLIENTIMMLOADLAYOUTMSG
typedef _CLIENTIMMPROCESSKEYMSG CLIENTIMMPROCESSKEYMSG
typedef _FNIMECONTROL FNIMECONTROLMSG
typedef _FNGETDBCSTEXTLENGTHSMSG FNGETDBCSTEXTLENGTHSMSG
typedef _CLIENTMONITORENUMPROCMSG CLIENTMONITORENUMPROCMSG
typedef _FNINOUTMENUGETOBJECTMSG FNINOUTMENUGETOBJECTMSG
typedef _FNLOGONNOTIFYMSG FNLOGONNOTIFYMSG
typedef _CLIENTCALLWINEVENTPROCMSG CLIENTCALLWINEVENTPROCMSG
typedef _CLIENTWOWGETPROCMODULEMSG CLIENTWOWGETPROCMODULEMSG

Functions

DWORD _ClientCopyDDEIn1 (HANDLE hClient, PINTDDEINFO pi)
VOID _ClientCopyDDEIn2 (PINTDDEINFO pi)
HANDLE _ClientCopyDDEOut1 (PINTDDEINFO pi)
BOOL xxxClientCopyDDEIn2 (PINTDDEINFO pi)
BOOL FixupDdeExecuteIfNecessary (HGLOBAL *phCommands, BOOL fNeedUnicode)
BOOL _ClientCopyDDEOut2 (PINTDDEINFO pi)
BOOL _ClientFreeDDEHandle (HANDLE hDDE, DWORD flags)
DWORD _ClientGetDDEFlags (HANDLE hDDE, DWORD flags)
DWORD GetDebugHookLParamSize (IN WPARAM wParam, IN PDEBUGHOOKINFO pdebughookstruct)

Define Documentation

#define CLIENTPRINTERTHUNKMSG   UMTHDR
 

Definition at line 6259 of file ntcb.h.

Typedef Documentation

typedef struct _CLIENTADDFONTRESOURCEWMSG CLIENTADDFONTRESOURCEWMSG
 

typedef struct _CLIENTCALLWINEVENTPROCMSG CLIENTCALLWINEVENTPROCMSG
 

typedef struct _CLIENTCHARTOWCHARMSG CLIENTCHARTOWCHARMSG
 

typedef struct _CLIENTCOPYDDEIN1MSG CLIENTCOPYDDEIN1MSG
 

typedef struct _CLIENTCOPYDDEIN2MSG CLIENTCOPYDDEIN2MSG
 

typedef struct _CLIENTCOPYDDEOUT1MSG CLIENTCOPYDDEOUT1MSG
 

typedef struct _CLIENTCOPYDDEOUT2MSG CLIENTCOPYDDEOUT2MSG
 

typedef struct _CLIENTCOPYIMAGEMSG CLIENTCOPYIMAGEMSG
 

typedef struct _CLIENTEVENTCALLBACKMSG CLIENTEVENTCALLBACKMSG
 

typedef struct _CLIENTEXTTEXTOUTW CLIENTEXTTEXTOUTWMSG
 

typedef struct _CLIENTFINDMNEMCHARMSG CLIENTFINDMNEMCHARMSG
 

typedef struct _CLIENTFREEDDEHANDLEMSG CLIENTFREEDDEHANDLEMSG
 

typedef struct _CLIENTFREELIBRARYMSG CLIENTFREELIBRARYMSG
 

typedef struct _CLIENTGETCHARSETINFOMSG CLIENTGETCHARSETINFOMSG
 

typedef struct _CLIENTGETDDEFLAGSMSG CLIENTGETDDEFLAGSMSG
 

typedef struct _CLIENTGETDDEHOOKDATAMSG CLIENTGETDDEHOOKDATAMSG
 

typedef struct _CLIENTGETLISTBOXSTRINGMSG CLIENTGETLISTBOXSTRINGMSG
 

typedef struct _CLIENTGETTEXTEXTENTPOINTW CLIENTGETTEXTEXTENTPOINTWMSG
 

typedef struct _CLIENTIMMLOADLAYOUTMSG CLIENTIMMLOADLAYOUTMSG
 

typedef struct _CLIENTIMMPROCESSKEYMSG CLIENTIMMPROCESSKEYMSG
 

typedef struct _CLIENTLOADIMAGEMSG CLIENTLOADIMAGEMSG
 

typedef struct _CLIENTLOADLIBRARYMSG CLIENTLOADLIBRARYMSG
 

typedef struct _CLIENTLOADMENUMSG CLIENTLOADMENUMSG
 

typedef struct _CLIENTLPKDRAWTEXTEXMSG CLIENTLPKDRAWTEXTEXMSG
 

typedef struct _CLIENTMONITORENUMPROCMSG CLIENTMONITORENUMPROCMSG
 

typedef struct _CLIENTPSMTEXTOUTMSG CLIENTPSMTEXTOUTMSG
 

typedef struct _CLIENTWOWGETPROCMODULEMSG CLIENTWOWGETPROCMODULEMSG
 

typedef struct _CREATESTRUCTDATA CREATESTRUCTDATA
 

typedef union _DEBUGLPARAM DEBUGLPARAM
 

typedef struct _FNCOPYDATAMSG FNCOPYDATAMSG
 

typedef struct _FNCOPYGLOBALDATAMSG FNCOPYGLOBALDATAMSG
 

typedef struct _FNDWORDMSG FNDWORDMSG
 

typedef struct _FNDWORDOPTINLPMSGMSG FNDWORDOPTINLPMSGMSG
 

typedef struct _FNGETDBCSTEXTLENGTHSMSG FNGETDBCSTEXTLENGTHSMSG
 

typedef struct _FNGETTEXTLENGTHSMSG FNGETTEXTLENGTHSMSG
 

typedef struct _FNHKINDWORDMSG FNHKINDWORDMSG
 

typedef struct _FNHKINLPCBTACTIVATESTRUCTMSG FNHKINLPCBTACTIVATESTRUCTMSG
 

typedef struct _FNHKINLPCBTCREATESTRUCTMSG FNHKINLPCBTCREATESTRUCTMSG
 

typedef struct _FNHKINLPDEBUGHOOKSTRUCTMSG FNHKINLPDEBUGHOOKSTRUCTMSG
 

typedef struct _FNHKINLPKBDLLHOOKSTRUCTMSG FNHKINLPKBDLLHOOKSTRUCTMSG
 

typedef struct _FNHKINLPMOUSEHOOKSTRUCTEXMSG FNHKINLPMOUSEHOOKSTRUCTEXMSG
 

typedef struct _FNHKINLPMSGDATA FNHKINLPMSGDATA
 

typedef struct _FNHKINLPMSGMSG FNHKINLPMSGMSG
 

typedef struct _FNHKINLPMSLLHOOKSTRUCTMSG FNHKINLPMSLLHOOKSTRUCTMSG
 

typedef struct _FNHKINLPRECTMSG FNHKINLPRECTMSG
 

typedef struct _FNHKOPTINLPEVENTMSGMSG FNHKOPTINLPEVENTMSGMSG
 

typedef struct _FNIMECONTROL FNIMECONTROLMSG
 

typedef struct _FNINCNTOUTSTRING FNINCNTOUTSTRINGMSG
 

typedef struct _FNINCNTOUTSTRINGNULL FNINCNTOUTSTRINGNULLMSG
 

typedef struct _FNINDESTROYCLIPBRDMSG FNINDESTROYCLIPBRDMSG
 

typedef struct _FNINDEVICECHANGEMSG FNINDEVICECHANGEMSG
 

typedef struct _FNINLPCOMPAREITEMSTRUCTMSG FNINLPCOMPAREITEMSTRUCTMSG
 

typedef struct _FNINLPCREATESTRUCTMSG FNINLPCREATESTRUCTMSG
 

typedef struct _FNINLPDELETEITEMSTRUCTMSG FNINLPDELETEITEMSTRUCTMSG
 

typedef struct _FNINLPDRAWITEMSTRUCTMSG FNINLPDRAWITEMSTRUCTMSG
 

typedef struct _FNINLPHELPFINFOSTRUCTMSG FNINLPHELPINFOSTRUCTMSG
 

typedef struct _FNINLPHLPSTRUCTMSG FNINLPHLPSTRUCTMSG
 

typedef struct _FNINLPKDRAWSWITCHWNDMSG FNINLPKDRAWSWITCHWNDMSG
 

typedef struct _FNINLPMDICREATESTRUCTMSG FNINLPMDICREATESTRUCTMSG
 

typedef struct _FNINLPWINDOWPOSMSG FNINLPWINDOWPOSMSG
 

typedef struct _FNINOUTDRAGMSG FNINOUTDRAGMSG
 

typedef struct _FNINOUTLPMEASUREITEMSTRUCTMSG FNINOUTLPMEASUREITEMSTRUCTMSG
 

typedef struct _FNINOUTLPPOINT5MSG FNINOUTLPPOINT5MSG
 

typedef struct _FNINOUTLPRECTMSG FNINOUTLPRECTMSG
 

typedef struct _FNINOUTLPSCROLLINFOMSG FNINOUTLPSCROLLINFOMSG
 

typedef struct _FNINOUTLPWINDOWPOSMSG FNINOUTLPWINDOWPOSMSG
 

typedef struct _FNINOUTMENUGETOBJECTMSG FNINOUTMENUGETOBJECTMSG
 

typedef struct _FNINOUTNCCALCSIZEMSG FNINOUTNCCALCSIZEMSG
 

typedef struct _FNINOUTNEXTMENUMSG FNINOUTNEXTMENUMSG
 

typedef struct _FNINOUTSTYLECHANGEMSG FNINOUTSTYLECHANGEMSG
 

typedef struct _FNINPAINTCLIPBRDMSG FNINPAINTCLIPBRDMSG
 

typedef struct _FNINSIZECLIPBRDMSG FNINSIZECLIPBRDMSG
 

typedef struct _FNINSTRINGMSG FNINSTRINGMSG
 

typedef struct _FNINSTRINGNULLMSG FNINSTRINGNULLMSG
 

typedef struct _FNINWPARAMCHARMSG FNINWPARAMCHARMSG
 

typedef struct _FNINWPARAMDBCSCHARMSG FNINWPARAMDBCSCHARMSG
 

typedef struct _FNLOGONNOTIFYMSG FNLOGONNOTIFYMSG
 

typedef struct _FNOPTOUTLPDWORDOPTOUTLPDWORDMSG FNOPTOUTLPDWORDOPTOUTLPDWORDMSG
 

typedef struct _FNOUTDWORDDWORDMSG FNOUTDWORDDWORDMSG
 

typedef struct _FNOUTDWORDINDWORDMSG FNOUTDWORDINDWORDMSG
 

typedef struct _FNOUTLPRECTMSG FNOUTLPRECTMSG
 

typedef struct _FNOUTSTRINGMSG FNOUTSTRINGMSG
 

typedef struct _FNPOPTINLPUINTMSG FNPOPTINLPUINTMSG
 

typedef struct _FNPOUTLPINTMSG FNPOUTLPINTMSG
 

typedef struct _FNSENTDDEMSGMSG FNSENTDDEMSGMSG
 

typedef struct _GENERICHOOKHEADER GENERICHOOKHEADER
 

typedef struct _GENERICHOOKHEADER * LPGENERICHOOKHEADER
 

typedef struct _OUTNCCALCSIZE OUTNCCALCSIZE
 

typedef struct _OUTNCCALCSIZE * POUTNCCALCSIZE
 

Function Documentation

DWORD _ClientCopyDDEIn1 (  HANDLE  hClient,
PINTDDEINFO  pi
) 
 

Definition at line 15 of file client/ddetrack.c.

References tagINTDDEINFO::cbDirect, tagINTDDEINFO::cbIndirect, tagDDE_DATA::Data, DDE_DATA, tagINTDDEINFO::DdePack, DDEPACK, DO_POST, DWORD, FAIL_POST, FAILNOFREE_POST, tagINTDDEINFO::flags, tagINTDDEINFO::hDirect, tagINTDDEINFO::hIndirect, INTDDEINFO, NULL, PBYTE, PDDE_DATA, PDDEPACK, tagINTDDEINFO::pDirect, tagINTDDEINFO::pIndirect, PINTDDEINFO, tagDDEPACK::uiHi, tagDDEPACK::uiLo, UINT, UserGlobalFree, USERGLOBALLOCK, UserGlobalSize, USERGLOBALUNLOCK, tagDDE_DATA::wFmt, WOWGLOBALFREE, XS_BITMAP, XS_DATA, XS_DIB, XS_ENHMETAFILE, XS_EXECUTE, XS_FREESRC, XS_HIHANDLE, XS_LOHANDLE, XS_METAFILEPICT, XS_PACKED, and XS_PALETTE. 

00018 {
00019     PBYTE pData;
00020     DWORD flags;
00021 
00022     //
00023     // zero out everything but the flags
00024     //
00025     flags = pi->flags;
00026     RtlZeroMemory(pi, sizeof(INTDDEINFO));
00027     pi->flags = flags;
00028     USERGLOBALLOCK(hClient, pData);
00029 
00030     if (pData == NULL) {                            // bad hClient
00031         RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:GlobalLock failed.");
00032         return (FAIL_POST);
00033     }
00034 
00035     if (flags & XS_PACKED) {
00036 
00037         if (UserGlobalSize(hClient) < sizeof(DDEPACK)) {
00038             /*
00039              * must be a low memory condition. fail.
00040              */
00041             return(FAIL_POST);
00042         }
00043 
00044         pi->DdePack = *(PDDEPACK)pData;
00045         USERGLOBALUNLOCK(hClient);
00046         UserGlobalFree(hClient);    // packed data handles are not WOW matched.
00047         hClient = NULL;
00048 
00049         if (!(flags & (XS_LOHANDLE | XS_HIHANDLE))) {
00050             if (flags & XS_EXECUTE && flags & XS_FREESRC) {
00051                 /*
00052                  * free execute ACK data
00053                  */
00054                 WOWGLOBALFREE((HANDLE)pi->DdePack.uiHi);
00055             }
00056             return (DO_POST); // no direct data
00057         }
00058 
00059         if (flags & XS_LOHANDLE) {
00060             pi->hDirect = (HANDLE)pi->DdePack.uiLo;
00061         } else {
00062             pi->hDirect = (HANDLE)pi->DdePack.uiHi;
00063         }
00064 
00065         if (pi->hDirect == 0) {
00066             return (DO_POST); // must be warm link
00067         }
00068 
00069         USERGLOBALLOCK(pi->hDirect, pi->pDirect);
00070         if (pi->pDirect == NULL) {
00071             RIPMSG1(RIP_ERROR, "_ClientCopyDDEIn1:GlobalLock failed for hDirect %lx.",pi->hDirect);
00072             return FAILNOFREE_POST;
00073         }
00074         pData = pi->pDirect;
00075         pi->cbDirect = (UINT)UserGlobalSize(pi->hDirect);
00076 
00077     } else {    // not packed - must be execute data or we wouldn't be called
00078 
00079         UserAssert(flags & XS_EXECUTE);
00080 
00081         pi->cbDirect = (UINT)UserGlobalSize(hClient);
00082         pi->hDirect = hClient;
00083         pi->pDirect = pData;
00084         hClient = NULL;
00085     }
00086 
00087     if (flags & XS_DATA) {
00088         PDDE_DATA pDdeData = (PDDE_DATA)pData;
00089 
00090         /*
00091          * Assert that the hClient has been freed. If not this code will return
00092          * the wrong thing on failure
00093          */
00094         UserAssert(flags & XS_PACKED);
00095 
00096         //
00097         // check here for indirect data
00098         //
00099 
00100         switch (pDdeData->wFmt) {
00101         case CF_BITMAP:
00102         case CF_DSPBITMAP:
00103             //
00104             // Imediately following the dde data header is a bitmap handle.
00105             //
00106             UserAssert(pi->cbDirect >= sizeof(DDE_DATA));
00107             pi->hIndirect = (HANDLE)pDdeData->Data;
00108             if (pi->hIndirect == 0) {
00109                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:GdiConvertBitmap failed");
00110                 return(FAILNOFREE_POST);
00111             }
00112             // pi->cbIndirect = 0; // zero init.
00113             // pi->pIndirect = NULL; // zero init.
00114             pi->flags |= XS_BITMAP;
00115             break;
00116 
00117         case CF_DIB:
00118             //
00119             // Imediately following the dde data header is a global data handle
00120             // to the DIB bits.
00121             //
00122             UserAssert(pi->cbDirect >= sizeof(DDE_DATA));
00123             pi->flags |= XS_DIB;
00124             pi->hIndirect = (HANDLE)pDdeData->Data;
00125             USERGLOBALLOCK(pi->hIndirect, pi->pIndirect);
00126             if (pi->pIndirect == NULL) {
00127                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:CF_DIB GlobalLock failed.");
00128                 return (FAILNOFREE_POST);
00129             }
00130             pi->cbIndirect = (UINT)UserGlobalSize(pi->hIndirect);
00131             break;
00132 
00133         case CF_PALETTE:
00134             UserAssert(pi->cbDirect >= sizeof(DDE_DATA));
00135             pi->hIndirect = (HANDLE) pDdeData->Data;
00136             if (pi->hIndirect == 0) {
00137                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:GdiConvertPalette failed.");
00138                 return(FAILNOFREE_POST);
00139             }
00140             // pi->cbIndirect = 0; // zero init.
00141             // pi->pIndirect = NULL; // zero init.
00142             pi->flags |= XS_PALETTE;
00143             break;
00144 
00145         case CF_DSPMETAFILEPICT:
00146         case CF_METAFILEPICT:
00147             //
00148             // This format holds a global data handle which contains
00149             // a METAFILEPICT structure that in turn contains
00150             // a GDI metafile.
00151             //
00152             UserAssert(pi->cbDirect >= sizeof(DDE_DATA));
00153             pi->hIndirect = GdiConvertMetaFilePict((HANDLE)pDdeData->Data);
00154             if (pi->hIndirect == 0) {
00155                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:GdiConvertMetaFilePict failed");
00156                 return(FAILNOFREE_POST);
00157             }
00158             // pi->cbIndirect = 0; // zero init.
00159             // pi->pIndirect = NULL; // zero init.
00160             pi->flags |= XS_METAFILEPICT;
00161             break;
00162 
00163         case CF_ENHMETAFILE:
00164         case CF_DSPENHMETAFILE:
00165             UserAssert(pi->cbDirect >= sizeof(DDE_DATA));
00166             pi->hIndirect = GdiConvertEnhMetaFile((HENHMETAFILE)pDdeData->Data);
00167             if (pi->hIndirect == 0) {
00168                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEIn1:GdiConvertEnhMetaFile failed");
00169                 return(FAILNOFREE_POST);
00170             }
00171             // pi->cbIndirect = 0; // zero init.
00172             // pi->pIndirect = NULL; // zero init.
00173             pi->flags |= XS_ENHMETAFILE;
00174             break;
00175         }
00176     }
00177 
00178     return (DO_POST);
00179 }

VOID _ClientCopyDDEIn2 (  PINTDDEINFO  pi  ) 
 

Definition at line 185 of file client/ddetrack.c.

References tagINTDDEINFO::cbDirect, tagINTDDEINFO::cbIndirect, tagINTDDEINFO::flags, tagINTDDEINFO::hDirect, tagINTDDEINFO::hIndirect, USERGLOBALUNLOCK, VOID(), WOWGLOBALFREE, and XS_FREESRC. 

00187 {
00188     if (pi->cbDirect) {
00189         USERGLOBALUNLOCK(pi->hDirect);
00190         if (pi->flags & XS_FREESRC) {
00191             WOWGLOBALFREE(pi->hDirect);
00192         }
00193     }
00194 
00195     if (pi->cbIndirect) {
00196         USERGLOBALUNLOCK(pi->hIndirect);
00197         if (pi->flags & XS_FREESRC) {
00198             WOWGLOBALFREE(pi->hIndirect);
00199         }
00200     }
00201 }

HANDLE _ClientCopyDDEOut1 (  PINTDDEINFO  pi  ) 
 

Definition at line 305 of file client/ddetrack.c.

References tagINTDDEINFO::cbDirect, tagINTDDEINFO::cbIndirect, tagINTDDEINFO::DdePack, tagINTDDEINFO::flags, tagINTDDEINFO::hDirect, tagINTDDEINFO::hIndirect, NULL, tagINTDDEINFO::pDirect, tagINTDDEINFO::pIndirect, tagDDEPACK::uiHi, tagDDEPACK::uiLo, UserGlobalAlloc, UserGlobalFree, USERGLOBALLOCK, USERGLOBALUNLOCK, XS_HIHANDLE, XS_LOHANDLE, and XS_PACKED. 

00307 {
00308     HANDLE hDdePack = NULL;
00309     PDDEPACK pDdePack = NULL;
00310 
00311     if (pi->flags & XS_PACKED) {
00312         /*
00313          * make a wrapper for the data
00314          */
00315         hDdePack = UserGlobalAlloc(GMEM_DDESHARE | GMEM_FIXED,
00316                 sizeof(DDEPACK));
00317         pDdePack = (PDDEPACK)hDdePack;
00318         if (pDdePack == NULL) {
00319             RIPMSG0(RIP_WARNING, "_ClientCopyDDEOut1:Couldn't allocate DDEPACK");
00320             return (NULL);
00321         }
00322         *pDdePack = pi->DdePack;
00323     }
00324 
00325     if (pi->cbDirect) {
00326         pi->hDirect = UserGlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pi->cbDirect);
00327         if (pi->hDirect == NULL) {
00328             RIPMSG0(RIP_WARNING, "_ClientCopyDDEOut1:Couldn't allocate hDirect");
00329             if (hDdePack) {
00330                 UserGlobalFree(hDdePack);
00331             }
00332             return (NULL);
00333         }
00334 
00335         USERGLOBALLOCK(pi->hDirect, pi->pDirect);
00336         UserAssert(pi->pDirect);
00337 
00338         // fixup packed data reference to direct data
00339 
00340         if (pDdePack != NULL) {
00341             if (pi->flags & XS_LOHANDLE) {
00342                 pDdePack->uiLo = HandleToUlong(pi->hDirect);
00343                 UserAssert((ULONG_PTR)pDdePack->uiLo == (ULONG_PTR)pi->hDirect);
00344             } else if (pi->flags & XS_HIHANDLE) {
00345                 pDdePack->uiHi = HandleToUlong(pi->hDirect);
00346                 UserAssert((ULONG_PTR)pDdePack->uiHi == (ULONG_PTR)pi->hDirect);
00347             }
00348         }
00349 
00350         if (pi->cbIndirect) {
00351             pi->hIndirect = UserGlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,
00352                     pi->cbIndirect);
00353             if (pi->hIndirect == NULL) {
00354                 RIPMSG0(RIP_WARNING, "_ClientCopyDDEOut1:Couldn't allocate hIndirect");
00355                 USERGLOBALUNLOCK(pi->hDirect);
00356                 UserGlobalFree(pi->hDirect);
00357                 if (hDdePack) {
00358                     UserGlobalFree(hDdePack);
00359                 }
00360                 return (NULL);
00361             }
00362             USERGLOBALLOCK(pi->hIndirect, pi->pIndirect);
00363             UserAssert(pi->pIndirect);
00364         }
00365     }
00366 
00367     if (hDdePack) {
00368         return (hDdePack);
00369     } else {
00370         return (pi->hDirect);
00371     }
00372 }

BOOL _ClientCopyDDEOut2 (  PINTDDEINFO  pi  ) 
 

Definition at line 379 of file client/ddetrack.c.

References BOOL, tagDDE_DATA::Data, FALSE, FixupDdeExecuteIfNecessary(), tagINTDDEINFO::flags, tagINTDDEINFO::hDirect, tagINTDDEINFO::hIndirect, tagINTDDEINFO::pDirect, TRUE, USERGLOBALUNLOCK, tagDDE_DATA::wFmt, XS_EXECUTE, and XS_UNICODE. 

00381 {
00382     BOOL fSuccess = TRUE;
00383     /*
00384      * done with copies - now fixup indirect references
00385      */
00386     if (pi->hIndirect) {
00387         PDDE_DATA pDdeData = (PDDE_DATA)pi->pDirect;
00388 
00389         switch (pDdeData->wFmt) {
00390         case CF_BITMAP:
00391         case CF_DSPBITMAP:
00392         case CF_PALETTE:
00393             pDdeData->Data = (ULONG_PTR)pi->hIndirect;
00394             fSuccess = (BOOL)pDdeData->Data;
00395             break;
00396 
00397         case CF_METAFILEPICT:
00398         case CF_DSPMETAFILEPICT:
00399             pDdeData->Data = (ULONG_PTR)GdiCreateLocalMetaFilePict(pi->hIndirect);
00400             fSuccess = (BOOL)pDdeData->Data;
00401             break;
00402 
00403         case CF_DIB:
00404             pDdeData->Data = (ULONG_PTR)pi->hIndirect;
00405             fSuccess = (BOOL)pDdeData->Data;
00406             USERGLOBALUNLOCK(pi->hIndirect);
00407             break;
00408 
00409         case CF_ENHMETAFILE:
00410         case CF_DSPENHMETAFILE:
00411             pDdeData->Data = (ULONG_PTR)GdiCreateLocalEnhMetaFile(pi->hIndirect);
00412             fSuccess = (BOOL)pDdeData->Data;
00413             break;
00414 
00415         default:
00416             RIPMSG0(RIP_WARNING, "_ClientCopyDDEOut2:Unknown format w/indirect data.");
00417             fSuccess = FALSE;
00418             USERGLOBALUNLOCK(pi->hIndirect);
00419         }
00420     }
00421 
00422     UserAssert(pi->hDirect); // if its null, we didn't need to call this function.
00423     USERGLOBALUNLOCK(pi->hDirect);
00424     if (pi->flags & XS_EXECUTE) {
00425         /*
00426          * Its possible that in RAW DDE cases where the app allocated the
00427          * execute data as non-moveable, we have a different hDirect
00428          * than we started with.  This needs to be noted and passed
00429          * back to the server. (Very RARE case)
00430          */
00431         FixupDdeExecuteIfNecessary(&pi->hDirect,
00432                 pi->flags & XS_UNICODE);
00433     }
00434     return fSuccess;
00435 }

BOOL _ClientFreeDDEHandle (  HANDLE  hDDE,
DWORD  flags
) 
 

Definition at line 456 of file client/ddetrack.c.

References BOOL, FALSE, FreeDDEData(), IS_PTR, NULL, TRUE, tagDDEPACK::uiHi, tagDDEPACK::uiLo, WOWGLOBALFREE, XS_DATA, XS_DUMPMSG, XS_EXECUTE, XS_LOHANDLE, and XS_PACKED. 

00459 {
00460     PDDEPACK pDdePack;
00461     HANDLE hNew;
00462 
00463     if (flags & XS_PACKED) {
00464         pDdePack = (PDDEPACK)hDDE;
00465         if (pDdePack == NULL) {
00466             return (FALSE);
00467         }
00468         if (flags & XS_LOHANDLE) {
00469             hNew = (HANDLE)pDdePack->uiLo;
00470         } else {
00471             hNew = (HANDLE)pDdePack->uiHi;
00472 
00473         }
00474         WOWGLOBALFREE(hDDE);
00475         hDDE = hNew;
00476 
00477     }
00478 
00479    /*
00480     * Do a range check and call GlobalFlags to validate, just to prevent heap checking
00481     * from complaining during the GlobalSize call.
00482     * Is this leaking atoms??
00483     */
00484     if ((hDDE <= (HANDLE)0xFFFF)
00485         || (GlobalFlags(hDDE) == GMEM_INVALID_HANDLE)
00486         || !GlobalSize(hDDE)) {
00487             /*
00488              * There may be cases where apps improperly freed stuff
00489              * when they shouldn't have so make sure this handle
00490              * is valid by the time it gets here.
00491              *
00492              * See SvSpontAdvise; it posts a message with an atom in uiHi. Then from _PostMessage
00493              *  in the kernel side, we might end up here. So it's not only for apps...
00494              */
00495             return(FALSE);
00496     }
00497 
00498     if (flags & XS_DUMPMSG) {
00499         if (flags & XS_PACKED) {
00500             if (!IS_PTR(hNew)) {
00501                 GlobalDeleteAtom(LOWORD((ULONG_PTR)hNew));
00502                 if (!(flags & XS_DATA)) {
00503                     return(TRUE);     // ACK
00504                 }
00505             }
00506         } else {
00507             if (!(flags & XS_EXECUTE)) {
00508                 GlobalDeleteAtom(LOWORD((ULONG_PTR)hDDE));   // REQUEST, UNADVISE
00509                 return(TRUE);
00510             }
00511         }
00512     }
00513     if (flags & XS_DATA) {
00514         // POKE, DATA
00515 #if DBG
00516         DDEHandleLastFreed = hDDE;
00517 #endif
00518         FreeDDEData(hDDE,
00519                 (flags & XS_DUMPMSG) ? FALSE : TRUE,    // fIgnorefRelease
00520                 (flags & XS_DUMPMSG) ? TRUE : FALSE);    // fDestroyTruelyGlobalObjects
00521     } else {
00522         // ADVISE, EXECUTE
00523 #if DBG
00524         DDEHandleLastFreed = hDDE;
00525 #endif
00526         WOWGLOBALFREE(hDDE);   // covers ADVISE case (fmt but no data)
00527     }
00528     return (TRUE);
00529 }

DWORD _ClientGetDDEFlags (  HANDLE  hDDE,
DWORD  flags
) 
 

Definition at line 532 of file client/ddetrack.c.

References DWORD, NULL, tagDDEPACK::uiLo, USERGLOBALLOCK, USERGLOBALUNLOCK, and XS_DATA. 

00535 {
00536     PDDEPACK pDdePack;
00537     PWORD pw;
00538     HANDLE hData;
00539     DWORD retval = 0;
00540 
00541     pDdePack = (PDDEPACK)hDDE;
00542     if (pDdePack == NULL) {
00543         return (0);
00544     }
00545 
00546     if (flags & XS_DATA) {
00547         if (pDdePack->uiLo) {
00548             hData = (HANDLE)pDdePack->uiLo;
00549             USERGLOBALLOCK(hData, pw);
00550             if (pw != NULL) {
00551                 retval = (DWORD)*pw; // first word is hData is wStatus
00552                 USERGLOBALUNLOCK(hData);
00553             }
00554         }
00555     } else {
00556         retval = (DWORD)pDdePack->uiLo;
00557     }
00558 
00559     return (retval);
00560 }

BOOL FixupDdeExecuteIfNecessary (  HGLOBAL *  phCommands,
BOOL  fNeedUnicode
) 
 

Definition at line 208 of file client/ddetrack.c.

References BOOL, FALSE, L, LPVOID, min, NT_SUCCESS, NULL, RtlIsTextUnicode(), RtlMultiByteToUnicodeN(), RtlUnicodeToMultiByteN(), strlen(), UINT, USERGLOBALLOCK, USERGLOBALUNLOCK, UserLocalAlloc, and UserLocalFree.

Referenced by _ClientCopyDDEOut2(). 

00211 {
00212     UINT cbLen;
00213     UINT cbSrc = (UINT)GlobalSize(*phCommands);
00214     LPVOID pstr;
00215     HGLOBAL hTemp;
00216     BOOL fHandleValueChanged = FALSE;
00217 
00218     USERGLOBALLOCK(*phCommands, pstr);
00219 
00220     if (cbSrc && pstr != NULL) {
00221         BOOL fIsUnicodeText;
00222 #ifdef ISTEXTUNICODE_WORKS
00223         int flags;
00224 
00225         flags = (IS_TEXT_UNICODE_UNICODE_MASK |
00226                 IS_TEXT_UNICODE_REVERSE_MASK |
00227                 (IS_TEXT_UNICODE_NOT_UNICODE_MASK &
00228                 (~IS_TEXT_UNICODE_ILLEGAL_CHARS)) |
00229                 IS_TEXT_UNICODE_NOT_ASCII_MASK);
00230         fIsUnicodeText = RtlIsTextUnicode(pstr, cbSrc - 2, &flags);
00231 #else
00232         fIsUnicodeText = ((cbSrc >= sizeof(WCHAR)) && (((LPSTR)pstr)[1] == '\0'));
00233 #endif
00234         if (!fIsUnicodeText && fNeedUnicode) {
00235             LPWSTR pwsz;
00236             /*
00237              * Contents needs to be UNICODE.
00238              */
00239             cbLen = strlen(pstr) + 1;
00240             cbSrc = min(cbSrc, cbLen);
00241             pwsz = UserLocalAlloc(HEAP_ZERO_MEMORY, cbSrc * sizeof(WCHAR));
00242             if (pwsz != NULL) {
00243                 if (NT_SUCCESS(RtlMultiByteToUnicodeN(
00244                         pwsz,
00245                         cbSrc * sizeof(WCHAR),
00246                         NULL,
00247                         (PCHAR)pstr,
00248                         cbSrc))) {
00249                     USERGLOBALUNLOCK(*phCommands);
00250                     if ((hTemp = GlobalReAlloc(
00251                             *phCommands,
00252                             cbSrc * sizeof(WCHAR),
00253                             GMEM_MOVEABLE)) != NULL) {
00254                         fHandleValueChanged = (hTemp != *phCommands);
00255                         *phCommands = hTemp;
00256                         USERGLOBALLOCK(*phCommands, pstr);
00257                         pwsz[cbSrc - 1] = L'\0';
00258                         wcscpy(pstr, pwsz);
00259                     }
00260                 }
00261                 UserLocalFree(pwsz);
00262             }
00263         } else if (fIsUnicodeText && !fNeedUnicode) {
00264             LPSTR psz;
00265             /*
00266              * Contents needs to be ANSI.
00267              */
00268             cbLen = (wcslen(pstr) + 1) * sizeof(WCHAR);
00269             cbSrc = min(cbSrc, cbLen);
00270             psz = UserLocalAlloc(HEAP_ZERO_MEMORY, cbSrc);
00271             if (psz != NULL) {
00272                 if (NT_SUCCESS(RtlUnicodeToMultiByteN(
00273                         psz,
00274                         cbSrc,
00275                         NULL,
00276                         (PWSTR)pstr,
00277                         cbSrc))) {
00278                     USERGLOBALUNLOCK(*phCommands);
00279                     if ((hTemp = GlobalReAlloc(
00280                             *phCommands,
00281                             cbSrc / sizeof(WCHAR),
00282                             GMEM_MOVEABLE)) != NULL) {
00283                         fHandleValueChanged = (hTemp != *phCommands);
00284                         *phCommands = hTemp;
00285                         USERGLOBALLOCK(*phCommands, pstr);
00286                         UserAssert(pstr);
00287                         psz[cbSrc - 1] = '\0';
00288                         strcpy(pstr, psz);
00289                     }
00290                 }
00291                 UserLocalFree(psz);
00292             }
00293         }
00294         USERGLOBALUNLOCK(*phCommands);
00295     }
00296     return(fHandleValueChanged);
00297 }

DWORD GetDebugHookLParamSize (  IN WPARAM  wParam,
IN PDEBUGHOOKINFO  pdebughookstruct
) 
 

Definition at line 4422 of file ntcb.h.

References DWORD. 

04425 {
04426     DWORD cbDbgLParam = 0;
04427 
04428     switch(wParam) {
04429     case WH_MSGFILTER:
04430     case WH_SYSMSGFILTER:
04431     case WH_GETMESSAGE:
04432         cbDbgLParam = sizeof(MSG);
04433         break;
04434 
04435     case WH_CALLWNDPROC:
04436         cbDbgLParam = sizeof(CWPSTRUCT);
04437         break;
04438 
04439     case WH_CALLWNDPROCRET:
04440         cbDbgLParam = sizeof(CWPRETSTRUCT);
04441         break;
04442 
04443     case WH_MOUSE:
04444         cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX);
04445         break;
04446 
04447     case WH_JOURNALRECORD:
04448     case WH_JOURNALPLAYBACK:
04449         cbDbgLParam = sizeof(EVENTMSG);
04450         break;
04451 
04452     case WH_CBT:
04453         switch (pdebughookstruct->code) {
04454         case HCBT_ACTIVATE:
04455             cbDbgLParam = sizeof(CBTACTIVATESTRUCT);
04456             break;
04457         case HCBT_CLICKSKIPPED:
04458             cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX);
04459             break;
04460         case HCBT_CREATEWND:
04461             cbDbgLParam = sizeof(CBT_CREATEWND);
04462             break;
04463         case HCBT_MOVESIZE:
04464             cbDbgLParam = sizeof(RECT);
04465             break;
04466         }
04467         break;
04468 
04469     case WH_SHELL:
04470         if (pdebughookstruct->code == HSHELL_GETMINRECT) {
04471             cbDbgLParam = sizeof(RECT);
04472         }
04473         break;
04474     }
04475     return cbDbgLParam;
04476 }

BOOL xxxClientCopyDDEIn2 (  PINTDDEINFO  pi  ) 
 

Generated on Sat May 15 19:44:52 2004 for test by doxygen 1.3.7