void ObjEditApply(LPIMAGE lpImage, LPOBJECT lpObject,
BOOL fApplyData, BOOL fApplyAlpha,
BOOL fInitFrame)
/***********************************************************************/
{
LPALPHA lpAlpha;
LPOBJECT lpNext;
BOOL fInitingData, fInitingAlpha;
if (!fApplyData && !fApplyAlpha)
return;
lpObject->InitUndoType = 0;
fInitingAlpha = fInitFrame && fApplyAlpha;
fInitingData = fInitFrame && fApplyData;
lpAlpha = lpObject->lpAlpha;
if (fApplyData)
{
if (lpObject->fBothDirty)
fApplyAlpha = YES;
if (lpObject == ImgGetBase(lpImage))
{
ImgPurgeObjects(lpImage);
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, NO))
lpNext->fUndoDeleted = NO;
}
if (!fInitingData)
PixmapFreeUndo(&lpObject->Pixmap);
else
PixmapEditApply(&lpObject->Pixmap);
lpObject->DataUndoType = 0;
lpObject->DataDirty = NO;
}
if (fApplyAlpha)
{
if (lpObject->lpUndoAlpha)
{
MaskClose(lpObject->lpUndoAlpha);
lpObject->lpUndoAlpha = NULL;
}
if (lpAlpha)
{
if (!fInitingAlpha)
PixmapFreeUndo(&lpAlpha->Pixmap);
else
PixmapEditApply(&lpAlpha->Pixmap);
}
lpObject->AlphaUndoType = 0;
lpObject->AlphaDirty = NO;
}
lpObject->fBothDirty = NO;
}
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);
}
static void ObjEditUndo(LPIMAGE lpImage, LPOBJECT lpObject, BOOL fUndoData, BOOL fUndoAlpha)
/***********************************************************************/
{
RECT rTemp;
BOOL fSelected, Resolution, fDeleted, fBase;
LPALPHA lpAlpha, lpTemp;
LPOBJECT lpNext;
int XSize, YSize;
int tempDataType;
lpAlpha = lpObject->lpAlpha;
fBase = lpObject == ImgGetBase(lpImage);
if (fUndoData && lpObject->DataDirty)
{
if (lpObject->DataUndoType & UT_RESOLUTION)
Resolution = FrameResolution(lpObject->Pixmap.EditFrame);
if (lpObject->DataUndoType & (UT_DATA|UT_NEWDATA))
{
PixmapEditUndo(&lpObject->Pixmap);
if (fBase)
{
lpImage->npix = FrameXSize(ObjGetEditFrame(lpObject));
lpImage->nlin = FrameYSize(ObjGetEditFrame(lpObject));
if (lpObject->DataUndoType & UT_NEWDATA)
{
tempDataType = lpImage->DataType;
lpImage->DataType = lpImage->UndoDataType;
lpImage->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_SELECTION)
{
fSelected = lpObject->fSelected;
lpObject->fSelected = lpObject->fUndoSelected;
lpObject->fUndoSelected = fSelected;
}
if (lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, 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 = ImgGetNextObjectEx(lpImage, 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(lpImage, 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(lpImage, lpObject, UT_DELETEMASK);
lpObject->fBothDirty = YES;
lpObject->AlphaDirty = lpObject->DataDirty;
lpObject->lpAlpha = NULL;
}
}
}
}
static BOOL ObjEditInit(LPIMAGE lpImage, LPOBJECT lpObject, UNDO_TYPE UndoType)
/***********************************************************************/
{
LPALPHA lpAlpha;
LPOBJECT lpNext;
BOOL fBase, fDataInit, fAlphaInit;
// See if this objects the base, and get alpha channel of object
fBase = (lpObject == ImgGetBase(lpImage));
lpAlpha = lpObject->lpAlpha;
//
// HANDLE INITIALIZATION OF OBJECT DATA
//
fDataInit = (UndoType & UT_DATAUNDO) != 0;
if (fDataInit && !Control.NoUndo)
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone
// the init flag is set only if we are doing an edit in place change
// to the data so we get rid of any useless undo's
if (!Control.UseApply || ( Control.UseApply && !lpObject->DataUndoNotRedo ) )
ObjEditApply(lpImage, lpObject, YES, !fBase, (UndoType & UT_DATA) != 0);
// Save undo information for the specific type of operation
if (UndoType & UT_OBJECTRECT && !(lpObject->DataUndoType & UT_OBJECTRECT))
lpObject->rUndoObject = lpObject->rObject;
if (UndoType & UT_RESOLUTION && !(lpObject->DataUndoType & UT_RESOLUTION))
lpObject->UndoResolution = FrameResolution(ObjGetEditFrame(lpObject));
if (UndoType & UT_SELECTION && !(lpObject->DataUndoType & UT_SELECTION))
lpObject->fUndoSelected = lpObject->fSelected;
// Size base is a special case for the base and base only
if (UndoType & UT_DATA)
{
// init the data pixmap for editing
if (!lpObject->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpObject->Pixmap))
return(FALSE);
}
if (UndoType & UT_NEWDATA)
{
if (fBase)
lpImage->UndoDataType = lpImage->DataType;
}
if (fBase && UndoType & UT_MOVEOBJECTS &&
!(lpObject->DataUndoType & UT_MOVEOBJECTS))
{
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, NO))
lpNext->rUndoObject = lpNext->rObject;
}
// Delete objects is a special case for the base and base only
if (fBase && UndoType & UT_DELETEOBJECTS &&
!(lpObject->DataUndoType & UT_DELETEOBJECTS))
{
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, YES))
lpNext->fUndoDeleted = NO;
}
}
// now that we have successfully initialized everything set UndoTypes
if (fDataInit)
{
lpObject->DataUndoNotRedo = YES;
lpObject->DataUndoType |= (UndoType & UT_DATAUNDO);
}
//
// HANDLE INITIALIZATION OF OBJECT ALPHA
//
fAlphaInit = (UndoType & UT_ALPHAUNDO) != 0;
if (fAlphaInit && !Control.NoUndo && (!fBase || Control.UndoMasks))
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone or
// apply any changes only to the mask
// or if it is a change to both data and mask and
// both were not dirty before
// Initialize the data undo if the object is not the base and we didn't
// already do a data init
// the init flag is set only if we are doing an edit in place change
// to the alpha so we get rid of any useless undo's
if (!Control.UseApply ||
(Control.UseApply && !lpObject->AlphaUndoNotRedo) ||
(fBase && (!fDataInit || !lpObject->fBothDirty)))
ObjEditApply(lpImage, lpObject, fDataInit ? NO : !fBase, YES,
(UndoType & UT_ALPHA) != 0);
// Save undo information for the specific type of operation
if (lpAlpha)
{
if (!lpObject->AlphaUndoType)
{
if (UndoType & UT_ALPHA)
{
// init the data pixmap for editing
if (!lpAlpha->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpAlpha->Pixmap))
return(FALSE);
lpAlpha->rUndoMask = lpAlpha->rMask;
}
if (UndoType & UT_NEWALPHA)
lpAlpha->rUndoMask = lpAlpha->rMask;
if (fBase && UndoType & UT_CREATEMASK)
lpObject->lpUndoAlpha = NULL;
if (fBase && UndoType & UT_DELETEMASK)
lpObject->lpUndoAlpha = lpAlpha;
if (UndoType & UT_ALPHAUNDO)
{
lpObject->AlphaUndoNotRedo = YES;
lpObject->AlphaUndoType |= (UndoType & UT_ALPHAUNDO);
}
}
}
}
return(TRUE);
}
void ImgEditUndo( LPIMAGE lpImage, BOOL fEditUndo, BOOL fMaskUndo )
/***********************************************************************/
{
RECT rUndo, rUndoMask, rTemp;
LPOBJECT lpBase, lpObject, lpNext;
BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete;
BOOL fUndoAlpha, fUndoData;
int nDeleted;
LPMASK lpMask;
if (!lpImage)
return;
// Initialize things for updating the display
fNewSize = fSetupMiniViews = fUndoDelete = NO;
AstralSetRectEmpty(&rUndo);
AstralSetRectEmpty(&rUndoMask);
// loop through objects doing undo
lpBase = ImgGetBase(lpImage);
lpObject = NULL;
while (lpObject = ImgGetNextObjectEx(lpImage, lpObject, NO, NO, fEditUndo))
{
// See if this is an object we are undoing
if (fEditUndo)
{
// check for special undo processing of a deleted object
if (lpObject->fDeleted)
{
if (Control.UndoObjects && !ImgIsSelectedObject(lpImage, lpBase))
continue;
}
else
if (Control.UndoObjects && !ImgIsSelectedObject(lpImage, lpObject))
continue;
}
// Only handle mask undo for the base object
if (fMaskUndo)
{
if (lpObject != lpBase || lpObject->fBothDirty ||
!lpObject->AlphaDirty)
continue;
}
fUndoData = fUndoAlpha = NO;
// Do preprocess for doing a data undo
if (fEditUndo)
{
if (lpObject->DataDirty)
fUndoData = YES;
// See if we need to undo the alpha for this object
if ((lpObject != lpBase) && lpObject->lpAlpha && lpObject->AlphaDirty)
fUndoAlpha = YES;
if (!fUndoData && !fUndoAlpha)
continue;
// check to see and undoing/redoing deleted objects will change
// the select state, if so undraw the object marquee
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
fUndoDelete = YES;
fRemoveMarquee = NO;
nDeleted = 0;
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted)
++nDeleted;
else
if (lpNext->fDeleted && lpNext->fSelected)
{
fRemoveMarquee = YES;
break;
}
}
if (ImgGetSelObject(lpImage, NULL) == lpBase && !fRemoveMarquee)
{
if (ImgCountObjects(lpImage) - nDeleted <= 1)
fRemoveMarquee = YES;
}
if (fRemoveMarquee)
RemoveObjectMarqueeEx(lpImage, NO);
}
}
else // fMaskUndo
if (!lpObject->AlphaDirty)
continue;
else
fUndoAlpha = YES;
// do a preprocess for undoing the mask caused either by
// a mask undo or by an edit function that also edits the mask
if (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo)
{
if ( lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
// if the undo is going to delete the mask,
// we need to undraw the mask
if (ImgGetMask(lpImage))
{
RemoveMaskMarquee(lpImage);
if (ImgGetMaskUpdateRect(lpImage, YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
// if the undo is going to create the mask,
// we need to undraw the object marquees if
// not in mask and object marquee mode
else
{
if (!Control.UseMaskAndObjects)
RemoveObjectMarqueeEx(lpImage, NO);
}
}
}
// Actually do the undo
ObjEditUndo(lpImage, lpObject, fUndoData, fUndoAlpha);
// do a postprocess for undoing the mask
if ((lpMask = ImgGetMask(lpImage)) &&
(((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo))
{
// if the undo is going to add the mask, we need to redraw the mask
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
if (ImgGetMaskUpdateRect(lpImage, YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
else
// just redraw the undo area for the mask
AstralUnionRect(&rUndoMask, &rUndoMask, &lpMask->Pixmap.UndoRect);
}
// Setup rectangle for undoing deletion of objects
// Handled specially so that moved objects will still undo
// and redo properly
if (fEditUndo)
{
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, YES))
{
if (lpNext->fDeleted || lpNext->fUndoDeleted)
AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject);
}
fSetupMiniViews = YES;
}
if (lpObject->Pixmap.fNewFrame)
{
/* if new frame, cause window to be redisplayed */
if (lpObject == lpBase)
fNewSize = YES;
else
{
if (!fNewSize)
{
AstralUnionRect(&rUndo, &rUndo, &lpObject->rObject);
AstralUnionRect(&rUndo, &rUndo, &lpObject->rUndoObject);
}
}
}
else
{
AstralSetRectEmpty(&rTemp);
if (fUndoData)
AstralUnionRect(&rTemp, &rTemp, &lpObject->Pixmap.UndoRect);
if (fUndoAlpha)
AstralUnionRect(&rTemp, &rTemp,
&lpObject->lpAlpha->Pixmap.UndoRect);
if (rTemp.right >= rTemp.left)
{
if (!fNewSize)
{
OffsetRect(&rTemp, lpObject->rObject.left,
lpObject->rObject.top);
AstralUnionRect(&rUndo, &rUndo, &rTemp);
}
}
}
}
}
// now redisplay whatever changes are necessary for the undo
if (fNewSize)
{
SetupImagePalette(lpImage, NO, YES);
if (lpBase->Pixmap.UndoFrame)
{
if ((FrameXSize(lpBase->Pixmap.UndoFrame) ==
FrameXSize(lpBase->Pixmap.EditFrame)) &&
(FrameYSize(lpBase->Pixmap.UndoFrame) ==
FrameYSize(lpBase->Pixmap.EditFrame)))
fNewSize = NO;
}
if (fNewSize)
UpdateImageSize();
else
UpdateImageEx(lpImage, NULL, YES, YES, YES);
if ( Tool.hRibbon )
SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
}
else
{
if (rUndoMask.right >= rUndoMask.left)
{
File2DispRect(&rUndoMask, &rUndoMask);
AstralToWindowsRect(&rUndoMask);
InvalidateRect(lpImage->hWnd, NULL, NO);
}
if (rUndo.right >= rUndo.left)
AnimateUndo( &rUndo );
}
if (fUndoDelete)
if ( Tool.hRibbon )
SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
if (fSetupMiniViews)
SetupMiniViews(NULL, NO);
}
