/* * DRAWICON.C * * Functions to handle creation of metafiles with icons and labels * as well as functions to draw such metafiles with or without the label. * * The metafile is created with a comment that marks the records containing * the label code. Drawing the metafile enumerates the records, draws * all records up to that point, then decides to either skip the label * or draw it. * * Copyright (c)1992 Microsoft Corporation, All Right Reserved */ #define STRICT 1 #include "ole2ui.h" #include "common.h" #include "utility.h" #include "geticon.h" /* * Strings for metafile comments. KEEP THESE IN SYNC WITH THE * STRINGS IN GETICON.C. */ static TCHAR szIconOnly[]=TEXT("IconOnly"); //Where to stop to exclude label. /* * OleUIMetafilePictIconFree * * Purpose: * Deletes the metafile contained in a METAFILEPICT structure and * frees the memory for the structure itself. * * Parameters: * hMetaPict HGLOBAL metafilepict structure created in * OleUIMetafilePictFromIconAndLabel * * Return Value: * None */ STDAPI_(void) OleUIMetafilePictIconFree(HGLOBAL hMetaPict) { LPMETAFILEPICT pMF; if (NULL==hMetaPict) return; pMF=(LPMETAFILEPICT)GlobalLock(hMetaPict); if (NULL!=pMF) { if (NULL!=pMF->hMF) DeleteMetaFile(pMF->hMF); } GlobalUnlock(hMetaPict); GlobalFree(hMetaPict); return; } /* * OleUIMetafilePictIconDraw * * Purpose: * Draws the metafile from OleUIMetafilePictFromIconAndLabel, either with * the label or without. * * Parameters: * hDC HDC on which to draw. * pRect LPRECT in which to draw the metafile. * hMetaPict HGLOBAL to the METAFILEPICT from * OleUIMetafilePictFromIconAndLabel * fIconOnly BOOL specifying to draw the label or not. * * Return Value: * BOOL TRUE if the function is successful, FALSE if the * given metafilepict is invalid. */ STDAPI_(BOOL) OleUIMetafilePictIconDraw(HDC hDC, LPRECT pRect, HGLOBAL hMetaPict , BOOL fIconOnly) { LPMETAFILEPICT pMF; DRAWINFO di; int cx, cy; SIZE size; POINT point; if (NULL==hMetaPict) return FALSE; pMF=GlobalLock(hMetaPict); if (NULL==pMF) return FALSE; di.Rect = *pRect; di.fIconOnly = fIconOnly; //Transform to back to pixels cx=XformWidthInHimetricToPixels(hDC, pMF->xExt); cy=XformHeightInHimetricToPixels(hDC, pMF->yExt); SaveDC(hDC); SetMapMode(hDC, pMF->mm); SetViewportOrgEx(hDC, (pRect->right - cx) / 2, 0, &point); SetViewportExtEx(hDC, min ((pRect->right - cx) / 2 + cx, cx), cy, &size); if (fIconOnly) { // Since we've used the __export keyword on the // EnumMetafileIconDraw proc, we do not need to use // MakeProcInstance EnumMetaFile(hDC, pMF->hMF, (MFENUMPROC)EnumMetafileIconDraw , (LPARAM)(LPDRAWINFO)&di); } else PlayMetaFile(hDC, pMF->hMF); RestoreDC(hDC, -1); GlobalUnlock(hMetaPict); return TRUE; } /* * EnumMetafileIconDraw * * Purpose: * EnumMetaFile callback function that draws either the icon only or * the icon and label depending on given flags. * * Parameters: * hDC HDC into which the metafile should be played. * phTable HANDLETABLE FAR * providing handles selected into the DC. * pMFR METARECORD FAR * giving the enumerated record. * lParam LPARAM flags passed in EnumMetaFile. * * Return Value: * int 0 to stop enumeration, 1 to continue. */ int CALLBACK EXPORT EnumMetafileIconDraw(HDC hDC, HANDLETABLE FAR *phTable , METARECORD FAR *pMFR, int cObj, LPARAM lParam) { LPDRAWINFO lpdi = (LPDRAWINFO)lParam; /* * We play everything blindly except for DIBBITBLT (or DIBSTRETCHBLT) * and ESCAPE with MFCOMMENT. For the BitBlts we change the x,y to * draw at (0,0) instead of wherever it was written to draw. The * comment tells us there to stop if we don't want to draw the label. */ //If we're playing icon only, stop enumeration at the comment. if (lpdi->fIconOnly) { if (META_ESCAPE==pMFR->rdFunction && MFCOMMENT==pMFR->rdParm[0]) { if (0==lstrcmpi(szIconOnly, (LPTSTR)&pMFR->rdParm[2])) return 0; } /* * Check for the records in which we want to munge the coordinates. * destX is offset 6 for BitBlt, offset 9 for StretchBlt, either of * which may appear in the metafile. */ if (META_DIBBITBLT==pMFR->rdFunction) pMFR->rdParm[6]=0; if (META_DIBSTRETCHBLT==pMFR->rdFunction) pMFR->rdParm[9] = 0; } PlayMetaFileRecord(hDC, phTable, pMFR, cObj); return 1; } /* * OleUIMetafilePictExtractLabel * * Purpose: * Retrieves the label string from metafile representation of an icon. * * Parameters: * hMetaPict HGLOBAL to the METAFILEPICT containing the metafile. * lpszLabel LPSTR in which to store the label. * cchLabel UINT length of lpszLabel. * lpWrapIndex DWORD index of first character in last line. Can be NULL * if calling function doesn't care about word wrap. * * Return Value: * UINT Number of characters copied. */ STDAPI_(UINT) OleUIMetafilePictExtractLabel(HGLOBAL hMetaPict, LPTSTR lpszLabel , UINT cchLabel, LPDWORD lpWrapIndex) { LPMETAFILEPICT pMF; LABELEXTRACT le; HDC hDC; /* * We extract the label by getting a screen DC and walking the metafile * records until we see the ExtTextOut record we put there. That * record will have the string embedded in it which we then copy out. */ if (NULL==hMetaPict || NULL==lpszLabel || 0==cchLabel) return FALSE; pMF=GlobalLock(hMetaPict); if (NULL==pMF) return FALSE; le.lpsz=lpszLabel; le.u.cch=cchLabel; le.Index=0; le.fFoundIconOnly=FALSE; le.fFoundSource=FALSE; //Unused for this function. le.fFoundIndex=FALSE; //Unused for this function. le.PrevIndex = 0; //Use a screen DC so we have something valid to pass in. hDC=GetDC(NULL); // Since we've used the EXPORT keyword on the // EnumMetafileExtractLabel proc, we do not need to use // MakeProcInstance EnumMetaFile(hDC, pMF->hMF, (MFENUMPROC)EnumMetafileExtractLabel, (LONG)(LPLABELEXTRACT)&le); ReleaseDC(NULL, hDC); GlobalUnlock(hMetaPict); //Tell where we wrapped (if calling function cares) if (NULL != lpWrapIndex) *lpWrapIndex = le.PrevIndex; //Return amount of text copied return le.u.cch; } /* * EnumMetafileExtractLabel * * Purpose: * EnumMetaFile callback function that walks a metafile looking for * ExtTextOut, then concatenates the text from each one into a buffer * in lParam. * * Parameters: * hDC HDC into which the metafile should be played. * phTable HANDLETABLE FAR * providing handles selected into the DC. * pMFR METARECORD FAR * giving the enumerated record. * pLE LPLABELEXTRACT providing the destination buffer and length. * * Return Value: * int 0 to stop enumeration, 1 to continue. */ int CALLBACK EXPORT EnumMetafileExtractLabel(HDC hDC, HANDLETABLE FAR *phTable , METARECORD FAR *pMFR, int cObj, LPLABELEXTRACT pLE) { /* * We don't allow anything to happen until we see "IconOnly" * in an MFCOMMENT that is used to enable everything else. */ if (!pLE->fFoundIconOnly) { if (META_ESCAPE==pMFR->rdFunction && MFCOMMENT==pMFR->rdParm[0]) { if (0==lstrcmpi(szIconOnly, (LPTSTR)&pMFR->rdParm[2])) pLE->fFoundIconOnly=TRUE; } return 1; } //Enumerate all records looking for META_EXTTEXTOUT - there can be more //than one. if (META_EXTTEXTOUT==pMFR->rdFunction) { UINT cchMax; LPTSTR lpszTemp; /* * If ExtTextOut has NULL fuOptions, then the rectangle is omitted * from the record, and the string starts at rdParm[4]. If * fuOptions is non-NULL, then the string starts at rdParm[8] * (since the rectange takes up four WORDs in the array). In * both cases, the string continues for (rdParm[2]+1) >> 1 * words. We just cast a pointer to rdParm[8] to an LPSTR and * lstrcpyn into the buffer we were given. * * Note that we use element 8 in rdParm instead of 4 because we * passed ETO_CLIPPED in for the options on ExtTextOut--docs say * [4] which is rect doesn't exist if we passed zero there. * */ cchMax=min(pLE->u.cch - pLE->Index, (UINT)pMFR->rdParm[2]); lpszTemp = pLE->lpsz + pLE->Index; lstrcpyn(lpszTemp, (LPTSTR)&(pMFR->rdParm[8]), cchMax + 1); // lstrcpyn(lpszTemp, (LPTSTR)&(pMFR->rdParm[4]), cchMax + 1); pLE->PrevIndex = pLE->Index; pLE->Index += cchMax; } return 1; } /* * OleUIMetafilePictExtractIcon * * Purpose: * Retrieves the icon from metafile into which DrawIcon was done before. * * Parameters: * hMetaPict HGLOBAL to the METAFILEPICT containing the metafile. * * Return Value: * HICON Icon recreated from the data in the metafile. */ STDAPI_(HICON) OleUIMetafilePictExtractIcon(HGLOBAL hMetaPict) { LPMETAFILEPICT pMF; HDC hDC; ICONEXTRACT ie; /* * We extract the label by getting a screen DC and walking the metafile * records until we see the ExtTextOut record we put there. That * record will have the string embedded in it which we then copy out. */ if (NULL==hMetaPict) return NULL; pMF=GlobalLock(hMetaPict); if (NULL==pMF) return FALSE; //Use a screen DC so we have something valid to pass in. hDC=GetDC(NULL); ie.fAND=TRUE; // We get information back in the ICONEXTRACT structure. // (Since we've used the EXPORT keyword on the // EnumMetafileExtractLabel proc, we do not need to use // MakeProcInstance) EnumMetaFile(hDC, pMF->hMF, (MFENUMPROC)EnumMetafileExtractIcon, (LONG)(LPICONEXTRACT)&ie); ReleaseDC(NULL, hDC); GlobalUnlock(hMetaPict); return ie.hIcon; } /* * EnumMetafileExtractIcon * * Purpose: * EnumMetaFile callback function that walks a metafile looking for * StretchBlt (3.1) and BitBlt (3.0) records. We expect to see two * of them, the first being the AND mask and the second being the XOR * data. We * ExtTextOut, then copies the text into a buffer in lParam. * * Parameters: * hDC HDC into which the metafile should be played. * phTable HANDLETABLE FAR * providing handles selected into the DC. * pMFR METARECORD FAR * giving the enumerated record. * pIE LPICONEXTRACT providing the destination buffer and length. * * Return Value: * int 0 to stop enumeration, 1 to continue. */ int CALLBACK EXPORT EnumMetafileExtractIcon(HDC hDC, HANDLETABLE FAR *phTable , METARECORD FAR *pMFR, int cObj, LPICONEXTRACT pIE) { LPBITMAPINFO lpBI; LPBITMAPINFOHEADER lpBH; LPBYTE lpbSrc; LPBYTE lpbDst; UINT uWidth, uHeight; DWORD cb; HGLOBAL hMem; BITMAP bm; HBITMAP hBmp; int cxIcon, cyIcon; //Continue enumeration if we don't see the records we want. if (META_DIBBITBLT!=pMFR->rdFunction && META_DIBSTRETCHBLT!=pMFR->rdFunction) return 1; /* * Windows 3.0 DrawIcon uses META_DIBBITBLT in whereas 3.1 uses * META_DIBSTRETCHBLT so we have to handle each case separately. */ if (META_DIBBITBLT==pMFR->rdFunction) //Win3.0 { //Get dimensions and the BITMAPINFO struct. uHeight=pMFR->rdParm[1]; uWidth =pMFR->rdParm[2]; lpBI=(LPBITMAPINFO)&(pMFR->rdParm[8]); } if (META_DIBSTRETCHBLT==pMFR->rdFunction) //Win3.1 { //Get dimensions and the BITMAPINFO struct. uHeight=pMFR->rdParm[2]; uWidth =pMFR->rdParm[3]; lpBI=(LPBITMAPINFO)&(pMFR->rdParm[10]); } lpBH=(LPBITMAPINFOHEADER)&(lpBI->bmiHeader); //Pointer to the bits which follows the BITMAPINFO structure. lpbSrc=(LPBYTE)lpBI+sizeof(BITMAPINFOHEADER); //Add the length of the color table (if one exists) if (0!=lpBH->biClrUsed) { // If we have an explicit count of colors used, we // can find the offset to the data directly lpbSrc += (lpBH->biClrUsed*sizeof(RGBQUAD)); } else if (lpBH->biCompression == BI_BITFIELDS) { // 16 or 32 bpp, indicated by BI_BITFIELDS in the compression // field, have 3 DWORD masks for adjusting subsequent // direct-color values, and no palette lpbSrc += 3 * sizeof(DWORD); } else { // In other cases, there is an array of RGBQUAD entries // equal to 2^(biBitCount) where biBitCount is the number // of bits per pixel. The exception is 24 bpp bitmaps, // which have no color table and just use direct RGB values. lpbSrc+= (lpBH->biBitCount == 24) ? 0 : (1 << (lpBH->biBitCount)) * sizeof(RGBQUAD); } /* * All the bits we have in lpbSrc are device-independent, so we * need to change them over to be device-dependent using SetDIBits. * Once we have a bitmap with the device-dependent bits, we can * GetBitmapBits to have buffers with the real data. * * For each pass we have to allocate memory for the bits. We save * the memory for the mask between passes. */ //Use CreateBitmap for ANY monochrome bitmaps if (pIE->fAND || 1==lpBH->biBitCount || lpBH->biBitCount > 8) hBmp=CreateBitmap((UINT)lpBH->biWidth, (UINT)lpBH->biHeight, 1, 1, NULL); else if (lpBH->biBitCount <= 8) hBmp=CreateCompatibleBitmap(hDC, (UINT)lpBH->biWidth, (UINT)lpBH->biHeight); if (!hBmp || !SetDIBits(hDC, hBmp, 0, (UINT)lpBH->biHeight, (LPVOID)lpbSrc, lpBI, DIB_RGB_COLORS)) { if (!pIE->fAND) GlobalFree(pIE->hMemAND); DeleteObject(hBmp); return 0; } //Allocate memory and get the DDBits into it. GetObject(hBmp, sizeof(bm), &bm); cb=bm.bmHeight*bm.bmWidthBytes * bm.bmPlanes; // if (cb % 4 != 0) // dword align // cb += 4 - (cb % 4); hMem=GlobalAlloc(GHND, cb); if (NULL==hMem) { if (NULL!=pIE->hMemAND) GlobalFree(pIE->hMemAND); DeleteObject(hBmp); return 0; } lpbDst=(LPBYTE)GlobalLock(hMem); GetBitmapBits(hBmp, cb, (LPVOID)lpbDst); DeleteObject(hBmp); GlobalUnlock(hMem); /* * If this is the first pass (pIE->fAND==TRUE) then save the memory * of the AND bits for the next pass. */ if (pIE->fAND) { pIE->fAND=FALSE; pIE->hMemAND=hMem; //Continue enumeration looking for the next blt record. return 1; } else { //Get the AND pointer again. lpbSrc=(LPBYTE)GlobalLock(pIE->hMemAND); /* * Create the icon now that we have all the data. lpbDst already * points to the XOR bits. */ cxIcon = GetSystemMetrics(SM_CXICON); cyIcon = GetSystemMetrics(SM_CYICON); pIE->hIcon=CreateIcon(ghInst, uWidth, uHeight, (BYTE)bm.bmPlanes, (BYTE)bm.bmBitsPixel, (LPVOID)lpbSrc, (LPVOID)lpbDst); GlobalUnlock(pIE->hMemAND); GlobalFree(pIE->hMemAND); GlobalFree(hMem); //We're done so we can stop. return 0; } } /* * OleUIMetafilePictExtractIconSource * * Purpose: * Retrieves the filename and index of the icon source from a metafile * created with OleUIMetafilePictFromIconAndLabel. * * Parameters: * hMetaPict HGLOBAL to the METAFILEPICT containing the metafile. * lpszSource LPTSTR in which to store the source filename. This * buffer should be OLEUI_CCHPATHMAX characters. * piIcon UINT FAR * in which to store the icon's index * within lpszSource * * Return Value: * BOOL TRUE if the records were found, FALSE otherwise. */ STDAPI_(BOOL) OleUIMetafilePictExtractIconSource(HGLOBAL hMetaPict , LPTSTR lpszSource, UINT FAR *piIcon) { LPMETAFILEPICT pMF; LABELEXTRACT le; HDC hDC; /* * We will walk the metafile looking for the two comment records * following the IconOnly comment. The flags fFoundIconOnly and * fFoundSource indicate if we have found IconOnly and if we have * found the source comment already. */ if (NULL==hMetaPict || NULL==lpszSource || NULL==piIcon) return FALSE; pMF=GlobalLock(hMetaPict); if (NULL==pMF) return FALSE; le.lpsz=lpszSource; le.fFoundIconOnly=FALSE; le.fFoundSource=FALSE; le.fFoundIndex=FALSE; //Use a screen DC so we have something valid to pass in. hDC=GetDC(NULL); EnumMetaFile(hDC, pMF->hMF, (MFENUMPROC)EnumMetafileExtractIconSource, (LONG)(LPLABELEXTRACT)&le); ReleaseDC(NULL, hDC); GlobalUnlock(hMetaPict); //Copy the icon index to the caller's variable. *piIcon=le.u.iIcon; //Check that we found everything. return (le.fFoundIconOnly && le.fFoundSource && le.fFoundIndex); } /* * EnumMetafileExtractIconSource * * Purpose: * EnumMetaFile callback function that walks a metafile skipping the first * comment record, extracting the source filename from the second, and * the index of the icon in the third. * * Parameters: * hDC HDC into which the metafile should be played. * phTable HANDLETABLE FAR * providing handles selected into the DC. * pMFR METARECORD FAR * giving the enumerated record. * pLE LPLABELEXTRACT providing the destination buffer and * area to store the icon index. * * Return Value: * int 0 to stop enumeration, 1 to continue. */ int CALLBACK EXPORT EnumMetafileExtractIconSource(HDC hDC, HANDLETABLE FAR *phTable , METARECORD FAR *pMFR, int cObj, LPLABELEXTRACT pLE) { LPTSTR psz; /* * We don't allow anything to happen until we see "IconOnly" * in an MFCOMMENT that is used to enable everything else. */ if (!pLE->fFoundIconOnly) { if (META_ESCAPE==pMFR->rdFunction && MFCOMMENT==pMFR->rdParm[0]) { if (0==lstrcmpi(szIconOnly, (LPTSTR)&pMFR->rdParm[2])) pLE->fFoundIconOnly=TRUE; } return 1; } //Now see if we find the source string. if (!pLE->fFoundSource) { if (META_ESCAPE==pMFR->rdFunction && MFCOMMENT==pMFR->rdParm[0]) { LSTRCPYN(pLE->lpsz, (LPTSTR)&pMFR->rdParm[2], OLEUI_CCHPATHMAX); pLE->lpsz[OLEUI_CCHPATHMAX-1] = TEXT('\0'); pLE->fFoundSource=TRUE; } return 1; } //Next comment will be the icon index. if (META_ESCAPE==pMFR->rdFunction && MFCOMMENT==pMFR->rdParm[0]) { /* * This string contains the icon index in string form, * so we need to convert back to a UINT. After we see this * we can stop the enumeration. The comment will have * a null terminator because we made sure to save it. */ psz=(LPTSTR)&pMFR->rdParm[2]; pLE->u.iIcon=0; //Do Ye Olde atoi while (*psz) pLE->u.iIcon=(10*pLE->u.iIcon)+((*psz++)-'0'); pLE->fFoundIndex=TRUE; return 0; } return 1; }