/*
* RESIMAGE.CPP
*
* Implementation of the Results Image control for OLE 2.0 UI dialogs.
* We need a separate control for dialogs in order to control the repaints
* properly and to provide a clean message interface for the dialog
* implementations.
*
* Copyright (c)1992 Microsoft Corporation, All Right Reserved
*/
#include "precomp.h"
#include "resimage.h"
#include "uiclass.h"
OLEDBGDATA
//Reference counter indicating how many times fResultImageInitialize has been
//successfully called
static UINT uRegistered = 0;
//Bitmap and image dimensions for result images.
static HBITMAP hBmpResults = NULL;
static UINT cxBmpResult;
static UINT cyBmpResult;
/*
* FResultImageInitialize
*
* Purpose:
* Attempts to load result bitmaps for the current display driver
* for use in OLE 2.0 UI dialogs. Also registers the ResultImage
* control class.
*
* Parameters:
* hInst HINSTANCE instance of the DLL.
*
* hPrevInst HINSTANCE of the previous instance. Used to
* determine whether to register window classes or not.
*
* Return Value:
* BOOL TRUE if all initialization succeeded, FALSE otherwise.
*/
#pragma code_seg(".text$initseg")
BOOL FResultImageInitialize(HINSTANCE hInst, HINSTANCE hPrevInst)
{
int cx, iBmp;
HDC hDC;
BITMAP bm;
WNDCLASS wc;
/*
* Determine the aspect ratio of the display we're currently
* running on and load the appropriate bitmap into the global
* hBmpResults (used from the ResultImage control only).
*
* By retrieving the logical Y extent of the display driver, you
* only have limited possibilities:
* LOGPIXELSY Display
* ----------------------------------------
* 48 CGA (unsupported)
* 72 EGA
* 96 VGA
* 120 8514/a (i.e. HiRes VGA)
*/
hDC=GetDC(NULL);
if (NULL==hDC)
return FALSE;
cx=GetDeviceCaps(hDC, LOGPIXELSY);
ReleaseDC(NULL, hDC);
/*
* Instead of single comparisons, check ranges instead, so in case
* we get something funky, we'll act reasonable.
*/
if (72 >=cx) iBmp=IDB_RESULTSEGA;
if (72 < cx && 120 > cx) iBmp=IDB_RESULTSVGA;
if (120 <=cx) iBmp=IDB_RESULTSHIRESVGA;
if (NULL == hBmpResults)
{
hBmpResults=LoadBitmap(hInst, MAKEINTRESOURCE(iBmp));
if (NULL==hBmpResults)
{
//On error, fail loading the DLL
OleDbgOut1(TEXT("FResultImageInitialize: Failed LoadBitmap.\r\n"));
return FALSE;
}
OleDbgOut4(TEXT("FResultImageInitialize: Loaded hBmpResults\r\n"));
// Now that we have the bitmap, calculate image dimensions
GetObject(hBmpResults, sizeof(BITMAP), &bm);
cxBmpResult = bm.bmWidth/CIMAGESX;
cyBmpResult = bm.bmHeight;
}
// Only register class if we're the first instance
if (hPrevInst)
uRegistered++;
else
{
// Static flag fRegistered guards against calling this function more
// than once in the same instance
if (0 == uRegistered)
{
wc.lpfnWndProc =ResultImageWndProc;
wc.cbClsExtra =0;
wc.cbWndExtra =CBRESULTIMAGEWNDEXTRA;
wc.hInstance =hInst;
wc.hIcon =NULL;
wc.hCursor =LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground =NULL;
wc.lpszMenuName =NULL;
wc.style =CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
wc.lpszClassName = TEXT(SZCLASSRESULTIMAGE1);
uRegistered = RegisterClass(&wc) ? 1 : 0;
wc.lpszClassName = TEXT(SZCLASSRESULTIMAGE2);
uRegistered = RegisterClass(&wc) ? 1 : 0;
wc.lpszClassName = TEXT(SZCLASSRESULTIMAGE3);
uRegistered = RegisterClass(&wc) ? 1 : 0;
}
else
uRegistered++;
}
return (uRegistered > 0);
}
#pragma code_seg()
/*
* ResultImageUninitialize
*
* Purpose:
* Cleans up anything done in FResultImageInitialize, such as freeing
* the bitmaps. Call from WEP.
*
* Parameters:
* None
*
* Return Value:
* None
*/
void ResultImageUninitialize(void)
{
--uRegistered;
if (0 == uRegistered)
{
if (NULL != hBmpResults)
{
DeleteObject(hBmpResults);
hBmpResults = NULL;
}
}
}
/*
* ResultImageWndProc
*
* Purpose:
* Window Procedure for the ResultImage custom control. Only handles
* WM_CREATE, WM_PAINT, and private messages to manipulate the bitmap.
*
* Parameters:
* Standard
*
* Return Value:
* Standard
*/
LONG CALLBACK ResultImageWndProc(HWND hWnd, UINT iMsg,
WPARAM wParam, LPARAM lParam)
{
UINT iBmp;
PAINTSTRUCT ps;
HDC hDC;
//Handle standard Windows messages.
switch (iMsg)
{
case WM_CREATE:
SetWindowWord(hWnd, RIWW_IMAGEINDEX, RESULTIMAGE_NONE);
return 0L;
case WM_PAINT:
iBmp = GetWindowWord(hWnd, RIWW_IMAGEINDEX);
hDC = BeginPaint(hWnd, &ps);
RECT rc;
UINT x, y;
HDC hDCDlg;
HBRUSH hBr;
LOGBRUSH lb;
HWND hDlg;
/*
* Our job before using TransparentBlt is to figure out
* where to position the result image. We place it centered
* on this control, so get our rect's center and subtract
* half of the image dimensions.
*/
GetClientRect(hWnd, &rc);
x = (rc.right+rc.left-cxBmpResult)/2;
y = (rc.bottom+rc.top-cyBmpResult)/2;
// Get the backgroup color the dialog is using.
hDlg=GetParent(hWnd);
hDCDlg=GetDC(hDlg);
hBr = (HBRUSH)SendMessage(hDlg,
WM_CTLCOLORDLG,
(WPARAM)hDCDlg,
(LPARAM)hDlg);
ReleaseDC(hDlg, hDCDlg);
GetObject(hBr, sizeof(LOGBRUSH), &lb);
SetBkColor(hDC, lb.lbColor);
if (RESULTIMAGE_NONE != iBmp)
{
TransparentBlt(hDC, x, y, hBmpResults, iBmp*cxBmpResult, 0,
cxBmpResult, cyBmpResult, RGBTRANSPARENT);
}
else
{
FillRect(hDC, &rc, hBr);
}
EndPaint(hWnd, &ps);
break;
case RIM_IMAGESET:
// wParam contains the new index.
iBmp=GetWindowWord(hWnd, RIWW_IMAGEINDEX);
// Validate the index before changing it and repainting
if (RESULTIMAGE_NONE==wParam ||
((RESULTIMAGE_MIN <= wParam) && (RESULTIMAGE_MAX >= wParam)))
{
SetWindowWord(hWnd, RIWW_IMAGEINDEX, (WORD)wParam);
InvalidateRect(hWnd, NULL, FALSE);
UpdateWindow(hWnd);
}
// Return the previous index.
return iBmp;
case RIM_IMAGEGET:
// Return the current index.
iBmp=GetWindowWord(hWnd, RIWW_IMAGEINDEX);
return (LONG)iBmp;
default:
return DefWindowProc(hWnd, iMsg, wParam, lParam);
}
return 0L;
}
/*
* TransparentBlt
*
* Purpose:
* Given a DC, a bitmap, and a color to assume as transparent in that
* bitmap, BitBlts the bitmap to the DC letting the existing background
* show in place of the transparent color.
*
* Parameters:
* hDC HDC on which to draw.
* x, y UINT location at which to draw the bitmap
* hBmp HBITMIP to draw from
* xOrg, yOrg UINT coordinates from which to draw the bitamp
* cx, cy UINT dimensions of the bitmap to Blt.
* cr COLORREF to consider as transparent.
*
* Return Value:
* None
*/
void TransparentBlt(HDC hDC, UINT x, UINT y, HBITMAP hBmp, UINT xOrg, UINT yOrg,
UINT cx, UINT cy, COLORREF cr)
{
HDC hDCSrc, hDCMid, hMemDC;
HBITMAP hBmpMono, hBmpT;
HBRUSH hBr, hBrT;
COLORREF crBack, crText;
if (NULL == hBmp)
return;
// Get three intermediate DC's
hDCSrc = CreateCompatibleDC(hDC);
hDCMid = CreateCompatibleDC(hDC);
hMemDC = CreateCompatibleDC(hDC);
SelectObject(hDCSrc, hBmp);
// Create a monochrome bitmap for masking
hBmpMono=CreateCompatibleBitmap(hDCMid, cx, cy);
SelectObject(hDCMid, hBmpMono);
// Create a middle bitmap
hBmpT=CreateCompatibleBitmap(hDC, cx, cy);
SelectObject(hMemDC, hBmpT);
// Create a monochrome mask where we have 0's in the image, 1's elsewhere.
crBack=SetBkColor(hDCSrc, cr);
BitBlt(hDCMid, 0, 0, cx, cy, hDCSrc, xOrg, yOrg, SRCCOPY);
SetBkColor(hDCSrc, crBack);
// Put the unmodified image in the temporary bitmap
BitBlt(hMemDC, 0, 0, cx, cy, hDCSrc, xOrg, yOrg, SRCCOPY);
// Create an select a brush of the background color
hBr = CreateSolidBrush(GetBkColor(hDC));
hBrT = (HBRUSH)SelectObject(hMemDC, hBr);
// Force conversion of the monochrome to stay black and white.
crText=SetTextColor(hMemDC, 0L);
crBack=SetBkColor(hMemDC, RGB(255, 255, 255));
/*
* Where the monochrome mask is 1, Blt the brush; where the mono mask
* is 0, leave the destination untouches. This results in painting
* around the image with the background brush. We do this first
* in the temporary bitmap, then put the whole thing to the screen.
*/
BitBlt(hMemDC, 0, 0, cx, cy, hDCMid, 0, 0, ROP_DSPDxax);
BitBlt(hDC, x, y, cx, cy, hMemDC, 0, 0, SRCCOPY);
SetTextColor(hMemDC, crText);
SetBkColor(hMemDC, crBack);
SelectObject(hMemDC, hBrT);
DeleteObject(hBr);
DeleteDC(hMemDC);
DeleteDC(hDCSrc);
DeleteDC(hDCMid);
DeleteObject(hBmpT);
DeleteObject(hBmpMono);
}
