Windows Kernel

Development Platform:
Visual C++

miniicon.cpp：Code Content
							/*
**------------------------------------------------------------------------------
** Module:  Disk Cleanup Applet
** File:    miniicon.c
**
** Purpose: Creates and Manages the mini icons
** Notes:   
** Mod Log: Created by Jason Cobb (2/97)
**
** Copyright (c)1997 Microsoft Corporation, All Rights Reserved
**------------------------------------------------------------------------------
*/
/*
**------------------------------------------------------------------------------
** Project include files
**------------------------------------------------------------------------------
*/
#include "common.h"
#include "resource.h"
#include "miniicon.h"
/*
**------------------------------------------------------------------------------
**	Local variables
**------------------------------------------------------------------------------
*/
HINSTANCE   MiniIcon::hInstance             = NULL;
MiniIcon::MiniIcon(
    void
    )
{
    hdcMiniMem = NULL;
    hbmMiniImage = NULL;
    hbmMiniMask = NULL;
    NumImages = 0;
 
    CreateMiniIcons();
}
MiniIcon::~MiniIcon(
    void
    )
{
    DestroyMiniIcons();
}
void
MiniIcon::Register(
    HINSTANCE hInstance
    )
{
    MiniIcon::hInstance = hInstance;
}
void
MiniIcon::Unregister(
    void
    )
{
    MiniIcon::hInstance= NULL;
}
BOOL
MiniIcon::CreateMiniIcons(
    void
    )
{
    HDC     hdc, hdcMem;
    HBITMAP hbmOld;
    BITMAP  bm;
    BOOL    bRet = FALSE;          // assume failure
    MiDebugMsg((0, "MiniIcon:CreateMiniIcons()"));
    if(hdcMiniMem) 
    {
        //
        // Then the mini-icon list has already been built, so
        // return success.
        //
        return TRUE;
    }
    hdc = GetDC(NULL);
    hdcMiniMem = CreateCompatibleDC(hdc);
    ReleaseDC(NULL, hdc);
    if(!hdcMiniMem) 
    {
        goto clean0;
    }
    if(!(hdcMem = CreateCompatibleDC(hdcMiniMem))) 
    {
        goto clean0;
    }
    if(!(hbmMiniImage = LoadBitmap(MiniIcon::hInstance, MAKEINTRESOURCE(BMP_MINIICONS)))) 
    {
        goto clean1;
    }
    GetObject(hbmMiniImage, sizeof(bm), &bm);
    if(!(hbmMiniMask = CreateBitmap(bm.bmWidth,
                                    bm.bmHeight,
                                    1,
                                    1,
                                    NULL))) 
    {
        goto clean1;
    }
    hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMiniImage);
    SelectObject(hdcMiniMem, hbmMiniMask);
    //
    // make the mask.  white where transparent, black where opaque
    //
    SetBkColor(hdcMem, RGB_TRANSPARENT);
    BitBlt(hdcMiniMem,
           0,
           0,
           bm.bmWidth,
           bm.bmHeight,
           hdcMem,
           0,
           0,
           SRCCOPY
          );
    //
    // black-out all of the transparent parts of the image, in preparation
    // for drawing.
    //
    SetBkColor(hdcMem, RGB_BLACK);
    SetTextColor(hdcMem, RGB_WHITE);
    BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, hdcMiniMem, 0, 0, SRCAND);
    SelectObject(hdcMiniMem, hbmOld);
    NumImages = bm.bmWidth/MINIX;
    bRet = TRUE;
    SelectObject(hdcMem, hbmOld);
clean1:
    DeleteObject(hdcMem);
clean0:
    //
    // If failure, clean up anything we might have built
    //
    if(!bRet) 
    {
        DestroyMiniIcons();
    }
    return bRet;
}
void
MiniIcon::DestroyMiniIcons(
    void
    )
{
    MiDebugMsg((0, "MiniIcon::DestroyMiniIcons()"));
    if(hdcMiniMem) 
    {
        DeleteDC(hdcMiniMem);
        hdcMiniMem = NULL;
    }
    if(hbmMiniImage) 
    {
        DeleteObject(hbmMiniImage);
        hbmMiniImage = NULL;
    }
    if(hbmMiniMask) 
    {
        DeleteObject(hbmMiniMask);
        hbmMiniMask = NULL;
    }
    NumImages = 0;
}
/**************************************************************************
Routine Description:
    This routine draws the specified mini-icon at the requested location.
Arguments:
    hdc - Supplies the handle of the device context in which the mini-icon
        will be drawn.
    rc - Supplies the rectangle in the specified HDC to draw the icon in.
    MiniIconIndex - The index of the mini-icon
            0   Check
            1   Uncheck
    Flags - Controls the drawing operation.  The LOWORD contains the actual flags
        defined as follows:
        DMI_MASK - Draw the mini-icon's mask into HDC.
        DMI_BKCOLOR - Use the system color index specified in the HIWORD of Flags
            as the background color.  If not specified, COLOR_WINDOW is used.
        DMI_USERECT - If set, DrawMiniIcon will use the supplied rect,
            stretching the icon to fit as appropriate.
Return Value:
    This function returns the offset from the left of rc where the string should
    start.
Remarks:
    By default, the icon will be centered vertically and butted against the left
    corner of the specified rectangle.
**********************************************************************************/
int
MiniIcon::DrawMiniIcon(
    HDC   hdc,
    RECT  rc,
    INT   MiniIconIndex,
    DWORD Flags
    )
{
    HBITMAP hbmOld;
    DWORD rgbBk, rgbText;
    INT ret = 0;
    if(hbmMiniImage) 
    {
        //
        // Set the Foreground and  background color for the
        // conversion of the Mono Mask image
        //
        if(Flags & DMI_MASK) 
        {
            rgbBk = SetBkColor(hdc, RGB_WHITE);
        } 
        
        else 
        {
            rgbBk = SetBkColor(hdc,
                               GetSysColor(((int)(Flags & DMI_BKCOLOR
                                                      ? HIWORD(Flags)
                                                      : COLOR_WINDOW)))
                              );
        }
        
        rgbText = SetTextColor(hdc, RGB_BLACK);
        if(Flags & DMI_USERECT) 
        {
            //
            // Copy the converted mask into the dest.  The transparent
            // areas will be drawn with the current window color.
            //
            hbmOld = (HBITMAP)SelectObject(hdcMiniMem,
                                  hbmMiniMask
                                 );
            StretchBlt(hdc,
                       rc.left,
                       rc.top,
                       rc.right - rc.left,
                       rc.bottom - rc.top,
                       hdcMiniMem,
                       MINIX * MiniIconIndex,
                       0,
                       MINIX,
                       MINIY,
                       SRCCOPY);
            if(!(Flags & DMI_MASK)) 
            {
                //
                // OR the image into the dest
                //
                SelectObject(hdcMiniMem,
                             hbmMiniImage
                            );
                            
                StretchBlt(hdc,
                           rc.left,
                           rc.top,
                           rc.right - rc.left,
                           rc.bottom - rc.top,
                           hdcMiniMem,
                           MINIX * MiniIconIndex,
                           0,
                           MINIX,
                           MINIY,
                           SRCPAINT);
            }
        } 
        
        else 
        {
            //
            // Copy the converted mask into the dest.  The transparent
            // areas will be drawn with the current window color.
            //
            hbmOld = (HBITMAP)SelectObject(hdcMiniMem,
                                  hbmMiniMask
                                 );
            
            BitBlt(hdc,
                   rc.left,
                   rc.top + (rc.bottom - rc.top - MINIY)/2,
                   MINIX,
                   MINIY,
                   hdcMiniMem,
                   MINIX * MiniIconIndex,
                   0,
                   SRCCOPY
                  );
            if(!(Flags & DMI_MASK)) 
            {
                //
                // OR the image into the dest
                //
                SelectObject(hdcMiniMem,
                             hbmMiniImage
                            );
                BitBlt(hdc,
                       rc.left,
                       rc.top + (rc.bottom - rc.top - MINIY)/2,
                       MINIX,
                       MINIY,
                       hdcMiniMem,
                       MINIX * MiniIconIndex,
                       0,
                       SRCPAINT
                      );
            }
        }
        SetBkColor(hdc, rgbBk);
        SetTextColor(hdc, rgbText);
        SelectObject(hdcMiniMem, hbmOld);
        if(Flags & DMI_USERECT) 
        {
            ret = rc.right - rc.left + 2;   // offset to string from left edge
        } 
        
        else 
        {
            ret = MINIX + 2;                // offset to string from left edge
        }
    }
    return ret;
}

						