IMAGE.C
/****************************************************************************/
/* */
/* Copyright (C) 1987-1996 Microsoft Corp. */
/* All Rights Reserved */
/* */
/****************************************************************************/
/****************************** Module Header *******************************
* Module Name: image.c
*
* Routines for opening and saving images.
*
* History:
*
****************************************************************************/
#include "imagedit.h"
#include <stdio.h>
#include <string.h>
/************************************************************************
* ImageNew
*
* Creates a new image for the specified device.
*
* Arguments:
*
* History:
*
************************************************************************/
BOOL ImageNew(
PDEVICE pDevice)
{
PIMAGEINFO pImage;
if (!(pImage = ImageLinkAlloc(pDevice, pDevice->cx, pDevice->cy,
0, 0, pDevice->nColors)))
return FALSE;
/*
* Allocate work space for the new image.
*/
if (!ImageDCCreate(pDevice->iType, pImage->cx, pImage->cy,
pImage->nColors)) {
ImageLinkFree(pImage);
return FALSE;
}
gpImageCur = pImage;
gnImages++;
giType = pDevice->iType;
/*
* Initialize the pick rectangle to encompass the entire image.
*/
PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
/*
* Mark the newly created image as dirty to be sure it gets saved.
*/
fImageDirty = TRUE;
/*
* Update the palettes.
*/
SetColorPalette(gnColors, giType, FALSE);
PropBarUpdate();
ToolboxUpdate();
ViewReset();
/*
* Reset the workspace window and then show it.
*/
WorkReset();
ShowWindow(ghwndWork, SW_SHOWNORMAL);
return TRUE;
}
/************************************************************************
* ImageNewBitmap
*
* Creates a new bitmap image given a set of characteristics. After
* device link is created for those characteristics, ImageNew() is
* called to do the actual work.
*
* Arguments:
*
* History:
*
************************************************************************/
BOOL ImageNewBitmap(
INT cx,
INT cy,
INT nColors)
{
PDEVICE pDevice;
if (!(pDevice = DeviceLinkAlloc(FT_BITMAP, NULL, nColors, cx, cy)))
return FALSE;
return ImageNew(pDevice);
}
/************************************************************************
* ImageOpen
*
* Determines what has to be done to open the specified image. If it
* is not already the current image, it will save the current image
* then will call ImageOpen2() to open the new one.
*
* Arguments:
*
* History:
*
************************************************************************/
BOOL ImageOpen(
PIMAGEINFO pImage)
{
/*
* New image is already current. Return success.
*/
if (pImage == gpImageCur)
return TRUE;
/*
* Is this an image for a known device?
*/
if (pImage->pDevice) {
/*
* Save away the current image.
*/
ImageSave();
/*
* Do the real open of the new image.
*/
return ImageOpen2(pImage);
}
else {
Message(MSG_CANTEDITIMAGE);
return FALSE;
}
}
/************************************************************************
* ImageOpen2
*
* Unconditionally opens up the specified image for editing. This involves
* parsing the DIB into various globals, putting the bits onto the screen
* and updating the different palettes appropriately.
*
* Arguments:
*
* History:
*
************************************************************************/
BOOL ImageOpen2(
PIMAGEINFO pImage)
{
HCURSOR hcurOld;
LPBITMAPINFO lpbi;
INT iBitCount;
INT cx;
INT cy;
INT nColors;
DWORD cbColorTable;
DWORD cbBits;
LPBYTE lpDIBBits;
HBITMAP hbmMono;
HBITMAP hbmImage;
PBITMAPINFO pbi;
hcurOld = SetCursor(hcurWait);
lpbi = (LPBITMAPINFO)pImage->DIBPtr;
iBitCount = lpbi->bmiHeader.biBitCount;
cx = (INT)lpbi->bmiHeader.biWidth;
cy = (INT)lpbi->bmiHeader.biHeight;
if (giType != FT_BITMAP)
cy /= 2;
nColors = pImage->nColors;
/*
* Allocate work space for the image.
*/
if (!ImageDCCreate(giType, cx, cy, nColors))
goto Error1;
/*
* Create a temporary bitmap.
*/
if (!(hbmMono = CreateBitmap(1, 1, 1, 1, NULL))) {
Message(MSG_OUTOFMEMORY);
goto Error2;
}
cbColorTable = (1 << iBitCount) * sizeof(RGBQUAD);
lpDIBBits = (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + cbColorTable;
cbBits = (((((DWORD)cx * iBitCount) + 31) & 0xffffffe0) >> 3) * cy;
/*
* Make a copy of the info header and color table.
*/
if (!(pbi = (PBITMAPINFO)MyAlloc(
sizeof(BITMAPINFOHEADER) + (INT)cbColorTable)))
goto Error3;
memcpy((LPBYTE)pbi, lpbi, sizeof(BITMAPINFOHEADER) + (INT)cbColorTable);
/* * Adjust some fields. The size field in an icon/cursor dib
* includes the AND mask bits, which we don't want to include
* right now.
*/
pbi->bmiHeader.biHeight = cy;
pbi->bmiHeader.biSizeImage = cbBits;
/*
* Set the bits into the XOR mask.
*/
hbmImage = SelectObject(ghdcImage, hbmMono);
SetDIBits(ghdcImage, hbmImage, 0, cy, lpDIBBits, pbi, DIB_RGB_COLORS);
SelectObject(ghdcImage, hbmImage);
/*
* If we are editing an icon or cursor, we need to set the bits
* for the AND mask also now.
*/
if (giType != FT_BITMAP) {
/*
* Skip past the XOR mask bits to the AND bits that follow.
*/
lpDIBBits += cbBits;
cbColorTable = 2 * sizeof(RGBQUAD);
/*
* Adjust some fields in the copy of the bitmap info structure,
* then copy a monochrome color table into it. Note that we
* are using the same allocated copy, which is ok because there
* will always be enough room allocated for the monochrome
* color table.
*/
pbi->bmiHeader.biBitCount = 1;
pbi->bmiHeader.biSizeImage =
cy * ((((DWORD)cx + 31) & 0xffffffe0) >> 3);
pbi->bmiHeader.biClrImportant = 0;
pbi->bmiHeader.biClrUsed = 0;
memcpy((PBYTE)pbi->bmiColors, (PBYTE)gargbColorTable2,
(INT)cbColorTable);
/*
* Set the bits into the AND mask.
*/
hbmImage = SelectObject(ghdcANDMask, hbmMono);
SetDIBits(ghdcANDMask, hbmImage, 0, cy, lpDIBBits, pbi,
DIB_RGB_COLORS);
SelectObject(ghdcANDMask, hbmImage);
/*
* Combine the XOR and AND masks into a viewable image.
*/
ImageDCCombine(ghdcImage, gcxImage, gcyImage, ghdcANDMask);
}
MyFree(pbi);
DeleteObject(hbmMono);
/*
* Set the current image pointer.
*/
gpImageCur = pImage;
fImageDirty = FALSE;
/*
* Initialize the pick rectangle to encompass the entire image.
*/
PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
SetColorPalette(gnColors, giType, FALSE);
/*
* Update the properties bar info and toolbox.
*/
PropBarUpdate();
ToolboxUpdate();
ViewReset();
/*
* Reset the workspace window and then show it.
*/
WorkReset();
ShowWindow(ghwndWork, SW_SHOWNORMAL);
SetCursor(hcurOld);
return TRUE;
Error3:
DeleteObject(hbmMono);
Error2:
ImageDCDelete();
Error1:
SetCursor(hcurOld);
return FALSE;
}
/************************************************************************
* ImageSave
*
* Saves the state of the current image into the image list (if it
* is dirty).
*
* History:
*
************************************************************************/
VOID ImageSave(VOID)
{
HCURSOR hcurOld;
INT iBitCount;
DWORD cbColorTable;
DWORD cbXORBits;
DWORD cbANDBits;
HANDLE hDIB;
DWORD dwDIBSize;
LPBITMAPINFOHEADER lpbih;
LPBYTE lpBits;
HBITMAP hbmMono;
HBITMAP hbmImage;
if (!fImageDirty)
return;
hcurOld = SetCursor(hcurWait);
/*
* Separate out the XOR and AND masks for ico/cur images.
*/
if (giType != FT_BITMAP)
ImageDCSeparate(ghdcImage, gcxImage, gcyImage, ghdcANDMask, grgbScreen);
/*
* Create a temporary bitmap.
*/
if (!(hbmMono = CreateBitmap(1, 1, 1, 1, NULL))) {
Message(MSG_OUTOFMEMORY);
goto Error1;
}
switch (gpImageCur->nColors) {
case 2:
iBitCount = 1;
break;
case 16:
iBitCount = 4;
break;
}
cbColorTable = (DWORD)gpImageCur->nColors * sizeof(RGBQUAD);
cbXORBits = (((((DWORD)gpImageCur->cx * iBitCount) + 31)
& 0xffffffe0) >> 3) * gpImageCur->cy;
switch (giType) {
case FT_BITMAP:
cbANDBits = 0;
break;
case FT_ICON:
case FT_CURSOR:
cbANDBits = (DWORD)gpImageCur->cy *
((((DWORD)gpImageCur->cx + 31) & 0xffffffe0) >> 3);
break;
}
dwDIBSize = sizeof(BITMAPINFOHEADER) + cbColorTable + cbXORBits +
cbANDBits;
/*
* Allocate space for the DIB for this image.
*/
if (!(hDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwDIBSize))) {
Message(MSG_OUTOFMEMORY);
goto Error2;
}
lpbih = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
/*
* For icons and cursors, we need to get the AND mask bits first.
*/
if (giType != FT_BITMAP) {
/*
* Point to where the AND bits should go.
*/
lpBits = (LPBYTE)lpbih + sizeof(BITMAPINFOHEADER) +
cbColorTable + cbXORBits;
/*
* Fill in the bitmap info header for getting the AND bits.
*/
lpbih->biSize = sizeof(BITMAPINFOHEADER);
lpbih->biWidth = gpImageCur->cx;
lpbih->biHeight = gpImageCur->cy;
lpbih->biPlanes = 1;
lpbih->biBitCount = 1;
lpbih->biCompression = BI_RGB;
lpbih->biSizeImage = cbANDBits;
lpbih->biXPelsPerMeter = 0;
lpbih->biYPelsPerMeter = 0;
lpbih->biClrImportant = 0;
lpbih->biClrUsed = 0;
/*
* Get the bits from the AND mask.
*/
hbmImage = SelectObject(ghdcANDMask, hbmMono);
GetDIBits(ghdcANDMask, hbmImage, 0, gpImageCur->cy, lpBits,
(LPBITMAPINFO)lpbih, DIB_RGB_COLORS);
SelectObject(ghdcANDMask, hbmImage);
}
/*
* Fill in the bitmap info header for getting the XOR bits.
*/
lpbih->biSize = sizeof(BITMAPINFOHEADER);
lpbih->biWidth = gpImageCur->cx;
lpbih->biHeight = gpImageCur->cy;
lpbih->biPlanes = 1;
lpbih->biBitCount = iBitCount;
lpbih->biCompression = BI_RGB;
lpbih->biSizeImage = cbXORBits;
lpbih->biXPelsPerMeter = 0;
lpbih->biYPelsPerMeter = 0;
lpbih->biClrImportant = 0;
lpbih->biClrUsed = 0;
/*
* Point to where the XOR bits should go.
*/
lpBits = (LPBYTE)lpbih + sizeof(BITMAPINFOHEADER) + cbColorTable;
/*
* Get the bits from the XOR mask.
*/
hbmImage = SelectObject(ghdcImage, hbmMono);
GetDIBits(ghdcImage, hbmImage, 0, gpImageCur->cy, lpBits,
(LPBITMAPINFO)lpbih, DIB_RGB_COLORS);
SelectObject(ghdcImage, hbmImage);
/*
* For icons and cursors, we have a few extra steps.
*/
if (giType != FT_BITMAP) {
/*
* Set the fields in the info structure to their final
* values. The saved value in the bitmap info header for the
* height in an icon/cursor DIB is really twice the height of
* the image, and the size of the image is the size of both
* the XOR and the AND mask bits.
*/
lpbih->biHeight *= 2;
lpbih->biSizeImage = cbXORBits + cbANDBits;
/*
* Recombine the XOR and AND masks now that we have their bits.
*/
ImageDCCombine(ghdcImage, gcxImage, gcyImage, ghdcANDMask);
}
/*
* Free any old DIB.
*/
if (gpImageCur->DIBhandle) {
GlobalUnlock(gpImageCur->DIBhandle);
GlobalFree(gpImageCur->DIBhandle);
}
/*
* Set the image structure to point to the newly created DIB.
*/
gpImageCur->DIBSize = dwDIBSize;
gpImageCur->DIBhandle = hDIB;
gpImageCur->DIBPtr = (LPBYTE)lpbih;
fFileDirty = TRUE;
fImageDirty = FALSE;
Error2:
DeleteObject(hbmMono);
Error1:
SetCursor (hcurOld);
}