static void ObjInitObject(LPOBJECT lpObject,
LPFRAME lpFrame,
LPMASK lpAlpha,
BOOL NoUndo)
/************************************************************************/
{
PixmapSetup(&lpObject->Pixmap, lpFrame, NoUndo);
lpObject->lpAlpha = lpAlpha;
lpObject->DataUndoType = 0;
lpObject->DataUndoNotRedo = YES;
lpObject->DataDirty = NO;
lpObject->AlphaUndoType = 0;
lpObject->AlphaUndoNotRedo = YES;
lpObject->AlphaDirty = NO;
lpObject->fBothDirty = NO;
lpObject->lpUndoAlpha = NULL;
AstralSetRectEmpty(&lpObject->rUndoObject);
lpObject->UndoResolution = 0;
lpObject->fUndoSelected = NO;
lpObject->fTransform = NO;
AstralSetRectEmpty(&lpObject->rTransform);
lpObject->fPasteIntoMask = NO;
lpObject->fUndoDeleted = NO;
lpObject->fUndoFailed = NoUndo;
lpObject->InitUndoType = 0;
lpObject->UndoColorMap = NULL;
lpObject->bLocked = NO;
lpObject->lpUndoText = NULL;
lpObject->lpText = NULL;
lpObject->dwObjectID = 0;
lpObject->szObjectName[0] = '\0';
}
LOCAL void ZoomBox_OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags)
/***********************************************************************/
{
BOOL fRButton;
POINT pt;
if ( !fCapture )
return;
fRButton = keyFlags & MK_RBUTTON;
if (!fSelection)
{
if (!IsOnImage(hWnd, x, y))
return;
if (fSelection = (abs(StartPoint.x-x) > SMALL_MOVEMENT ||
abs(StartPoint.y-y) > SMALL_MOVEMENT))
{
AstralUpdateWindow(hWnd);
AstralSetRectEmpty( &SelectRect );
StartSelection( hWnd, NULL, &SelectRect,
SL_BOX|SL_SPECIAL|SL_NOLIMIT, StartPoint, 0L );
}
}
if (fSelection)
{
pt.x = x; pt.y = y;
UpdateSelection( hWnd, NULL, &SelectRect, SL_BOX|SL_NOLIMIT,
pt, CONSTRAINASPECT, lAspectX, lAspectY, MOVEKEY||fRButton,FROMCENTER);
}
}
//=======================================================================
// Gets the max bounds for the poly list.
// If there are no polygons or poly list then the rect is empty.
//=======================================================================
BOOL PolyListGetBounds(LPCPolyList lpList, LPRECT lpRect)
//=======================================================================
{
AstralSetRectEmpty(lpRect);
if (lpList)
lpList->ForEach1((LPLISTPROC1)poly_get_bounds, (LONG)lpRect);
return(TRUE);
}
void CImage::GetGroupRect(LPOBJECT lpObject, LPRECT lpRect)
{
LPOBJECT lpNextObject;
AstralSetRectEmpty( lpRect );
lpNextObject = GetBase();
while( lpNextObject = GetSelObject( lpNextObject ) )
{
if( lpObject->wGroupID == lpNextObject->wGroupID )
AstralUnionRect( lpRect, lpRect, &lpNextObject->rObject );
}
}
BOOL CChromaMask::JoinChromaMask(LPIMAGE lpImage, LPRECT lpUpdateRect)
{
LPOBJECT lpBase;
LPMASK lpMask;
RECT rDummy;
RECT rMask;
BOOL fNewMask = NO;
BOOL fCreateMask = NO;
UNDO_TYPE Type;
AstralSetRectEmpty(lpUpdateRect);
if (ImgGetMask(lpImage))
Type = UT_ALPHA;
else
{
fNewMask = TRUE;
Type = UT_CREATEMASK;
}
// get mask, create one if one does not exist
lpMask = ImgGetMaskEx(lpImage, iMode==SHAPE_SUBTRACT ? OFF : ON,
Control.NoUndo, &fNewMask, lpUpdateRect);
if (!lpMask)
return(FALSE);
// if not new mask and we are allowed to create undo, initialize undo
lpBase = ImgGetBase(lpImage);
if (!ImgEditInit(lpImage, ET_OBJECT,Type, lpBase))
return(FALSE);
EnableMarqueeEx( lpImage, NO );
// add Chroma to mask
MaskAddChroma(lpImage, lpMask, &rMask, !fNewMask);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rMask);
// if using undo, indicate in-place editing has occurred
ImgEditedObject(lpImage, lpBase, IDS_CHROMA_APPLY, fNewMask ? NULL : &rMask);
// after subtractive masks we dont know area
if (iMode!=SHAPE_ADD)
MaskRectUpdate(lpMask, &rDummy);
// get area that needs to be redisplayed, may be larger
// than rUpdate because of slime
if (ImgGetMaskUpdateRect(lpImage, fNewMask, NO, &rMask))
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rMask);
EnableMarqueeEx(lpImage, YES);
return(TRUE);
}
BOOL CImage::GetFloatingObjectsRect( LPRECT lpRect )
{
LPOBJECT lpObject;
AstralSetRectEmpty( lpRect );
if ( !(lpObject = GetNextObject(GetBase(), YES, NO) ))
return( NO );
while ( lpObject )
{
AstralUnionRect( lpRect, lpRect, &lpObject->rObject );
lpObject = GetNextObject(lpObject, YES, NO);
}
return( YES );
}
BOOL CImage::GetSelObjectRect( LPRECT lpRect, BOOL bExcludeBase )
{
LPOBJECT lpObject;
BOOL bFoundOne;
AstralSetRectEmpty( lpRect );
bFoundOne = NO;
lpObject = ( bExcludeBase ? GetBase() : NULL );
while ( lpObject = GetSelObject(lpObject) )
{
AstralUnionRect( lpRect, lpRect, &lpObject->rObject );
bFoundOne = YES;
}
return( bFoundOne );
}
//=======================================================================
// Geta the bounding rect for all the points in the rect
//=======================================================================
void CPoly::GetBounds(LPRECT lpBounds)
//=======================================================================
{
int i;
AstralSetRectEmpty(lpBounds);
for (i=0; i<EntriesUsed;i++)
{
if (lpPoints[i].x == BEZIER_MARKER)
continue;
if (lpPoints[i].x < lpBounds->left)
lpBounds->left = lpPoints[i].x;
if (lpPoints[i].x > lpBounds->right)
lpBounds->right = lpPoints[i].x;
if (lpPoints[i].y < lpBounds->top)
lpBounds->top = lpPoints[i].y;
if (lpPoints[i].y > lpBounds->bottom)
lpBounds->bottom = lpPoints[i].y;
}
}
// Gets the current mask if any.
// If no mask exists then create one using fOn and fNoUndo.
// bCreated is TRUE if a new mask was created.
LPMASK CImage::GetMaskEx(BOOL fOn, BOOL fNoUndo, LPINT bCreated, LPRECT lpUpdateRect)
{
LPMASK lpMask;
LPFRAME lpFrame;
FRMTYPEINFO TypeInfo;
FRMDATATYPE FrameType = FDT_GRAYSCALE;
AstralSetRectEmpty(lpUpdateRect);
if (lpMask = GetMask())
{
if (bCreated)
*bCreated = FALSE;
return(lpMask);
}
lpFrame = GetBaseEditFrame();
FrameGetTypeInfo(lpFrame, &TypeInfo);
if (TypeInfo.DataType == FDT_LINEART && Mask.OneBitMask)
FrameType = FDT_LINEART;
if (!(lpMask = MaskCreate(NULL, FrameXSize(lpFrame),
FrameYSize(lpFrame),
fOn,
fNoUndo, FrameType)))
{
Message( IDS_EMEMALLOC );
return(NULL);
}
// sync up the resolution of the image data and the mask
// don't ever rely on the mask's resolution being correct
// cause other size can change the image data resolution
// without changing the mask's resolution. Also, there are
// other places the mask gets created without syncing up
// the resolution. I am doing it here so we can begin
// to track it correctly (Ted)
FrameSetResolution(AlphaGetEditFrame(lpMask), FrameResolution(lpFrame));
if (bCreated)
*bCreated = TRUE;
if (!Control.UseMaskAndObjects)
GetObjectMarqueeRect(this, lpUpdateRect);
SetMask(lpMask);
return(lpMask);
}
void ImgEditMaskUndo( LPIMAGE lpImage )
/***********************************************************************/
{
LPOBJECT lpBase;
LPMASK lpMask;
RECT rUndo;
lpBase = ImgGetBase(lpImage);
if (!lpBase->AlphaDirty)
return;
if (lpBase->fBothDirty)
return;
AstralSetRectEmpty(&rUndo);
if (ImgGetMask(lpImage) &&
lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
RemoveMaskMarquee(lpImage);
ImgGetMaskUpdateRect(lpImage, YES, NO, &rUndo);
}
ObjEditUndo(lpImage, lpBase, NO, YES);
if (lpMask = ImgGetMask(lpImage))
{
if (lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
RemoveMaskMarquee(lpImage);
ImgGetMaskUpdateRect(lpImage, YES, NO, &rUndo);
}
else
rUndo = lpMask->Pixmap.UndoRect;
}
if (rUndo.right >= rUndo.left)
{
OffsetRect(&rUndo, lpBase->rObject.left, lpBase->rObject.top);
File2DispRect(&rUndo, &rUndo);
AstralToWindowsRect(&rUndo);
InvalidateRect(lpImage->hWnd, NULL, NO);
}
}
void CImage::EditMaskUndo()
{
LPOBJECT lpBase;
LPMASK lpMask;
RECT rUndo;
lpBase = GetBase();
if (!lpBase->AlphaDirty)
return;
if (lpBase->fBothDirty)
return;
AstralSetRectEmpty(&rUndo);
if (GetMask() &&
lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
RemoveMaskMarquee(this);
GetMaskUpdateRect(YES, NO, &rUndo);
}
ObjEditUndo(lpBase, NO, YES);
if (lpMask = GetMask())
{
if (lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
RemoveMaskMarquee(this);
GetMaskUpdateRect(YES, NO, &rUndo);
}
else
rUndo = lpMask->Pixmap.UndoRect;
}
if (rUndo.right >= rUndo.left)
{
OffsetRect(&rUndo, lpBase->rObject.left, lpBase->rObject.top);
File2DispRect(GetActiveDoc(), &rUndo, &rUndo);
AstralToWindowsRect(&rUndo);
InvalidateRect(GetActiveDoc(), NULL, NO);
}
}
LOCAL STATUS_CODE ApplyMaps(LPIMAGE lpImage, LPMAPS lpMaps, ITEMID idDirty,
LPRECT lpUpdateRect, LPUPDATE_TYPE lpUpdateType)
/************************************************************************/
{
ENGINE Engine;
FRMTYPEINFO TypeInfo;
LPCOLORMAP lpColorMap;
STATUS_CODE StatusCode;
AstralSetRectEmpty(lpUpdateRect);
*lpUpdateType = UT_NONE;
ImgGetTypeInfo(lpImage, &TypeInfo);
if (TypeInfo.DataType == FDT_PALETTECOLOR)
{
lpColorMap = FrameCopyColorMap(TypeInfo.ColorMap);
if (!lpColorMap)
{
Message(IDS_EMEMALLOC);
return(SC_MEMERROR);
}
ApplyMaps24((LPTR)lpColorMap->RGBData, lpColorMap->NumEntries, lpMaps);
StatusCode = ApplyColorMap(lpImage, lpColorMap, FALSE, DT_NONE, idDirty);
FrameDestroyColorMap(lpColorMap);
if (StatusCode == SC_SUCCESS)
*lpUpdateType = UT_DATATYPE;
}
else
{
SetEngineDef(&Engine);
Engine.lpDataProc = (LPDATAPROC)ApplyMapsProc;
Engine.lpParam = lpMaps;
StatusCode = LineEngineSelObj(lpImage, &Engine, idDirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
*lpUpdateRect = Engine.rUpdate;
*lpUpdateType = UT_AREA;
}
}
return(StatusCode);
}
BOOL ZoomPaint( HWND hWnd )
/************************************************************************/
{
PAINTSTRUCT ps;
HDC hDC;
RECT rPaint;
LPDISPLAY lpDisplay;
LPIMAGE lpImage;
hDC = BeginPaint(hWnd, &ps);
lpDisplay = (LPDISPLAY)GetDisplayPtr(hWnd);
lpImage = (LPIMAGE)GetImagePtr (hWnd);
if (lpImage && lpDisplay)
{
rPaint = ps.rcPaint;
AstralToWindowsRect(&rPaint);
lpImage->Paint(hWnd,hDC,&rPaint,NULL); // will paint the invert box
AstralSetRectEmpty(&lpDisplay->UpdateRect);
}
EndPaint(hWnd, &ps);
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);
}
void CImage::EditUndo( BOOL fEditUndo, BOOL fMaskUndo,
LPUPDATE_TYPE lpUpdateType, LPRECT lpUpdateRect)
{
RECT rUndo, rUndoMask, rTemp;
LPOBJECT lpBase, lpObject, lpNext;
BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete, fColorMapChanged;
BOOL fUndoAlpha, fUndoData;
int nDeleted;
LPMASK lpMask;
EDIT_TARGET Target;
AstralSetRectEmpty(lpUpdateRect);
// Initialize things for updating the display
fNewSize = fSetupMiniViews = fUndoDelete = fColorMapChanged = NO;
AstralSetRectEmpty(&rUndo);
AstralSetRectEmpty(&rUndoMask);
// loop through objects doing undo
lpBase = GetBase();
lpObject = NULL;
// get the target of the last edit
Target = EditTarget;
while (lpObject = GetNextObject(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)
continue; // do no undo processing for a deleted object
// {
// if (Control.UndoObjects && !IsSelectedObject(lpBase))
// continue;
// }
else
// if target is not the entire image and we are in undo
// object mode and the object is not selected then
// skip this object
if (Target != ET_ALLOBJECTS && Control.UndoObjects && !IsSelectedObject(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 = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted)
++nDeleted;
else
if (lpNext->fDeleted && lpNext->fSelected)
{
fRemoveMarquee = YES;
break;
}
}
if (GetSelObject(NULL) == lpBase && !fRemoveMarquee)
{
if (CountObjects() - nDeleted <= 1)
fRemoveMarquee = YES;
}
if (fRemoveMarquee)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
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 (GetMask())
{
GetMaskMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
if (GetMaskUpdateRect(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)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
}
// Actually do the undo
ObjEditUndo(lpObject, fUndoData, fUndoAlpha);
// do a postprocess for undoing the mask
if ((lpMask = GetMask()) &&
(((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 (GetMaskUpdateRect(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 = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fDeleted || lpNext->fUndoDeleted)
AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject);
}
fSetupMiniViews = YES;
}
if (lpObject->DataUndoType & UT_COLORMAP)
fColorMapChanged = 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);
}
}
if( lpObject->DataUndoType & UT_OBJECTRECT )
{
AstralUnionRect( &rUndo, &rUndo, &lpObject->rObject );
AstralUnionRect( &rUndo, &rUndo, &lpObject->rUndoObject );
}
}
}
}
// now redisplay whatever changes are necessary for the undo
if (fColorMapChanged)
{
ImgColorMapChanged(this);
*lpUpdateType |= UT_DATATYPE;
}
if (fNewSize)
{
*lpUpdateType |= UT_DATATYPE;
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)
*lpUpdateType |= UT_SIZE;
else
{
int dx, dy;
GetInfo(&dx, &dy, NULL, NULL);
SetRect(lpUpdateRect, 0, 0, dx-1, dy-1);
}
}
else
{
if (!AstralIsRectEmpty(lpUpdateRect))
*lpUpdateType |= UT_ACTIVEAREA;
if (rUndoMask.right >= rUndoMask.left)
{
*lpUpdateType |= UT_ACTIVEAREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndoMask);
}
if (rUndo.right >= rUndo.left)
{
*lpUpdateType |= UT_AREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndo);
}
}
}
long DoCommand( HWND hWindow, WPARAM wParam, LPARAM lParam )
/***********************************************************************/
{
FNAME szFileName;
LPFRAME lpFrame;
LPOBJECT lpObject, lpBase;
RECT rect, rMask, rTemp, rAll;
HWND hWnd;
STRING szString;
int i, idFileType, x, y, dx, dy;
BOOL fDoZoom, bPrint, fHasZoom;
LPSTR lpszCmdLine;
HGLOBAL hMem;
ITEMID idDataType;
DWORD dwReturn;
int NewShape;
UINT wID;
SoundStartID( wParam, NO/*bLoop*/, NULL/*hInstance*/ );
/*
WIN16: ID = wParam
ctrl handle = LOWORD(lParam)
notify code = HIWORD(lParam)
WIN32: ID = LOWORD(wParam)
ctrl handle = lParam
notify code = HIWORD(wParam)
*/
#ifdef WIN32
wID = LOWORD(wParam);
#else
wID = wParam;
#endif
switch (wID)
{
case IDM_EXIT:
DeactivateTool();
PostMessage( hWndAstral, WM_CLOSE, 0, 0L);
Delay (750);
break;
case IDM_CLOSE:
DeactivateTool();
/* Check to see if the image needs to be saved */
if ( !ConfirmClose(NO,NO) )
break;
CloseImage( NO, lpImage ); // Close the active image
break;
case IDM_ABOUT:
/* Bring up the modal 'About' dialog box */
AstralDlg( NO|2, hInstAstral, hWindow, IDD_ABOUT, DlgAboutProc);
break;
case IDM_NEXTPAGE:
if ( !lpImage )
break;
DeactivateTool();
SendMessage( lpImage->hWnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0L );
break;
case IDM_NEW:
DeactivateTool();
SoundStartResource( "magic01", NO, NULL );
AstralCursor( IDC_WAIT );
New( Control.NewWidth, Control.NewHeight, Control.NewResolution,
Control.NewDepth );
AstralCursor( NULL );
break;
case IDM_OPEN:
DeactivateTool();
/* Bring up the modal 'File Open' box */
if ( !(dwReturn = DoOpenDlg( hWindow, IDD_OPEN,
Save.FileType, szFileName, NO )) )
break;
idFileType = LOWORD( dwReturn );
Save.FileType = idFileType;
PutDefaultInt( "FileType", idFileType - IDN_TIFF );
AstralImageLoad( idFileType, szFileName, MAYBE, YES );
break;
case IDM_ALTOPEN:
DeactivateTool();
// Command line sent from a second instance prior to it closing
/* If the caller passed in a file name, try to load it or print it */
if ( !(lpszCmdLine = (LPSTR)lParam) )
break;
HandleCommandLine( hWindow, lpszCmdLine, &bPrint );
break;
case IDM_SAVE:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVEAS:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVESPECIAL:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVEWALLPAPER:
DeactivateTool();
SaveWallpaper( "CRAYOLA", NO/*fTiled*/ );
break;
case IDM_REVERT:
if ( !lpImage )
break;
DeactivateTool();
if ( lpImage->fUntitled ) // If the picture doesn't have a name, get out
break;
if ( ImgChanged(lpImage) )
{
/* Check to see if its OK to trash changes */
if ( AstralOKCancel(IDS_OKTOREVERT,
(LPSTR)lpImage->CurFile) == IDCANCEL )
break;
}
lstrcpy( szFileName, lpImage->CurFile );
idFileType = lpImage->FileType;
fDoZoom = IsZoomed(lpImage->hWnd);
fHasZoom = Window.fHasZoom;
CloseImage( NO, lpImage ); // Close the active image
if ( !AstralImageLoad( idFileType, szFileName, fDoZoom, YES ) )
break;
break;
case IDM_RECALLIMAGE0:
case IDM_RECALLIMAGE1:
case IDM_RECALLIMAGE2:
case IDM_RECALLIMAGE3:
case IDM_RECALLIMAGE4:
case IDM_RECALLIMAGE5:
case IDM_RECALLIMAGE6:
case IDM_RECALLIMAGE7:
case IDM_RECALLIMAGE8:
case IDM_RECALLIMAGE9:
DeactivateTool();
GetMenuString( GetMenu(hWindow), wID,
szFileName, sizeof(szFileName), MF_BYCOMMAND );
i = 0;
while ( szFileName[i] && szFileName[i] != ' ' )
i++; // Skip over the numeric id in the string (3. junk.tif)
lstrcpy(szString, &szFileName[i+1]);
GetRecallFileName(szString);
AstralImageLoad( NULL, szString, MAYBE, YES );
break;
case IDM_PRINT:
if ( !lpImage )
break;
DeactivateTool();
AstralCursor( IDC_WAIT );
DoPrintSizeInits();
SoundStartResource( "print", YES, NULL );
PrintFile( hWindow, filename(lpImage->CurFile), YES, lpImage, NULL );
SoundStop();
AstralCursor( NULL );
break;
case IDM_PRINTSETUP:
/* Bring up the setup dialog box for the active printer */
AstralDlg( NO|2, hInstAstral, hWindow, IDD_PRINTSETUP,
DlgPrintSetupProc);
break;
case IDC_SOUND:
SoundToggle();
break;
case IDM_UNDO:
if ( !lpImage )
break;
DeactivateTool();
ImgEditUndo(lpImage, YES, NO);
break;
case IDM_CUT:
case IDM_COPY:
if ( !lpImage )
break;
DeactivateTool();
// Create the clipboard files from the image
ProgressBegin(1, IDS_PROGCOPY);
if ( !ImgWriteClipOut( lpImage, NULL, NULL, &rMask, lpImage->DataType ) )
{
ProgressEnd();
Message(IDS_EMEMALLOC);
break;
}
ProgressEnd();
OpenClipboard(hWindow);
EmptyClipboard();
// Passing a NULL data handle in SetClipboardData() means that
// the data will be requested in a WM_RENDERFORMAT message
hMem = ConstructObject( lpImage,
IsRectEmpty(&rMask)? (LPRECT)NULL : (LPRECT)&rMask );
if ( pOLE )
{ // Any data put on before Native will become staticly copied
SetClipboardData( pOLE->cfNative, NULL );
SetClipboardData( pOLE->cfOwnerLink, hMem );
}
SetClipboardData( CF_DIB, NULL );
if ( Control.DoPicture )
SetClipboardData( CF_METAFILEPICT, NULL );
if ( Control.DoBitmap )
SetClipboardData( CF_BITMAP, NULL );
SetClipboardData( CF_PALETTE, NULL );
SetClipboardData( Control.cfImage, NULL );
if ( pOLE && wID == IDM_COPY && !lpImage->fUntitled )
{ // ObjectLink is retrieved during a Paste Link...
SetClipboardData( pOLE->cfObjectLink, hMem );
}
CloseClipboard();
if ( wID == IDM_COPY )
break;
// else fall through to IDM_DELETE
case IDM_DELETE:
if ( !lpImage )
break;
{
COLORINFO ColorInfo;
DeactivateTool();
ColorInfo.gray = 255;
SetColorInfo( &ColorInfo, &ColorInfo, CS_GRAY );
TintFill( lpImage, &ColorInfo, 255, MM_NORMAL,
wID == IDM_CUT ? IDS_UNDOCUT : IDS_UNDODELETE );
}
break;
case IDM_PASTE:
if ( !lpImage )
break;
case IDM_PASTEASNEW:
if ( !OpenClipboard(hWndAstral) )
{
Message( IDS_ECLIPOPEN );
break;
}
if ( !IsClipboardFormatAvailable(CF_DIB) &&
!IsClipboardFormatAvailable(CF_BITMAP) &&
!IsClipboardFormatAvailable(Control.cfImage) )
{
Message( IDS_ECLIPOPEN );
CloseClipboard();
break;
}
CloseClipboard();
DeactivateTool();
// First put clipboard contents into a file(s)
AstralCursor(IDC_WAIT);
if ( !PasteFromClipboard( hWindow, (wID == IDM_PASTE) /*fNeedMask*/ ) )
{
AstralCursor(NULL);
Message(IDS_EMEMALLOC);
break;
}
if ( wID == IDM_PASTE )
{
ProgressBegin(1, IDS_PROGPASTECLIP);
TransformObjectsStart( YES/*fNewObject*/ );
if ( ImgCreateClipInObject( lpImage, NO ) )
;
ProgressEnd();
}
else
if ( wID == IDM_PASTEASNEW )
{
if ( lpFrame = AstralFrameLoad( Names.PasteImageFile, -1,
&idDataType, &idFileType) )
{
if ( NewImageWindow(
NULL, // lpOldFrame
NULL, // Name
lpFrame, // lpNewFrame
idFileType, // lpImage->FileType
idDataType, // lpImage->DataType
FALSE, // New view?
IMG_DOCUMENT, // lpImage->DocumentType
NULL, // lpImage->ImageName
MAYBE
) )
lpImage->fChanged = YES;
}
}
break;
case IDM_ESCAPE:
if (!lpImage)
break;
if (lpImage->hWnd == hZoomWindow)
break;
if ( Tool.bActive && Tool.lpToolProc )
DestroyProc( lpImage->hWnd, 1L );
break;
case IDM_SIZEUP:
case IDM_SIZEDOWN:
if (!Retouch.hBrush)
break;
SetFocus( hWindow ); // Take focus away from any controls
if ( Retouch.BrushShape == IDC_BRUSHCUSTOM )
break;
if ( wID == IDM_SIZEUP )
{
if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 ))
Retouch.BrushSize += 2;
else
Retouch.BrushSize++;
}
else
{
if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 ))
Retouch.BrushSize -= 2;
else
Retouch.BrushSize--;
}
if ( Retouch.BrushSize < 1 || Retouch.BrushSize > MAX_BRUSH_SIZE )
{
Retouch.BrushSize = bound( Retouch.BrushSize, 1,MAX_BRUSH_SIZE);
MessageBeep(0);
break;
}
if (lpImage)
DisplayBrush(0, 0, 0, OFF);
SetMgxBrushSize(Retouch.hBrush, Retouch.BrushSize);
if (lpImage && Window.hCursor == Window.hNullCursor)
DisplayBrush(lpImage->hWnd, 32767, 32767, ON);
if ( Tool.hRibbon )
SetSlide( Tool.hRibbon, IDC_BRUSHSIZE, Retouch.BrushSize );
break;
case IDM_SHAPEUP:
case IDM_SHAPEDOWN:
if (!Retouch.hBrush)
break;
SetFocus( hWindow ); // Take focus away from any controls
NewShape = Retouch.BrushShape;
if ( wID == IDM_SHAPEUP )
NewShape++;
else NewShape--;
if ( NewShape > IDC_BRUSHCUSTOM )
NewShape = IDC_BRUSHCIRCLE;
if ( NewShape < IDC_BRUSHCIRCLE )
NewShape = IDC_BRUSHCUSTOM;
if (lpImage)
DisplayBrush(0, 0, 0, OFF);
if (!SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush))
{
NewShape = IDC_BRUSHCIRCLE;
SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush);
}
Retouch.BrushShape = NewShape;
if (lpImage && Window.hCursor == Window.hNullCursor)
DisplayBrush(lpImage->hWnd, 32767, 32767, ON);
if ( Tool.hRibbon )
{
CheckComboItem( Tool.hRibbon, IDC_BRUSHSHAPE, IDC_BRUSHCIRCLE,
IDC_BRUSHCUSTOMNEW, Retouch.BrushShape );
SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
}
break;
case IDM_MOVEUP:
case IDM_MOVEDOWN:
case IDM_MOVELEFT:
case IDM_MOVERIGHT:
if (!lpImage)
break;
lpBase = ImgGetBase(lpImage);
if (ImgGetSelObject(lpImage, NULL) == lpBase)
break;
dx = dy = 0;
if (wID == IDM_MOVEUP)
--dy;
if (wID == IDM_MOVEDOWN)
++dy;
if (wID == IDM_MOVELEFT)
--dx;
if (wID == IDM_MOVERIGHT)
++dx;
lpObject = NULL;
while (lpObject = ImgGetSelObject(lpImage, lpObject))
{
rect = lpObject->rObject;
OffsetRect(&rect, dx, dy);
if (!AstralIntersectRect(&rTemp, &lpBase->rObject, &rect))
break;
}
if (lpObject)
break;
AstralSetRectEmpty(&rAll);
lpObject = NULL;
while (lpObject = ImgGetSelObject(lpImage, lpObject))
{
rect = lpObject->rObject;
OffsetRect(&lpObject->rObject, dx, dy);
AstralUnionRect(&rAll, &rAll, &lpObject->rObject);
if (!lpObject->Pixmap.fNewFrame &&
EqualRect(&rect, &lpObject->rUndoObject))
lpObject->rUndoObject = lpObject->rObject;
UpdateImage(&rect, TRUE);
UpdateImage(&lpObject->rObject, TRUE);
}
if (wID == IDM_MOVEUP)
{
x = (rAll.left + rAll.right)/2;
y = rAll.top;
}
else
if (wID == IDM_MOVEDOWN)
{
x = (rAll.left + rAll.right)/2;
y = rAll.bottom;
}
else
if (wID == IDM_MOVELEFT)
{
x = rAll.left;
y = (rAll.top + rAll.bottom)/2;
}
else
if (wID == IDM_MOVERIGHT)
{
x = rAll.right;
y = (rAll.top + rAll.bottom)/2;
}
File2Display(&x, &y);
AutoScroll(lpImage->hWnd, x, y);
AstralUpdateWindow(lpImage->hWnd);
DisplayInfo(-1, &rAll);
break;
case IDM_LASTTOOL:
DeactivateTool();
if ( Tool.idLast && (hWnd = AstralDlgGet(IDD_MAIN)) )
SendMessage( hWnd, WM_COMMAND, Tool.idLast, 2L);
break;
case IDM_PREF:
// prevent problems if running animations and they change
// the wave mix dll setting in preferences
StopAnimation();
AstralDlg( NO|2, hInstAstral, hWindow, IDD_PREF, DlgPrefProc );
break;
case IDC_VIEWLAST: // duplicate of function in the view ribbon
if ( !lpImage )
break;
RevertLastView();
break;
// case IDC_VIEWFULL: // duplicate of function in the view ribbon
// if ( !lpImage )
// break;
// AstralDlg( NO, hInstAstral, hWindow, IDD_VIEWFULL, DlgFullScreenViewProc );
// break;
case IDC_VIEWALL: // duplicate of function in the view ribbon
if ( !lpImage )
break;
ViewAll();
break;
case IDC_ZOOMIN: // duplicate of function in the view ribbon
if ( !lpImage )
break;
if (!lpImage->lpDisplay)
break;
if (!lpImage->lpDisplay->ViewPercentage)
break;
x = ( lpImage->lpDisplay->FileRect.left
+ lpImage->lpDisplay->FileRect.right ) / 2;
y = ( lpImage->lpDisplay->FileRect.top
+ lpImage->lpDisplay->FileRect.bottom ) / 2;
SaveLastView();
Zoom(x,y, +100, YES, ( View.ZoomWindow ^ CONTROL ) );
break;
case IDC_ZOOMOUT: // duplicate of function in the view ribbon
if ( !lpImage )
break;
if (!lpImage->lpDisplay)
break;
if (!lpImage->lpDisplay->ViewPercentage)
break;
x = ( lpImage->lpDisplay->FileRect.left
+ lpImage->lpDisplay->FileRect.right ) / 2;
y = ( lpImage->lpDisplay->FileRect.top
+ lpImage->lpDisplay->FileRect.bottom ) / 2;
SaveLastView();
Zoom(x,y, -100, YES,( View.ZoomWindow ^ CONTROL ) );
break;
case IDM_HELP:
Control.Hints = !Control.Hints;
PutDefInt (Control.Hints,Control.Hints);
break;
default:
return( FALSE );
}
return( TRUE );
}
void VignetteProc( HWND hWindow, UINT msg, int x, int y, UINT32 Option )
/************************************************************************/
{
RECT Rect;
BOOL fShift;
POINT pt;
static int Type, Style;
static BOOL fConstrain;
static RECT SelectRect;
int res;
FRMDATATYPE type;
LPIMAGE lpImage;
STRING szString;
GRADIENT_PARMS parms;
switch (msg)
{
case WM_CREATE: // The first mouse down message
if (!IsOnImage(hWindow, x, y))
break;
ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
{
AstralStrEx( IDC_TOOLNAMESTART+IDC_VIGNETTE, szString, sizeof(szString) );
Message(IDS_NOTWITHLINEART, (LPSTR)szString);
break;
}
AstralUpdateWindow(hWindow);
Tool.bActive = YES;
// SetMaskingState( x, y );
break;
case WM_LBUTTONDOWN:
Type = Vignette.Gradient;
fConstrain = ( Type == IDC_VIGSQUARE || Type == IDC_VIGCIRCLE );
AstralSetRectEmpty( &SelectRect );
if ( Type == IDC_VIGCIRCLE || Type == IDC_VIGELLIPSE )
Style = SL_ELLIPSE;
else
if ( Type == IDC_VIGRADIAL || Type == IDC_VIGLINEAR )
Style = SL_LINE;
else
Style = SL_BOX;
pt.x = x; pt.y = y;
StartSelection( hWindow, NULL, &SelectRect, Style | SL_SPECIAL,
pt, 0L );
break;
case WM_LBUTTONUP:
Tool.bActive = NO;
Rect = SelectRect; // make a copy before it gets ordered
EndSelection( hWindow, NULL, &SelectRect, Style, YES );
lpImage = (LPIMAGE)GetImagePtr ( hWindow );
res = FrameResolution(ImgGetBaseEditFrame(lpImage));
type = FrameType(ImgGetBaseEditFrame(lpImage));
parms.VigOpacity = Vignette.VigOpacity;
parms.VigMergeMode = Vignette.VigMergeMode;
parms.iBaseRes = res;
parms.x1 = Rect.left;
parms.y1 = Rect.top;
parms.x2 = Rect.right;
parms.y2 = Rect.bottom;
GetActiveColorFromType(type, &parms.StartColor);
GetAlternateColorFromType(type, &parms.EndColor);
parms.Gradient = Vignette.Gradient;
parms.RepeatCount = Vignette.RepeatCount;
parms.SoftTransition = Vignette.SoftTransition;
parms.Midpoint = Vignette.Midpoint;
parms.VigColorModel = Vignette.VigColorModel;
ProcessCommand(lpImage->lpCmdList, IDS_CMD_GRADIENT, &parms);
break;
case WM_MOUSEMOVE: // sent when ToolActive is on
fShift = SHIFT;
pt.x = x; pt.y = y;
UpdateSelection( hWindow, NULL, &SelectRect, Style,
pt, fConstrain^CONSTRAINASPECT, 1L, 1L,
MOVEKEY||Window.fRButtonDown, FROMCENTER);
break;
case WM_LBUTTONDBLCLK:
break;
case WM_DESTROY: // The cancel operation message
if (!Tool.bActive)
break;
Tool.bActive = NO;
EndSelection( hWindow, NULL, &SelectRect, Style, YES );
break;
}
}
CImage::CImage( ITEMID idDataType,
LPSTR lpFileName,
LPCMDLIST lpCommandList,
ITEMID idFileType,
int DocType,
LPSTR lpImageName)
{
fOwnedByClient = FALSE;
fRelease = FALSE;
// setup name of image, if no name passed in, setup an untitled image
if ( !lpFileName )
{
fChanged = TRUE;
fUntitled = TRUE;
GetUntitledName(CurFile);
}
else
{
fChanged = FALSE;
fUntitled = FALSE;
lstrcpy( CurFile, lpFileName );
}
if (lpImageName)
lstrcpy(ImageName, lpImageName);
else
ImageName[0] = '\0';
npix = 0;
nlin = 0;
FileType = GetPPFileType(CurFile);
if (!FileType)
FileType = Control.DefaultFileType;
DataType = idDataType;
UndoDataType = 0;
DocumentType = DocType;
Element = 0;
Compressed = FALSE;
UseObjectMarquee = Control.UseObjectMarquee;
MarqueeStatus = 0;
ObjList.lpHead = ObjList.lpTail = NULL;
AltObjList.lpHead = AltObjList.lpTail = NULL;
m_ViewMode = VM_NORMAL;
lpFastbitsPreview = NULL;
AstralSetRectEmpty(&rFastbitsGrid);
hPal = NULL;
nPaletteEntries = 0;
fNoSize = FALSE;
lpCmdList = lpCommandList;
iUndoCreateMaskDirty = 0;
fSaveNoSize = FALSE;
lpPaletteLUT = NULL;
PaletteType = PT_COLORPALETTE;
EditTarget = ET_OBJECT;
fDisableUndos = FALSE;
hLastBrush = NULL;
szLastBrushStyle[0] = '\0';
idLastBrush = 0;
dwObjectID = 0;
m_cmsXform = NULL;
SaveInfo.toRCS = SaveInfo.frRCS = 0;
lpClipObject = NULL;
m_bDoCmsGamma = FALSE;
fMaskCreate = FALSE;
fDiscardUndo = FALSE;
PtInfo.toRCS = PtInfo.frRCS = 0;
m_lpDispObject = NULL;
if (lpCmdList)
pServerDoc = lpCmdList->pDocument;
else
pServerDoc = NULL;
}
BOOL CImage::CombineObjects(BOOL fNoUndo, BOOL fCreateMask,
BOOL fForceIt, ITEMID idDirty, LPRECT lpUpdateRect)
{
LPOBJECT lpBase, lpObject;
int iWidth, iHeight, depth, y, iImageWidth, iImageHeight;
LPTR lpDataBuf, lpMaskPtr;
RECT rFloaters, rMask, rTemp;
BOOL fNewMask;
LPMASK lpMask;
UNDO_TYPE UndoType;
AstralSetRectEmpty(lpUpdateRect);
// get rectangle for all floating objects
if (!GetFloatingObjectsRect(&rFloaters))
return(FALSE);
// Get base object
lpBase = GetBase();
// get pixmap information
PixmapGetInfo(&lpBase->Pixmap, PMT_EDIT, &iImageWidth, &iImageHeight, &depth, NULL);
BoundRect(&rFloaters, 0, 0, iImageWidth-1, iImageHeight-1);
iWidth = RectWidth(&rFloaters);
iHeight = RectHeight(&rFloaters);
// allocate buffer for alpha channel combining
if (!(lpDataBuf = Alloc((long)iWidth*depth)))
{
Message(IDS_EMEMALLOC);
return(FALSE);
}
lpMask = NULL;
if (fCreateMask)
{
lpMask = GetMaskEx(OFF, Control.NoUndo, &fNewMask, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
// do it to it
ProgressBegin(lpMask != NULL ? 2 : 1, idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
if (!fNoUndo)
{
UndoType = UT_DATA|UT_DELETEOBJECTS;
if (lpMask)
{
if (fNewMask)
UndoType |= UT_CREATEMASK;
else
UndoType |= UT_ALPHA;
}
if (!ImgEditInit(this, ET_OBJECT, UndoType, lpBase))
{
if (!fForceIt)
{
ProgressEnd();
FreeUp(lpDataBuf);
return(FALSE);
}
}
}
// do it to it
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
ImgGetLine(this, NULL, rFloaters.left, y, iWidth, lpDataBuf);
PixmapWrite(&lpBase->Pixmap, PMT_EDIT, rFloaters.left, y, iWidth,
lpDataBuf, iWidth);
}
ProgressEnd();
if (lpMask && (lpObject = GetNextObject(lpBase, YES, NO)))
{
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
lpMaskPtr = PixmapPtr(&lpMask->Pixmap, PMT_EDIT, rFloaters.left,
y, YES);
if (!lpMaskPtr)
continue;
ImgMaskLoad(this, lpObject, NULL,
rFloaters.left, y, iWidth, lpDataBuf, NO,
CR_OR, 0, 0);
CombineData(lpDataBuf, lpMaskPtr, iWidth, NO, CR_OR);
}
MaskRectUpdate(lpMask, &rMask);
ProgressEnd();
}
FreeUp(lpDataBuf);
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
lpObject = lpBase;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// always let undo stuff initialize this
// lpObject->fUndoDeleted = NO;
lpObject->fDeleted = YES;
}
//DeleteObjects((LPOBJECT)lpBase->lpNext, NO);
if (!fNoUndo)
ImgEditedObject(this, lpBase, idDirty, &rFloaters);
else
fChanged = YES;
//if ( Tool.hRibbon )
// SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
ProgressEnd();
//SetupMiniViews(NULL, NO);
return(TRUE);
}
//************************************************************************
LOCAL STATUS_CODE ApplyCalibration(
LPIMAGE lpImage,
ITEMID dirty,
LPSTR lpScanMap,
LPSTR lpPrintMap,
LPRECT lpUpdateRect,
LPUPDATE_TYPE lpUpdateType)
//************************************************************************
{
FNAME szFileName;
ENGINE Engine;
LPCALMAPS lpMaps;
BOOL fScanMap, fPrintMap;
FRMTYPEINFO TypeInfo;
LPCOLORMAP lpColorMap;
STATUS_CODE StatusCode;
int i;
ASSERT(lpImage);
AstralSetRectEmpty(lpUpdateRect);
*lpUpdateType = UT_NONE;
ImgGetTypeInfo(lpImage, &TypeInfo);
lpMaps = (LPCALMAPS)Alloc(sizeof(CALMAPS));
if (!lpMaps)
{
Message(IDS_EMEMALLOC);
return(SC_MEMERROR);
}
for (i = 0; i < CALSCAN_MAPS; ++i)
ResetMap( &lpMaps->ScanMap[i], CALPOINTS, NO );
if (fScanMap = (lstrlen(lpScanMap) != 0))
{
if ( LookupExtFileN( lpScanMap, szFileName, IDN_SCANMAP, NO ) )
{
// Remember that the maps load in XRGB order
if (!LoadMap( &lpMaps->ScanMap[CALSCAN_GRAY],
&lpMaps->ScanMap[CALSCAN_RED],
&lpMaps->ScanMap[CALSCAN_GREEN],
&lpMaps->ScanMap[CALSCAN_BLUE],
szFileName ))
{
FreeUp(lpMaps);
return(SC_READERROR);
}
if (TypeInfo.DataType == FDT_CMYKCOLOR)
{
// make maps work on cmyk
for (i = 0; i < CALSCAN_MAPS; ++i)
ReverseMap(&lpMaps->ScanMap[i], FALSE);
}
}
else
{
fScanMap = NO;
}
}
for (i = 0; i < CAL_MAPS; ++i)
ResetMap( &lpMaps->PrintMap[i], CALPOINTS, NO );
if (fPrintMap = (lstrlen(lpPrintMap) != 0))
{
if ( LookupExtFileN( lpPrintMap, szFileName, IDN_CALMAP, NO ) )
{
// Remember that the maps load in MCMYK order
if (!LoadCalMap( &lpMaps->PrintMap[CAL_MASTER],
&lpMaps->PrintMap[CAL_CYAN],
&lpMaps->PrintMap[CAL_MAGENTA],
&lpMaps->PrintMap[CAL_YELLOW],
&lpMaps->PrintMap[CAL_BLACK],
szFileName ))
{
FreeUp(lpMaps);
return(SC_READERROR);
}
if (TypeInfo.DataType != FDT_CMYKCOLOR)
{
// make maps work on rgb
for (i = 0; i < CAL_MAPS; ++i)
ReverseMap(&lpMaps->PrintMap[i], FALSE);
}
}
else
{
fPrintMap = NO;
lpPrintMap = NULL;
}
}
if (!fScanMap && !fPrintMap)
{
FreeUp(lpMaps);
return(SC_SUCCESS); // user selected no maps???
}
switch (TypeInfo.DataType)
{
case FDT_LINEART:
case FDT_GRAYSCALE:
MakeFloatMap(&lpMaps->ScanMap[CALSCAN_GRAY], lpMaps->CalPnts);
MakeFloatMap(&lpMaps->PrintMap[CAL_BLACK], lpMaps->TmpPnts);
MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts);
MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[0]);
break;
case FDT_CMYKCOLOR:
for (i = 0; i < 4; ++i)
{
if (i == 3) // black
MakeFloatMap(&lpMaps->ScanMap[CALSCAN_GRAY], lpMaps->CalPnts);
else
MakeFloatMap(&lpMaps->ScanMap[CALSCAN_RED+i], lpMaps->CalPnts);
MakeFloatMap(&lpMaps->PrintMap[CAL_MASTER], lpMaps->TmpPnts);
MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts);
MakeFloatMap(&lpMaps->PrintMap[CAL_CYAN+i], lpMaps->TmpPnts);
MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts);
MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[i]);
}
break;
default:
case FDT_RGBCOLOR:
case FDT_PALETTECOLOR:
for (i = 0; i < 3; ++i)
{
MakeFloatMap(&lpMaps->ScanMap[CALSCAN_RED+i], lpMaps->CalPnts);
MakeFloatMap(&lpMaps->PrintMap[CAL_MASTER], lpMaps->TmpPnts);
MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts);
MakeFloatMap(&lpMaps->PrintMap[CAL_CYAN+i], lpMaps->TmpPnts);
MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts);
MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[i]);
}
break;
}
ImgGetTypeInfo(lpImage, &TypeInfo);
if (TypeInfo.DataType == FDT_PALETTECOLOR)
{
lpColorMap = FrameCopyColorMap(TypeInfo.ColorMap);
if (!lpColorMap)
{
Message(IDS_EMEMALLOC);
return(SC_MEMERROR);
}
LineCalMapProc(0, 0, lpColorMap->NumEntries-1,
(LPTR)lpColorMap->RGBData,
(LPTR)lpColorMap->RGBData,
3,
lpMaps);
StatusCode = ApplyColorMap(lpImage, lpColorMap, FALSE, DT_NONE, dirty);
FrameDestroyColorMap(lpColorMap);
if (StatusCode == SC_SUCCESS)
*lpUpdateType = UT_DATATYPE;
}
else
{
SetEngineDef(&Engine);
Engine.lpDataProc = (LPDATAPROC)LineCalMapProc;
Engine.lpParam = lpMaps;
StatusCode = LineEngineSelObj(lpImage, &Engine, dirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
*lpUpdateRect = Engine.rUpdate;
*lpUpdateType = UT_AREA;
}
}
FreeUp(lpMaps);
return(StatusCode);
}
