windows-xp/Source/XPSP1/NT/com/oleutest/letest/ole2ui/drawicon.c

/*
 * 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;
    }