/************************************************************************* ** ** OLE 2 Standard Utilities ** ** olestd.c ** ** This file contains utilities that are useful for dealing with ** target devices. ** ** (c) Copyright Microsoft Corp. 1992 All Rights Reserved ** *************************************************************************/ #define STRICT 1 #include "ole2ui.h" #ifndef WIN32 #include #endif /* * OleStdCreateDC() * * Purpose: * * Parameters: * * Return Value: * SCODE - S_OK if successful */ STDAPI_(HDC) OleStdCreateDC(DVTARGETDEVICE FAR* ptd) { HDC hdc=NULL; LPDEVNAMES lpDevNames; LPDEVMODE lpDevMode; LPTSTR lpszDriverName; LPTSTR lpszDeviceName; LPTSTR lpszPortName; if (ptd == NULL) { hdc = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL); goto errReturn; } lpDevNames = (LPDEVNAMES) ptd; // offset for size field if (ptd->tdExtDevmodeOffset == 0) { lpDevMode = NULL; }else{ lpDevMode = (LPDEVMODE) ((LPSTR)ptd + ptd->tdExtDevmodeOffset); } lpszDriverName = (LPTSTR) lpDevNames + ptd->tdDriverNameOffset; lpszDeviceName = (LPTSTR) lpDevNames + ptd->tdDeviceNameOffset; lpszPortName = (LPTSTR) lpDevNames + ptd->tdPortNameOffset; hdc = CreateDC(lpszDriverName, lpszDeviceName, lpszPortName, lpDevMode); errReturn: return hdc; } /* * OleStdCreateIC() * * Purpose: Same as OleStdCreateDC, except that information context is * created, rather than a whole device context. (CreateIC is * used rather than CreateDC). * OleStdDeleteDC is still used to delete the information context. * * Parameters: * * Return Value: * SCODE - S_OK if successful */ STDAPI_(HDC) OleStdCreateIC(DVTARGETDEVICE FAR* ptd) { HDC hdcIC=NULL; LPDEVNAMES lpDevNames; LPDEVMODE lpDevMode; LPTSTR lpszDriverName; LPTSTR lpszDeviceName; LPTSTR lpszPortName; if (ptd == NULL) { hdcIC = CreateIC(TEXT("DISPLAY"), NULL, NULL, NULL); goto errReturn; } lpDevNames = (LPDEVNAMES) ptd; // offset for size field lpDevMode = (LPDEVMODE) ((LPTSTR)ptd + ptd->tdExtDevmodeOffset); lpszDriverName = (LPTSTR) lpDevNames + ptd->tdDriverNameOffset; lpszDeviceName = (LPTSTR) lpDevNames + ptd->tdDeviceNameOffset; lpszPortName = (LPTSTR) lpDevNames + ptd->tdPortNameOffset; hdcIC = CreateIC(lpszDriverName, lpszDeviceName, lpszPortName, lpDevMode); errReturn: return hdcIC; } #ifdef NEVER // This code is wrong /* * OleStdCreateTargetDevice() * * Purpose: * * Parameters: * * Return Value: * SCODE - S_OK if successful */ STDAPI_(DVTARGETDEVICE FAR*) OleStdCreateTargetDevice(LPPRINTDLG lpPrintDlg) { DVTARGETDEVICE FAR* ptd=NULL; LPDEVNAMES lpDevNames, pDN; LPDEVMODE lpDevMode, pDM; UINT nMaxOffset; LPTSTR pszName; DWORD dwDevNamesSize, dwDevModeSize, dwPtdSize; if ((pDN = (LPDEVNAMES)GlobalLock(lpPrintDlg->hDevNames)) == NULL) { goto errReturn; } if ((pDM = (LPDEVMODE)GlobalLock(lpPrintDlg->hDevMode)) == NULL) { goto errReturn; } nMaxOffset = (pDN->wDriverOffset > pDN->wDeviceOffset) ? pDN->wDriverOffset : pDN->wDeviceOffset ; nMaxOffset = (pDN->wOutputOffset > nMaxOffset) ? pDN->wOutputOffset : nMaxOffset ; pszName = (LPTSTR)pDN + nMaxOffset; dwDevNamesSize = (DWORD)((nMaxOffset+lstrlen(pszName) + 1/* NULL term */)*sizeof(TCHAR)); dwDevModeSize = (DWORD) (pDM->dmSize + pDM->dmDriverExtra); dwPtdSize = sizeof(DWORD) + dwDevNamesSize + dwDevModeSize; if ((ptd = (DVTARGETDEVICE FAR*)OleStdMalloc(dwPtdSize)) != NULL) { // copy in the info ptd->tdSize = (UINT)dwPtdSize; lpDevNames = (LPDEVNAMES) &ptd->tdDriverNameOffset; _fmemcpy(lpDevNames, pDN, (size_t)dwDevNamesSize); lpDevMode=(LPDEVMODE)((LPTSTR)&ptd->tdDriverNameOffset+dwDevNamesSize); _fmemcpy(lpDevMode, pDM, (size_t)dwDevModeSize); ptd->tdDriverNameOffset += 4 ; ptd->tdDeviceNameOffset += 4 ; ptd->tdPortNameOffset += 4 ; ptd->tdExtDevmodeOffset = (UINT)dwDevNamesSize + 4 ; } errReturn: GlobalUnlock(lpPrintDlg->hDevNames); GlobalUnlock(lpPrintDlg->hDevMode); return ptd; } #endif // NEVER /* * OleStdDeleteTargetDevice() * * Purpose: * * Parameters: * * Return Value: * SCODE - S_OK if successful */ STDAPI_(BOOL) OleStdDeleteTargetDevice(DVTARGETDEVICE FAR* ptd) { BOOL res=TRUE; if (ptd != NULL) { OleStdFree(ptd); } return res; } /* * OleStdCopyTargetDevice() * * Purpose: * duplicate a TARGETDEVICE struct. this function allocates memory for * the copy. the caller MUST free the allocated copy when done with it * using the standard allocator returned from CoGetMalloc. * (OleStdFree can be used to free the copy). * * Parameters: * ptdSrc pointer to source TARGETDEVICE * * Return Value: * pointer to allocated copy of ptdSrc * if ptdSrc==NULL then retuns NULL is returned. * if ptdSrc!=NULL and memory allocation fails, then NULL is returned */ STDAPI_(DVTARGETDEVICE FAR*) OleStdCopyTargetDevice(DVTARGETDEVICE FAR* ptdSrc) { DVTARGETDEVICE FAR* ptdDest = NULL; if (ptdSrc == NULL) { return NULL; } if ((ptdDest = (DVTARGETDEVICE FAR*)OleStdMalloc(ptdSrc->tdSize)) != NULL) { _fmemcpy(ptdDest, ptdSrc, (size_t)ptdSrc->tdSize); } return ptdDest; } /* * OleStdCopyFormatEtc() * * Purpose: * Copies the contents of a FORMATETC structure. this function takes * special care to copy correctly copying the pointer to the TARGETDEVICE * contained within the source FORMATETC structure. * if the source FORMATETC has a non-NULL TARGETDEVICE, then a copy * of the TARGETDEVICE will be allocated for the destination of the * FORMATETC (petcDest). * * OLE2NOTE: the caller MUST free the allocated copy of the TARGETDEVICE * within the destination FORMATETC when done with it * using the standard allocator returned from CoGetMalloc. * (OleStdFree can be used to free the copy). * * Parameters: * petcDest pointer to destination FORMATETC * petcSrc pointer to source FORMATETC * * Return Value: * returns TRUE is copy is successful; retuns FALSE if not successful */ STDAPI_(BOOL) OleStdCopyFormatEtc(LPFORMATETC petcDest, LPFORMATETC petcSrc) { if ((petcDest == NULL) || (petcSrc == NULL)) { return FALSE; } petcDest->cfFormat = petcSrc->cfFormat; petcDest->ptd = OleStdCopyTargetDevice(petcSrc->ptd); petcDest->dwAspect = petcSrc->dwAspect; petcDest->lindex = petcSrc->lindex; petcDest->tymed = petcSrc->tymed; return TRUE; } // returns 0 for exact match, 1 for no match, -1 for partial match (which is // defined to mean the left is a subset of the right: fewer aspects, null target // device, fewer medium). STDAPI_(int) OleStdCompareFormatEtc(FORMATETC FAR* pFetcLeft, FORMATETC FAR* pFetcRight) { BOOL bExact = TRUE; if (pFetcLeft->cfFormat != pFetcRight->cfFormat) return 1; else if (!OleStdCompareTargetDevice (pFetcLeft->ptd, pFetcRight->ptd)) return 1; if (pFetcLeft->dwAspect == pFetcRight->dwAspect) // same aspects; equal ; else if ((pFetcLeft->dwAspect & ~pFetcRight->dwAspect) != 0) // left not subset of aspects of right; not equal return 1; else // left subset of right bExact = FALSE; if (pFetcLeft->tymed == pFetcRight->tymed) // same medium flags; equal ; else if ((pFetcLeft->tymed & ~pFetcRight->tymed) != 0) // left not subset of medium flags of right; not equal return 1; else // left subset of right bExact = FALSE; return bExact ? 0 : -1; } STDAPI_(BOOL) OleStdCompareTargetDevice (DVTARGETDEVICE FAR* ptdLeft, DVTARGETDEVICE FAR* ptdRight) { if (ptdLeft == ptdRight) // same address of td; must be same (handles NULL case) return TRUE; else if ((ptdRight == NULL) || (ptdLeft == NULL)) return FALSE; else if (ptdLeft->tdSize != ptdRight->tdSize) // different sizes, not equal return FALSE; #ifdef WIN32 else if (memcmp(ptdLeft, ptdRight, ptdLeft->tdSize) != 0) #else else if (_fmemcmp(ptdLeft, ptdRight, (int)ptdLeft->tdSize) != 0) #endif // not same target device, not equal return FALSE; return TRUE; }