STATUS_CODE ApplyColorMap(LPIMAGE lpImage, LPCOLORMAP lpColorMap, BOOL fReMap,
DITHER_TYPE DitherType, ITEMID idDirty)
/************************************************************************/
{
UNDO_TYPE UndoType;
int iMaxWidth;
FRMTYPEINFO OldTypeInfo, NewTypeInfo;
LPOBJECT lpObject;
RECT rEdit;
CFrameTypeConvert TypeConvert;
UndoType = UT_COLORMAP;
if (fReMap)
UndoType |= UT_DATA;
if (!ImgEditInit(lpImage, ET_ALLOBJECTS, UndoType, NULL))
return(SC_UNDOERROR);
ProgressBegin(ImgCountObjects(lpImage), idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
if (fReMap)
{
ImgGetTypeInfo(lpImage, &OldTypeInfo);
FrameSetTypeInfo(&NewTypeInfo, FDT_PALETTECOLOR, lpColorMap);
iMaxWidth = 0;
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
if (RectWidth(&lpObject->rObject) > iMaxWidth)
iMaxWidth = RectWidth(&lpObject->rObject);
}
if (!TypeConvert.Init(OldTypeInfo, NewTypeInfo, iMaxWidth, DitherType))
{
ProgressEnd();
Message(IDS_EMEMALLOC);
return(SC_MEMERROR);
}
}
lpObject = NULL;
while (lpObject = ImgGetNextObjectEx(lpImage, lpObject, YES, NO, YES))
{
if (fReMap)
PaletteMapPixmap(&lpObject->Pixmap, &TypeConvert);
FrameSetColorMap(ObjGetEditFrame(lpObject), lpColorMap);
rEdit = lpObject->rObject;
ImgEditedObject(lpImage, lpObject, idDirty, &rEdit);
}
ImgColorMapChanged(lpImage);
ProgressEnd();
return(SC_SUCCESS);
}
void CImage::ObjEditUndo(LPOBJECT lpObject, BOOL fUndoData, BOOL fUndoAlpha)
{
RECT rTemp;
BOOL fSelected, Resolution, fDeleted, fBase, bLocked;
LPALPHA lpAlpha, lpTemp;
LPOBJECT lpNext;
int XSize, YSize;
int tempDataType;
LPCOLORMAP lpColorMap;
int GroupID;
lpAlpha = lpObject->lpAlpha;
fBase = lpObject == GetBase();
if (fUndoData && lpObject->DataDirty)
{
if (lpObject->DataUndoType & UT_RESOLUTION)
Resolution = FrameResolution(lpObject->Pixmap.EditFrame);
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpColorMap = FrameGetColorMap(ObjGetEditFrame(lpObject)))
lpColorMap = FrameCopyColorMap(lpColorMap);
else
lpColorMap = NULL;
}
if (lpObject->DataUndoType & (UT_DATA|UT_NEWDATA))
{
PixmapEditUndo(&lpObject->Pixmap);
if (fBase)
{
npix = FrameXSize(ObjGetEditFrame(lpObject));
nlin = FrameYSize(ObjGetEditFrame(lpObject));
if (lpObject->DataUndoType & UT_NEWDATA)
{
tempDataType = DataType;
DataType = UndoDataType;
UndoDataType = tempDataType;
}
}
}
if (lpObject->DataUndoType & UT_OBJECTRECT)
{
rTemp = lpObject->rObject;
lpObject->rObject = lpObject->rUndoObject;
lpObject->rUndoObject = rTemp;
}
if (lpObject->DataUndoType & UT_RESOLUTION)
{
FrameSetResolution( lpObject->Pixmap.EditFrame,
lpObject->UndoResolution);
lpObject->UndoResolution = Resolution;
}
if (lpObject->DataUndoType & UT_UNDOTEXTDATA)
{
if (lpObject->lpUndoText)
{
CTextObject *pTmp = lpObject->lpUndoText;
lpObject->lpUndoText = lpObject->lpText;
lpObject->lpText = pTmp;
}
}
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpObject->UndoColorMap)
{
FrameSetColorMap( ObjGetEditFrame(lpObject), lpObject->UndoColorMap);
FrameDestroyColorMap(lpObject->UndoColorMap);
}
lpObject->UndoColorMap = lpColorMap;
}
if (lpObject->DataUndoType & UT_SELECTION)
{
fSelected = lpObject->fSelected;
lpObject->fSelected = lpObject->fUndoSelected;
lpObject->fUndoSelected = fSelected;
}
if (lpObject->DataUndoType & UT_LOCKOBJECTS)
{
bLocked = lpObject->bLocked;
lpObject->bLocked = lpObject->bUndoLocked;
lpObject->bUndoLocked = bLocked;
}
if (lpObject->DataUndoType & UT_GROUPOBJECTS)
{
GroupID = lpObject->wGroupID;
lpObject->wGroupID = lpObject->UndoGroupID;
lpObject->UndoGroupID = GroupID;
}
if (lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted || lpNext->fDeleted)
{
fDeleted = lpNext->fDeleted;
lpNext->fDeleted = lpNext->fUndoDeleted;
lpNext->fUndoDeleted = fDeleted;
}
}
}
if (fBase && lpObject->DataUndoType & UT_MOVEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
{
rTemp = lpNext->rObject;
lpNext->rObject = lpNext->rUndoObject;
lpNext->rUndoObject = rTemp;
}
}
lpObject->DataUndoNotRedo = !lpObject->DataUndoNotRedo;
if (!fUndoAlpha)
fUndoAlpha = lpObject->fBothDirty;
}
else if (fUndoAlpha && lpObject->fBothDirty)
fUndoAlpha = NO;
if (fUndoAlpha && lpObject->AlphaDirty)
{
if (lpAlpha)
{
if (lpObject->AlphaUndoType & (UT_ALPHA|UT_NEWALPHA))
{
PixmapEditUndo(&lpAlpha->Pixmap);
rTemp = lpAlpha->rMask;
lpAlpha->rMask = lpAlpha->rUndoMask;
lpAlpha->rUndoMask = rTemp;
}
}
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK))
{
lpTemp = lpObject->lpAlpha;
lpObject->lpAlpha = lpObject->lpUndoAlpha;
lpObject->lpUndoAlpha = lpTemp;
}
lpObject->AlphaUndoNotRedo = !lpObject->AlphaUndoNotRedo;
}
lpAlpha = lpObject->lpAlpha;
// check to make sure the mask is still the same size
if (fUndoData && fBase && lpObject->Pixmap.fNewFrame)
{
// we just undid to a different size frame bag mask delete undo
if (lpObject->lpUndoAlpha && !lpObject->fBothDirty)
ObjEditApply(lpObject, NO, YES, NO);
if (lpAlpha)
{
XSize = FrameXSize(lpAlpha->Pixmap.EditFrame);
YSize = FrameYSize(lpAlpha->Pixmap.EditFrame);
if (XSize != FrameXSize(lpObject->Pixmap.EditFrame) ||
YSize != FrameYSize(lpObject->Pixmap.EditFrame))
{
ObjEditInit(lpObject, UT_DELETEMASK);
// dont free mask if it was stored for later undo/redo
if (!lpObject->lpUndoAlpha)
MaskClose(lpObject->lpAlpha);
lpObject->fBothDirty = YES;
lpObject->AlphaDirty = lpObject->DataDirty;
lpObject->lpAlpha = NULL;
}
}
}
}
LPFRAME DIBToPaletteFrame( LPTR lpDIBMem, BOOL bForceRGB )
{
FRMDATATYPE FrameDataType;
LPBITMAPINFO lpInfo;
LPCOLORMAP lpColorMap;
LPRGBQUAD lpRGBQColorMap;
LPFRAME lpFrame;
HPTR lpSrcLine;
HPTR lpSrc;
LPTR lpDst;
BOOL bGrayMap;
int iColorMapEntries;
int iResolution;
int iFrameXSize;
int iFrameYSize;
int iSrcWidth;
int iDstWidth;
int iCount;
int y;
int i;
lpInfo = (LPBITMAPINFO)lpDIBMem;
// Get the important bitmap information
iFrameXSize = lpInfo->bmiHeader.biWidth;
iFrameYSize = lpInfo->bmiHeader.biHeight;
iResolution = ((lpInfo->bmiHeader.biXPelsPerMeter) * 254L) / 10000L;
// Make sure that we have something to do
if ((iFrameXSize <= 0) || (iFrameYSize <= 0))
{
return(NULL);
}
// Validate the image resolution
if (iResolution <= 0)
{
iResolution = 75;
}
lpRGBQColorMap = &lpInfo->bmiColors[0];
bGrayMap = TRUE;
if (lpInfo->bmiHeader.biBitCount == 4)
iColorMapEntries = 16;
else
iColorMapEntries = 256;
// Find out whether or not this is a grayscale image
for(i=0;i<iColorMapEntries;i++)
{
if (bGrayMap)
{
if ((lpRGBQColorMap[i].rgbBlue != lpRGBQColorMap[i].rgbRed) ||
(lpRGBQColorMap[i].rgbBlue != lpRGBQColorMap[i].rgbRed))
{
bGrayMap = FALSE;
break;
}
}
}
if (bGrayMap)
{
FrameDataType = FDT_GRAYSCALE;
bForceRGB = FALSE;
}
else
{
if (bForceRGB)
{
FrameDataType = FDT_RGBCOLOR;
}
else
{
FrameDataType = FDT_PALETTECOLOR;
}
}
// Create the new image frame
lpFrame = FrameOpen(FrameDataType, iFrameXSize, iFrameYSize, iResolution);
if (!lpFrame) return(NULL);
// Add the colormap to the frame if necessary
if (!bGrayMap)
{
// Allocate space for the colormap
lpColorMap = (LPCOLORMAP)Alloc( sizeof(COLORMAP)+ sizeof(RGBS) * 256);
if (!lpColorMap)
{
FrameClose(lpFrame);
return(NULL);
}
lpColorMap->NumEntries = 256;
for(i=0;i<iColorMapEntries;i++)
{
lpColorMap->RGBData[i].red = lpRGBQColorMap[i].rgbRed;
lpColorMap->RGBData[i].green = lpRGBQColorMap[i].rgbGreen;
lpColorMap->RGBData[i].blue = lpRGBQColorMap[i].rgbBlue;
}
for(i=iColorMapEntries;i<256;i++)
{
lpColorMap->RGBData[i].red = 0;
lpColorMap->RGBData[i].green = 0;
lpColorMap->RGBData[i].blue = 0;
}
if (FrameDataType == FDT_RGBCOLOR)
if (!FrameSetColorMap( lpFrame, lpColorMap ))
{
FrameClose( lpFrame );
return(NULL);
}
}
// Find the DIB data pointer and width
lpSrcLine = lpDIBMem + lpInfo->bmiHeader.biSize +
iColorMapEntries * (sizeof(RGBQUAD));
//OLD VERSION USED lpInfo->bmiHeader.biClrUsed instead of iColorMapEntries
// some 4 bit DIB's don't set biCLrUsed that way
if (lpInfo->bmiHeader.biBitCount == 4)
iSrcWidth = ((lpInfo->bmiHeader.biWidth+7)/8)*4;
else
iSrcWidth = ((lpInfo->bmiHeader.biWidth+3)/4)*4;
iDstWidth = FrameByteWidth( lpFrame );
if (bForceRGB)
{
// Copy the DIB data into the RGB Frame
if (lpInfo->bmiHeader.biBitCount == 4)
{
for(y=iFrameYSize-1;y >= 0;y--)
{
lpSrc = lpSrcLine;
lpDst = FramePointer( lpFrame, 0, y, TRUE );
iCount = (iFrameXSize+1)/2;
while(iCount-- > 0)
{
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].red;
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].green;
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].blue;
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].red;
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].green;
*lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].blue;
lpSrc++;
}
lpSrcLine += iSrcWidth;
}
}
else
{
for(y=iFrameYSize-1;y >= 0;y--)
{
lpSrc = lpSrcLine;
lpDst = FramePointer( lpFrame, 0, y, TRUE );
iCount = iFrameXSize;
while(iCount-- > 0)
{
*lpDst++ = lpColorMap->RGBData[*lpSrc].red;
*lpDst++ = lpColorMap->RGBData[*lpSrc].green;
*lpDst++ = lpColorMap->RGBData[*lpSrc].blue;
lpSrc++;
}
lpSrcLine += iSrcWidth;
}
}
}