void ImgEditedObjectFrame(LPIMAGE lpImage, LPOBJECT lpObject, int iDirty,
LPRECT lpEditRect,
LPFRAME lpDataFrame, LPFRAME lpAlphaFrame)
/***********************************************************************/
{
LPALPHA lpAlpha;
BOOL fEditedData, fEditedAlpha, fBase;
fBase = (lpObject == ImgGetBase(lpImage));
fEditedData = (lpObject->InitUndoType & UT_DATAUNDO) != 0;
fEditedAlpha = (lpObject->InitUndoType & UT_ALPHAUNDO) != 0;
if (lpEditRect)
OffsetRect(lpEditRect, -lpObject->rObject.left, -lpObject->rObject.top);
lpAlpha = lpObject->lpAlpha;
if (fEditedData)
{
lpObject->fChanged = YES;
if (!Control.NoUndo && !lpObject->fUndoFailed)
lpObject->DataDirty = iDirty;
if (lpDataFrame)
{
PixmapNewFrame(&lpObject->Pixmap, lpDataFrame, lpEditRect, Control.UseApply);
if (lpObject == ImgGetBase(lpImage))
{
lpImage->npix = FrameXSize(lpDataFrame);
lpImage->nlin = FrameYSize(lpDataFrame);
}
}
}
if (fEditedAlpha)
{
if (lpObject != ImgGetBase(lpImage))
lpObject->fChanged = YES;
if (!Control.NoUndo && (!fBase || Control.UndoMasks) &&
!lpObject->fUndoFailed)
lpObject->AlphaDirty = iDirty;
if (lpAlpha && lpAlphaFrame)
PixmapNewFrame(&lpAlpha->Pixmap, lpAlphaFrame, lpEditRect, Control.UseApply);
}
if (!Control.NoUndo && !lpObject->fUndoFailed && !lpObject->fBothDirty)
lpObject->fBothDirty = fEditedData && fEditedAlpha;
if (lpEditRect)
OffsetRect(lpEditRect, lpObject->rObject.left, lpObject->rObject.top);
}
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;
}
void ImgEditedObject(LPIMAGE lpImage, LPOBJECT lpObject, int iDirty, LPRECT lpEditRect)
/***********************************************************************/
{
LPALPHA lpAlpha;
BOOL fEditedData, fEditedAlpha, fBase;
fBase = (lpObject == ImgGetBase(lpImage));
fEditedData = (lpObject->InitUndoType & UT_DATAUNDO) != 0;
fEditedAlpha = (lpObject->InitUndoType & UT_ALPHAUNDO) != 0;
if (lpEditRect)
OffsetRect(lpEditRect, -lpObject->rObject.left, -lpObject->rObject.top);
lpAlpha = lpObject->lpAlpha;
if (fEditedData)
{
lpObject->fChanged = YES;
if (!Control.NoUndo && !lpObject->fUndoFailed)
{
lpObject->DataDirty = iDirty;
if (lpEditRect)
PixmapAddUndoArea(&lpObject->Pixmap, lpEditRect);
}
}
if (fEditedAlpha)
{
if (lpObject != ImgGetBase(lpImage))
lpObject->fChanged = YES;
if (!Control.NoUndo && (!fBase || Control.UndoMasks) &&
!lpObject->fUndoFailed)
{
lpObject->AlphaDirty = iDirty;
if (lpEditRect && lpAlpha)
PixmapAddUndoArea(&lpAlpha->Pixmap, lpEditRect);
}
}
if (!Control.NoUndo && !lpObject->fUndoFailed && !lpObject->fBothDirty)
lpObject->fBothDirty = fEditedData && fEditedAlpha;
if (lpEditRect)
OffsetRect(lpEditRect, lpObject->rObject.left, lpObject->rObject.top);
}
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 PosObjects( LPIMAGE lpImage, LPPOSOBJECTS_PARMS lpPosParms )
/************************************************************************/
{
RECT bRect, uRect;
LPOBJECT lpObject;
int res;
int x,y;
if( !( lpImage ) )
return( FALSE );
if( !( lpObject = ImgGetBase( lpImage ) ) )
return( FALSE );
ImgEditInit( lpImage, ET_SELOBJECTS, UT_OBJECTRECT, lpObject );
ImgGetInfoEx(lpImage, NULL, NULL, NULL, NULL, &res);
x = lpPosParms->XOffset;
y = lpPosParms->YOffset;
ResConvertUL(lpPosParms->iBaseRes, res, &x, &y);
ImgGetSelObjectRect( lpImage, &bRect, YES );
x -= bRect.left;
y -= bRect.top;
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
{
if( lpObject->wGroupID )
{
if( !( IsGroupLocked( lpObject->wGroupID ) ) )
{
ImgEditedObject( lpImage, lpObject, IDS_UNDOOBJPOS, NULL );
OffsetRect( &lpObject->rObject, x, y);
}
}
else if (!lpObject->bLocked)
{
ImgEditedObject( lpImage, lpObject, IDS_UNDOOBJPOS, NULL );
OffsetRect( &lpObject->rObject, x, y);
}
}
ImgGetSelObjectRect( lpImage, &uRect, YES );
AstralUnionRect( &uRect, &uRect, &bRect );
UpdateImage( lpImage, &uRect, YES );
return( TRUE );
}
void DoReset(HWND hDlg, LPALIGNOBJECTS_PARMS lpAlignParms)
{
RECT uRect;
LPIMAGE lpImage = GetActiveImage();
LPRECT pRect;
LPOBJECT lpObject;
if(!lpImage)
return;
HWND hWnd = GetDlgItem(hDlg, IDC_ALIGN_GRID);
int x,y,i, wind;
RECT cRect;
for( i = 0, wind = GW_CHILD; i < ALIGN_NUM_OBJECTS; i++, wind = GW_HWNDNEXT )
{
hWnd = GetWindow( hWnd, wind );
GetClientRect( hWnd, &cRect );
cRect.right -= 1;
cRect.bottom -= 1;
ShowWindow( hWnd, SW_HIDE );
x = InitPos[i].x - cRect.left;
y = InitPos[i].y - cRect.top;
OffsetRect( &cRect, x, y);
MoveWindow( hWnd, cRect.left, cRect.top, RectWidth( &cRect ),
RectHeight( &cRect ), TRUE );
UpdateWindow( GetDlgItem( hDlg, IDC_ALIGN_GRID ) );
ShowWindow( hWnd, SW_SHOWNA );
}
lpAlignParms->HorzAlign = HA_NONE;
lpAlignParms->VertAlign = VA_NONE;
if( lpAlignParms->bPreview )
{
pRect = lpAlignParms->lpRect;
if( !( lpObject = ImgGetBase(lpImage)))
return;
while ( lpObject = ImgGetSelObject( lpImage, lpObject) )
{
AstralUnionRect(&uRect, &uRect, &lpObject->rObject);
lpObject->rObject = *pRect++;
}
AlignObjects( GetActiveImage(), lpAlignParms );
}
EnableWindow( GetDlgItem( hDlg, IDC_PREVIEW ), TRUE );
lpAlignParms->bPreview = FALSE;
UpdateImage(lpImage, &uRect, YES);
}
LOCAL BOOL size_image(LPIMAGE lpImage, LFIXED Width , LFIXED Height,
int Resolution, BOOL bSmartSize)
{
int pix, lin, res;
LPFRAME lpDataFrame;
LPFRAME lpAlphaFrame;
LPOBJECT lpBase;
LPALPHA lpAlpha;
RECT rAlpha;
if (!lpImage)
return(FALSE);
lpBase = ImgGetBase(lpImage);
lpAlpha = lpBase->lpAlpha;
res = Resolution;
ProgressBegin(1, 0);
pix = FMUL( res, Width );
lin = FMUL( res, Height );
lpAlphaFrame = NULL;
if (lpDataFrame = SizeFrame(lpBase->Pixmap.EditFrame, pix, lin, res,
bSmartSize))
{
if (lpAlpha)
lpAlphaFrame = SizeFrame(lpAlpha->Pixmap.EditFrame, pix, lin,
res, bSmartSize);
}
if ( !lpDataFrame || (lpAlpha && !lpAlphaFrame))
{
if (lpDataFrame)
FrameClose(lpDataFrame);
if (lpAlphaFrame)
FrameClose(lpAlphaFrame);
ProgressEnd();
return( FALSE );
}
lpBase->rObject.right = FrameXSize(lpDataFrame)-1;
lpBase->rObject.bottom = FrameYSize(lpDataFrame)-1;
if (lpAlpha)
MaskRectUpdate(lpAlpha, &rAlpha);
ProgressEnd();
return( TRUE );
}
BOOL IsGroupLocked( WORD wGroupID )
/************************************************************************/
{
LPOBJECT lpObject;
LPIMAGE lpImage;
lpImage = GetActiveImage();
lpObject = ImgGetBase( lpImage );
while( lpObject = ImgGetSelObject( lpImage, lpObject ) )
{
if( lpObject->wGroupID == wGroupID && lpObject->bLocked )
return( TRUE );
}
return( FALSE );
}
BOOL UnGroupObjects(LPIMAGE lpImage, LPCMD_PARMS lpCmdParms)
{
LPOBJECT lpObject = NULL;
if( !( lpImage ) )
return( FALSE );
if( !( lpObject = ImgGetBase( lpImage ) ) )
return( FALSE );
ImgEditInit(lpImage, ET_SELOBJECTS, UT_GROUPOBJECTS, lpObject );
while (lpObject = ImgGetSelObject(lpImage, lpObject))
{
ImgEditedObject( lpImage, lpObject, IDS_UNDOUNGROUPOBJ, NULL );
lpObject->wGroupID = 0;
}
return(TRUE);
}
void CChromaMask::MaskAddChroma(LPIMAGE lpImage, LPMASK lpMask, LPRECT lpRect, BOOL MaskExist)
{
int dx, dy, i, depth;
LPTR lpAlphaLine;
LPTR lpLine;
LPOBJECT lpBase = ImgGetBase(lpImage);
int top = -1;
int bottom = 0;
FRMTYPEINFO TypeInfo;
ProgressBegin(1,PROGRESS_ID(IDS_CHROMA_APPLY));
PixmapGetInfo(&lpMask->Pixmap, PMT_EDIT, &dx, &dy, NULL, NULL);
ImgGetTypeInfo(lpImage, &TypeInfo);
if (!(depth = FrameDepth(ObjGetEditFrame(lpBase))))
depth = 1; // never worry about lineart
xExtL = 10000;
xExtR = 0;
lpLine = Alloc((long)dx*depth);
for (i = 0; i < dy; ++i)
{
AstralClockCursor(i, dy, NO);
Dirty = FALSE;
lpAlphaLine = PixmapPtr( &lpMask->Pixmap, PMT_EDIT, 0, i, YES);
if (Delete)
clr(lpAlphaLine, dx);
ImgGetLine(lpImage, lpBase, 0, i, dx, lpLine, NULL);
ChromaProc(dx, TypeInfo, lpLine, lpAlphaLine, MaskExist);
if (Dirty)
{
if (top == -1)
top = i;
if (i > bottom)
bottom = i;
}
}
lpRect->left = xExtL;
lpRect->right = xExtR;
lpRect->top = top;
lpRect->bottom = bottom;
FreeUp(lpLine);
ProgressEnd();
}
BOOL UnLockObjects( LPIMAGE lpImage, LPCMD_PARMS lpCmdParms )
/************************************************************************/
{
LPOBJECT lpObject;
if( !( lpImage ) )
return( FALSE );
if( !( lpObject = ImgGetBase( lpImage ) ) )
return( FALSE );
ImgEditInit( lpImage, ET_SELOBJECTS, UT_LOCKOBJECTS, lpObject );
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
{
ImgEditedObject( lpImage, lpObject, IDS_UNDOOBJUNLOCK, NULL );
lpObject->bLocked = NO;
}
return( TRUE );
}
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 LoadPuzzleImage(HWND hWnd)
{
char szTemp[MAX_PATH];
char szFname[MAX_PATH];
BOOL bLoad;
HWND hImageCtrl = GetDlgItem(hWnd, IDC_PUZZLE_IMAGE);
if (hImageCtrl)
{
lstrcpy(szTemp, GetString (IDS_PUZZLE, NULL));
wsprintf(szFname, szTemp, iHardness);
PathCat(szPreview,Control.PouchPath,szFname);
bLoad = AstralImageLoad(0, szPreview, TRUE, FALSE);
if (bLoad && lpImage)
{
// set in the image and tool proc
SetWindowLong(hImageCtrl, GWL_IMAGE,
(long) ImgGetBase (lpImage));
SetWindowLong(hImageCtrl, GWL_IMAGE_TOOLPROC,
(long) PuzzleProc);
ShowWindow(hImageCtrl, SW_SHOW);
AstralControlPaint(hWnd, IDC_PUZZLE_IMAGE);
}
}
}
BOOL WINPROC EXPORT DlgRoomMazes (HWND hWnd,UINT wMsg,WPARAM wParam,LPARAM lParam)
{
BOOL bHandled = TRUE;
char szTemp[MAX_PATH];
HWND hCtl;
switch (wMsg)
{
case WM_COMMAND:
switch (wParam)
{
case HS_COVER:
StopAnimation();
ShowCoverAnimatedButtons(hWnd, TRUE);
hCtl = GetDlgItem (hWnd,IDC_HIDDEN_IMAGE);
ShowWindow (hCtl,SW_HIDE);
if (idCurrentRoom == RM_MAILMAZE)
{
hCtl = GetDlgItem (hWnd,HS_LOGO_MAILMAZE);
ShowWindow (hCtl,SW_SHOW);
hCtl = GetDlgItem (hWnd,HS_XTRA_MAILMAZE);
ShowWindow (hCtl,SW_HIDE);
hCtl = GetDlgItem (hWnd,HS_RESTART);
ShowWindow (hCtl,SW_HIDE);
}
else if (idCurrentRoom == RM_MAZES)
{
hCtl = GetDlgItem (hWnd,HS_LOGO_MAZES);
ShowWindow (hCtl,SW_SHOW);
hCtl = GetDlgItem (hWnd,HS_XTRA_MAZES);
ShowWindow (hCtl,SW_HIDE);
hCtl = GetDlgItem (hWnd,HS_RESTART);
ShowWindow (hCtl,SW_HIDE);
}
bHandled = FALSE;
break;
case HS_TAB1:
case HS_TAB2:
case HS_TAB3:
case HS_TAB4:
case HS_TAB5:
case HS_TAB6:
case HS_TAB7:
case HS_TAB8:
StopAnimation();
ShowCoverAnimatedButtons(hWnd, FALSE);
bTrack = FALSE;
if (idCurrentRoom == RM_MAILMAZE)
wsprintf (szTemp,GetString (IDS_MAILMAZE,NULL),wParam - HS_TAB1 + 1);
else if (idCurrentRoom == RM_MAZES)
wsprintf (szTemp,GetString (IDS_MAZES,NULL),wParam - HS_TAB1 + 1);
PathCat (szPreview,Control.PouchPath,szTemp);
AstralImageLoad (IDN_ART,szPreview,MAYBE,NO);
if (lpImage)
{
bShowSolution = bSolved = FALSE;
ImgSetPixelProc (MazePixelProc);
hCtl = GetDlgItem (hWnd,IDC_HIDDEN_IMAGE);
SetWindowLong (hCtl,GWL_IMAGE,(long) ImgGetBase (lpImage));
SetWindowLong (hCtl,GWL_IMAGE_TOOLPROC,(long)MazeToolProc);
ShowWindow (hCtl,SW_SHOW);
InvalidateRect (hCtl,NULL,FALSE);
if (idCurrentRoom == RM_MAILMAZE)
{
hCtl = GetDlgItem (hWnd,HS_LOGO_MAILMAZE);
ShowWindow (hCtl,SW_HIDE);
hCtl = GetDlgItem (hWnd,HS_XTRA_MAILMAZE);
ShowWindow (hCtl,SW_SHOW);
hCtl = GetDlgItem (hWnd,HS_RESTART);
ShowWindow (hCtl,SW_SHOW);
}
else if (idCurrentRoom == RM_MAZES)
{
hCtl = GetDlgItem (hWnd,HS_LOGO_MAZES);
ShowWindow (hCtl,SW_HIDE);
hCtl = GetDlgItem (hWnd,HS_XTRA_MAZES);
ShowWindow (hCtl,SW_SHOW);
hCtl = GetDlgItem (hWnd,HS_RESTART);
ShowWindow (hCtl,SW_SHOW);
}
bHandled = FALSE;
}
#ifdef STUDIO
SoundStartID(HS_XTRA_MAILMAZE, FALSE, 0);
#else
SoundStartID(HS_XTRA_MAZES, FALSE, 0);
#endif
break;
case HS_COLORME:
StopAnimation();
GoPaintApp (hWnd,szPreview);
break;
case HS_SHOWME:
case HS_RESTART:
bTrack = FALSE;
bShowSolution = (wParam == HS_SHOWME);
hCtl = GetDlgItem (hWnd,IDC_HIDDEN_IMAGE);
StopAnimation();
InvalidateRect (hCtl,NULL,FALSE);
UpdateWindow (hCtl);
if (wParam == HS_SHOWME)
StartAnimation(hCtl);
break;
default:
bHandled = FALSE;
}
break;
case WM_INITDIALOG:
hMazePen = CreatePen (PS_SOLID,3,RGB (0,0,255));
bHandled = FALSE;
break;
case WM_DESTROY:
StopAnimation();
ImgSetPixelProc (NULL);
if (hMazePen)
{
DeleteObject (hMazePen);
hMazePen = 0;
}
bHandled = FALSE;
break;
default:
bHandled = FALSE;
}
if (!bHandled)
bHandled = DefRoomProc (hWnd,wMsg,wParam,lParam);
return bHandled;
}
LOCAL BOOL FullScreenView_OnInitDialog(HWND hDlg, HWND hWndFocus, LPARAM lParam)
{
CPPMDIChildWnd *pMDIChild;
HWND hMDIWnd;
RECT ClientRect;
int npix, nlin, cx, cy, dx, dy;
HWND hControl, hMDIChild, hView;
LPOBJECT lpBase;
LPFRAME lpFrame;
// Make the window as big as the screen
dx = GetSystemMetrics( SM_CXSCREEN );
dy = GetSystemMetrics( SM_CYSCREEN );
MoveWindow( hDlg, 0, 0, dx, dy, NO );
// Compute the center of the window
GetClientRect( hDlg, &ClientRect );
cx = ( ClientRect.right + ClientRect.left ) / 2;
cy = ( ClientRect.bottom + ClientRect.top ) / 2;
// Link all of the images to image controls
hControl = GetDlgItem( hDlg, IDC_VIEWFULL );
CServerView *pView = PictPubApp.GetActiveView();
BOOL bInplaceActive = (pView && pView->GetDocument()->IsInPlaceActive());
if (bInplaceActive)
{
hMDIChild = pView->GetParentFrame()->GetSafeHwnd();
hView = pView->GetSafeHwnd();
}
else
{
pMDIChild = (CPPMDIChildWnd*)((CMDIFrame*)PictPubApp.m_pMainWnd)->MDIGetActive();
hMDIWnd = pMDIChild->GetSafeHwnd();
if (hMDIWnd)
hView = pMDIChild->GetActiveView()->GetSafeHwnd();
else
hView = NULL;
}
while ( hView )
{
lpBase = ImgGetBase((LPIMAGE)GetImagePtr(hView));
if ( !lpBase || !hControl )
break;
lpFrame = ObjGetEditFrame(lpBase);
// Link the frame to the image control
SetWindowLong( hControl, GWL_IMAGE, (long)lpBase );
// The destination size can be no bigger the the screen
npix = FrameXSize(lpFrame);
nlin = FrameYSize(lpFrame);
if ( npix > dx || nlin > dy )
{
npix = dx;
nlin = dy;
ScaleToFit( &npix, &nlin,
FrameXSize(lpFrame), FrameYSize(lpFrame));
}
// Position the control in the center of the window
ClientRect.left = cx - npix/2;
ClientRect.right = ClientRect.left + npix;
ClientRect.top = cy - nlin/2;
ClientRect.bottom = ClientRect.top + nlin;
MoveWindow( hControl,
ClientRect.left, ClientRect.top, // New position
RectWidth( &ClientRect ),
RectHeight( &ClientRect ), // New size
NO /* No repaint*/ );
if (bInplaceActive)
break;
// Check to see if these get destroyed when the window does
do
{
hView = NULL;
if (hMDIWnd = GetWindow( hMDIWnd, GW_HWNDNEXT ))
{
if ((CWnd::FromHandle(hMDIWnd))->
IsKindOf(RUNTIME_CLASS(CPPMDIChildWnd)))
hView = ((CPPMDIChildWnd*)CWnd::FromHandle(hMDIWnd))->
GetActiveView()->GetSafeHwnd();
}
} while (hMDIWnd && !hView);
if (!hView)
break;
// Get another image control
hControl = CopyWindow( hControl );
}
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);
}
BOOL ConvertImage(LPIMAGE lpImage, LPCONVERT_PARMS lpParms)
/***********************************************************************/
{
BOOL fRet = FALSE;
LPFRAME lpDstFrame, lpBaseFrame;
LPOBJECT lpBase, lpObject;
BOOL fError, fOptimize, fProgressSet;
INTERNAL_DATA data;
int inDepth, iMaxWidth, nColors, i;
LPCOLORMAP lpColorMap;
LPRGB lpRGB;
FRMTYPEINFO InTypeInfo, OutTypeInfo;
CFrameTypeConvert TypeConvert;
DITHER_TYPE DitherType = DT_DEFAULT;
if (ImgInMaskEditMode(lpImage))
return(TRUE);
lpColorMap = NULL;
lpBase = ImgGetBase(lpImage);
lpBaseFrame = ObjGetEditFrame(lpBase);
inDepth = FrameDepth(lpBaseFrame);
OutTypeInfo = lpParms->cmsInfo.dst;
FrameGetTypeInfo(lpBaseFrame, &InTypeInfo);
// are we try to convert to a color managed image?
if (Control.CMSEnabled && IsDstPTSelected(&OutTypeInfo.ptInfo))
{
// see if our image already has a color managed source
if (!IsSrcPTSelected(&InTypeInfo.ptInfo))
{
// nope, see if the source passed in is valid for this image
if (IsSrcPTSelected(&lpParms->cmsInfo.src.ptInfo) &&
(lpParms->cmsInfo.src.DataType == InTypeInfo.DataType))
{
InTypeInfo = lpParms->cmsInfo.src;
}
// go get a source from the user
else
{
CMSINFO CmsInfo2;
if( CmsGetSrcPTType( &InTypeInfo, &CmsInfo2) )
InTypeInfo = CmsInfo2.src;
}
}
}
else
FrameSetTypeInfo(&InTypeInfo, InTypeInfo.DataType, InTypeInfo.ColorMap);
// no conversion necessary
if (FrameTypeInfoEqual(InTypeInfo, OutTypeInfo))
return(TRUE);
DitherType = lpParms->DitherType;
fOptimize = lpParms->ConvertType == CT_OPTIMIZED;
fProgressSet = FALSE;
if ( OutTypeInfo.DataType == FDT_PALETTECOLOR/* && inDepth >= 3 */)
{
if (lpParms->ConvertType == CT_CUSTOM)
{
FNAME szFileName;
if ( !LookupExtFileN( lpParms->szPalette, szFileName, IDN_PALETTE, NO ) )
return(FALSE);
if (!(lpColorMap = Palette_ReadColorMap(szFileName)))
return(FALSE);
}
else
{
// allocate a map to carry around with image
lpColorMap = FrameCreateColorMap();
if (!lpColorMap)
{
Message(IDS_EMEMALLOC);
goto MemError;
}
lpColorMap->NumEntries = lpParms->iLevels;
if (InTypeInfo.DataType == FDT_GRAYSCALE && lpColorMap->NumEntries == 256 &&
fOptimize)
{
DitherType = DT_NONE;
lpRGB = lpColorMap->RGBData;
for (i = 0; i < lpColorMap->NumEntries; ++i)
{
lpRGB->red = lpRGB->green = lpRGB->blue = i;
++lpRGB;
}
}
else
{
// 1. CreateOptimizedPalette phase - only if fOptimize
// 2. Mapping phase
ProgressBegin(fOptimize ? 2 : 1,
lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
fProgressSet = TRUE;
if (fOptimize)
ProgressBegin(1, 0);
if (!CreateOptimizedPalette(lpBase, ObjGetEditFrame(lpBase),
lpColorMap->RGBData, &lpColorMap->NumEntries,
fOptimize,
fOptimize ? AstralClockCursor : NULL))
{
if (fOptimize)
ProgressEnd();
Message(IDS_EMEMALLOC);
goto ExitFalse;
}
if (fOptimize)
ProgressEnd();
}
}
if (lpColorMap->NumEntries <= 16)
lpColorMap->NumEntries = 16;
else
lpColorMap->NumEntries = 256;
FrameSetTypeInfo(&OutTypeInfo, FDT_PALETTECOLOR, lpColorMap);
}
if (!fProgressSet)
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
fProgressSet = TRUE;
iMaxWidth = 0;
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
if (RectWidth(&lpObject->rObject) > iMaxWidth)
iMaxWidth = RectWidth(&lpObject->rObject);
}
if (!TypeConvert.Init(InTypeInfo, OutTypeInfo, iMaxWidth, DitherType))
{
Message(IDS_EMEMALLOC);
goto ExitFalse;
}
if (ImgMultipleObjects(lpImage))
{
ProgressBegin(ImgCountObjects(lpImage), 0);
if ( !ImgEditInit(lpImage, ET_ALLOBJECTS, UT_NEWDATA|UT_COLORMAP, lpBase) )
goto ExitFalse;
fError = NO;
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
lpDstFrame = ConvertFrame(ObjGetEditFrame(lpObject), OutTypeInfo, &TypeConvert);
if (!lpDstFrame)
{
fError = YES;
break;
}
ImgEditedObjectFrame( lpImage, lpObject, lpParms->Common.idDirty, NULL,
lpDstFrame, NULL);
}
if (fError)
{
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
if (lpObject->Pixmap.UndoFrame)
{
lpDstFrame = lpObject->Pixmap.EditFrame;
lpObject->Pixmap.EditFrame = lpObject->Pixmap.UndoFrame;
lpObject->Pixmap.UndoFrame = NULL;
FrameClose(lpDstFrame);
}
}
}
ProgressEnd();
}
else
{
if ( !ImgEditInit(lpImage, ET_OBJECT, UT_NEWDATA|UT_COLORMAP, lpBase) )
goto ExitFalse;
ProgressBegin(1, 0);
lpDstFrame = ConvertFrame(lpBaseFrame, OutTypeInfo, &TypeConvert);
ProgressEnd();
if (!lpDstFrame)
goto ExitFalse;
/* Setup the new image and bring up the new image window */
ImgEditedObjectFrame( lpImage, lpBase, lpParms->Common.idDirty, NULL,
lpDstFrame, NULL);
}
switch (lpParms->cmsInfo.dst.DataType)
{
case FDT_LINEART:
lpImage->DataType = IDC_SAVELA;
break;
case FDT_GRAYSCALE:
lpImage->DataType = IDC_SAVECT;
break;
case FDT_PALETTECOLOR:
lpImage->DataType = IDC_SAVE8BITCOLOR;
break;
case FDT_RGBCOLOR:
lpImage->DataType = IDC_SAVE24BITCOLOR;
break;
case FDT_CMYKCOLOR:
lpImage->DataType = IDC_SAVE32BITCOLOR;
break;
}
ImgColorMapChanged(lpImage);
lpParms->Common.UpdateType = UT_DATATYPE;
fRet = TRUE;
ExitFalse:
if (fProgressSet)
ProgressEnd();
MemError:
if (lpColorMap)
FrameDestroyColorMap(lpColorMap);
return(fRet);
}
BOOL ImgEditInit( LPIMAGE lpImage, EDIT_TARGET Target, UNDO_TYPE UndoType,
LPOBJECT lpTargetObject)
/***********************************************************************/
{
LPOBJECT lpObject, lpBase;
int retc;
BOOL fDiscardUndo = NO;
BOOL fUndoFailed;
BOOL fMaskEdit;
lpBase = ImgGetBase(lpImage);
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
lpObject->InitUndoType = 0;
// No mask undo's are allowed - so apply any that we have now
if (!Control.UndoMasks)
ObjEditApply(lpImage, lpBase, NO, YES, NO);
// No undo's are allowed - so apply any that we have now
if (Control.NoUndo)
{
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
ObjEditApply(lpImage, lpObject, YES, lpObject != lpBase, NO);
}
if (!Control.MultipleObjects)
UndoType &= ~UT_DELETEOBJECTS;
fMaskEdit = (Target == ET_OBJECT) && (lpTargetObject == lpBase) &&
((UndoType & UT_ALPHAUNDO) != 0);
// see if any objects cannot have their undos freed without
// asking the user first, if so ask the user and get the response
// This is only a manual apply thing
if (UndoType & (UT_NEWDATA|UT_NEWALPHA) && Control.UseApply)
{
lpObject = NULL;
fDiscardUndo = YES;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS &&
!ImgIsSelectedObject(lpImage, lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
continue;
if (!ObjEditUndoDiscardable(lpObject, (UndoType & UT_NEWDATA) != 0,
(UndoType & UT_NEWALPHA) != 0))
{
retc = AstralConfirm( IDS_OKTOAPPLY );
if (retc == IDCANCEL)
return(FALSE);
fDiscardUndo = retc == IDYES;
break;
}
}
}
// now loop through the objects initializing their undos
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS && !ImgIsSelectedObject(lpImage, lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
{
// if no individual undo's, wack any undo buffers
// if in auto apply or in manual apply and state is redo
// Objects that are not the base need to also have
// their alphas wacked if this is not a mask edit
if (!Control.UndoObjects && (!Control.UseApply ||
( Control.UseApply && !lpObject->DataUndoNotRedo ) ) )
ObjEditApply(lpImage, lpObject, !fMaskEdit,
(lpObject != lpBase) && !fMaskEdit, NO);
continue;
}
// Discard it's undo if possible
if (fDiscardUndo)
ObjEditFreeUndo(lpObject, (UndoType & UT_NEWDATA) != 0,
(UndoType & UT_NEWALPHA) != 0);
// save state of undo failed flag
fUndoFailed = lpObject->fUndoFailed;
// Initialize the undo for this object
if (!ObjEditInit(lpImage, lpObject, UndoType))
{
// Undo initialization failed, so apply all objects that
// were going to be initialized
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
// see if this is an object we are not editing
if ((Target == ET_SELOBJECTS &&
!ImgIsSelectedObject(lpImage, lpObject)) ||
(Target == ET_OBJECT && lpObject != lpTargetObject))
{
continue;
}
lpObject->fUndoFailed = YES;
lpObject->InitUndoType = 0;
if (lpObject == lpBase)
ObjEditApply(lpImage, lpObject,
(UndoType & UT_DATAUNDO) != 0,
(UndoType & UT_ALPHAUNDO) != 0, NO);
else
ObjEditApply(lpImage, lpObject, YES, YES, NO);
}
// if we have failed before
if (fUndoFailed)
return(TRUE);
else
{
Message(IDS_NOUNDO);
return(FALSE);
}
}
lpObject->fUndoFailed = NO;
lpObject->InitUndoType = UndoType;
}
return( TRUE );
}
BOOL CombineObjObjects( LPIMAGE lpImage, LPCMD_PARMS lpCmdParms )
/************************************************************************/
{
RECT rCombine,r;
LPOBJECT lpBase, lpObj;
LPALPHA lpAlpha, lpMask;
LPFRAME lpDFrame, lpSFrame;
LPTR lpDF, lpDM, *lpSM, *lpSF;
int x, y, yy, depth;
int N, H, W, i;
double *lpAlphaTable, *AiXOi;
double red,blue,green,k;
POINT pt;
double Oi, Ai, Mi, Mc;
LPOBJECT *lpObject;
FRMTYPEINFO TypeInfo;
BOOL fCanDoOpacity;
FRMDATATYPE MaskType = FDT_GRAYSCALE;
if (!(lpImage))
return( FALSE );
ImgGetTypeInfo(lpImage, &TypeInfo);
if (TypeInfo.DataType == FDT_LINEART && Mask.OneBitMask)
MaskType = FDT_LINEART;
fCanDoOpacity = CANDOTRANSPARENCY(TypeInfo.DataType);
lpObj = lpBase = ImgGetBase(lpImage);
if (!(depth = FrameDepth(ObjGetEditFrame(lpBase))))
depth = 1; // never worry about lineart
N = ImgCountSelObjects(lpImage, NULL);
ImgGetSelObjectRect(lpImage, &rCombine, YES);
H = RectHeight(&rCombine);
W = RectWidth (&rCombine);
lpObject = NULL;
AiXOi = lpAlphaTable = NULL;
lpAlphaTable = (double *)Alloc((N+1) * sizeof(double));
AiXOi = (double *)Alloc(N * sizeof(double));
lpSM = (LPTR *)Alloc(N * sizeof(LPTR));
lpSF = (LPTR *)Alloc(N * sizeof(LPTR));
lpObject = (LPOBJECT *)Alloc(N * sizeof(LPOBJECT));
lpAlpha = MaskCreate(NULL, W, H, YES, Control.NoUndo, MaskType);
lpDFrame = ImgGetBaseEditFrame(lpImage);
lpDFrame = FrameOpen(FrameType(lpDFrame), W, H, FrameResolution(lpDFrame));
if (!lpAlphaTable || !lpObject || !AiXOi || !lpAlpha || !lpDFrame || !lpSM || !lpSF)
{
if (lpAlphaTable)
FreeUp(lpAlphaTable);
if (lpObject)
FreeUp(lpObject);
if (AiXOi)
FreeUp(AiXOi);
if (lpDFrame)
FreeUp(lpDFrame);
if (lpSF)
FreeUp(lpSF);
if (lpSM)
FreeUp(lpSM);
Message(IDS_EMEMALLOC);
return(FALSE);
}
for (i=0; i < N; i++)
lpObj = lpObject[i] = ImgGetSelObject(lpImage, lpObj);
ImgEditInit(lpImage, ET_OBJECT, UT_DELETEOBJECTS, lpBase);
ProgressBegin(1, PROGRESS_ID(IDS_UNDOOBJCOMBOBJS));
for (y = 0; y <= H; y++)
{
AstralClockCursor(y, H, NO);
lpDF = FramePointer(lpDFrame, 0, y, YES);
lpDM = PixmapPtr(&lpAlpha->Pixmap, PMT_EDIT, 0, y, YES);
pt.y = y + rCombine.top;
for (i=0; i < N; i++)
{
yy = pt.y - lpObject[i]->rObject.top;
lpSFrame = ObjGetEditFrame(lpObject[i]);
lpSF[i] = FramePointer(lpSFrame, 0, yy, NO);
lpMask = ObjGetAlpha(lpObject[i]);
lpSM[i] = PixmapPtr(&lpMask->Pixmap, PMT_EDIT, 0, yy, NO);
}
for (x = 0; x < W; x++)
{
lpAlphaTable[N] = 1.0;
pt.x = x + rCombine.left;
for (i=N-1; i >= 0; i--)
{
r = lpObject[i]->rObject;
r.bottom++;
r.right++;
if (PtInRect(&r, pt))
{
if (fCanDoOpacity)
Oi = lpObject[i]->Opacity / 255.0;
else
Oi = 1;
if (fCanDoOpacity)
Ai = *lpSM[i]++ / 255.0;
else if (*lpSM[i] < 128)
{
Ai = 0;
lpSM[i]++;
}
else
{
Ai = 1;
lpSM[i]++;
}
AiXOi[i] = Oi * Ai;
lpAlphaTable[i] = lpAlphaTable[i+1] * (1.0 - AiXOi[i]);
}
else
{
AiXOi[i] = 1.0;
lpAlphaTable[i] = lpAlphaTable[i+1];
}
}
Mc = 1.0 - lpAlphaTable[0];
lpDM[x] = (BYTE)(Mc * 255);
red = blue = green = k = 0;
for (i=0; i < N; i++)
{
r = lpObject[i]->rObject;
r.bottom++;
r.right++;
if (PtInRect(&r, pt))
{
Mi = AiXOi[i] * lpAlphaTable[i+1];
switch(depth)
{
case 1:
red += *lpSF[i]++ * Mi;
break;
case 3:
red += *lpSF[i]++ * Mi;
green += *lpSF[i]++ * Mi;
blue += *lpSF[i]++ * Mi;
break;
case 4:
red += *lpSF[i]++ * Mi;
green += *lpSF[i]++ * Mi;
blue += *lpSF[i]++ * Mi;
k += *lpSF[i]++ * Mi;
break;
}
}
}
if (Mc == 0.0)
Mc = 1.0;
switch(depth)
{
case 1:
*lpDF++ = (BYTE)(red / Mc);
break;
case 3:
*lpDF++ = (BYTE)(red / Mc);
*lpDF++ = (BYTE)(green / Mc);
*lpDF++ = (BYTE)(blue / Mc);
break;
case 4:
*lpDF++ = (BYTE)(red / Mc);
*lpDF++ = (BYTE)(green / Mc);
*lpDF++ = (BYTE)(blue / Mc);
*lpDF++ = (BYTE)(k / Mc);
break;
}
}
}
lpObj = ObjCreateFromFrame(ST_PERMANENT, lpDFrame, lpAlpha, &rCombine,
Control.NoUndo );
lpObj->fSelected = YES;
lpObj->fUndoDeleted = YES;
ImgAddNewObject(lpImage, lpObj);
for (i=0; i < N; i++)
lpObject[i]->fDeleted = YES;
ImgEditedObject(lpImage, lpBase, IDS_UNDOOBJCOMBOBJS, NULL);
UpdateImage(lpImage, &rCombine, YES);
FreeUp(lpSM);
FreeUp(lpSF);
FreeUp(AiXOi);
FreeUp(lpAlphaTable);
FreeUp(lpObject);
ProgressEnd();
return( TRUE );
}
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);
}
BOOL WINPROC EXPORT DlgRoomDot2Dot (HWND hWnd,UINT wMsg,WPARAM wParam,LPARAM lParam)
{
BOOL bHandled = TRUE;
char szTemp[MAX_PATH];
HWND hImageCtrl;
switch (wMsg)
{
case WM_COMMAND:
switch (wParam)
{
case HS_COVER:
ShowControls(hWnd, TRUE);
ShowCoverAnimatedButtons(hWnd, TRUE);
break;
case HS_SHOW_ME:
iActiveDot = 0;
bPlaying = FALSE;
UpdateDot2DotImage(hWnd, NULL);
break;
case HS_COLORME_ME:
RemoveCodedBackground();
GoPaintApp (hWnd,szPreview);
break;
case HS_TAB1:
case HS_TAB2:
case HS_TAB3:
case HS_TAB4:
case HS_TAB5:
case HS_TAB6:
case HS_TAB7:
case HS_TAB8:
{
BOOL bLoad;
ShowCoverAnimatedButtons(hWnd, FALSE);
ShowControls(hWnd, FALSE);
hImageCtrl = GetDlgItem(hWnd, IDC_HIDDEN_IMAGE);
if (hImageCtrl)
{
wsprintf (szTemp,GetString (IDS_CIRCUS, NULL),wParam - HS_TAB1 + 1);
PathCat (szPreview,Control.PouchPath,szTemp);
bLoad = AstralImageLoad( 0, szPreview, TRUE, FALSE);
if (bLoad && lpImage)
{
bPlaying = TRUE;
SetWindowLong(hImageCtrl, GWL_IMAGE,
(long) ImgGetBase (lpImage));
SetWindowLong(hImageCtrl, GWL_IMAGE_TOOLPROC,
(long) Dot2DotProc);
InitPoints();
ImgSetPixelProc(Dot2DotPixelProc);
ShowWindow(hImageCtrl, SW_SHOW);
UpdateDot2DotImage(hWnd, NULL);
}
}
} // HS_TABS
SoundStartID(HS_XTRA_CIRCUS, FALSE, 0);
break;
default:
bHandled = FALSE;
} // switch (wParam)
break;
case WM_INITDIALOG:
hDot2DotWnd = hWnd;
ShowControls(hWnd, TRUE);
bHandled = FALSE; // allow DefRoomProc to be called.
break;
case WM_DESTROY:
ImgSetPixelProc(NULL); // make sure our proc is no longer used
bHandled = FALSE; // allow DefRoomProc to be called
break;
case WM_PAINT:
hImageCtrl = GetDlgItem(hWnd, IDC_HIDDEN_IMAGE);
DefRoomProc (hWnd,wMsg,wParam,lParam);
UpdateWindow(hImageCtrl);
PaintDot2Dots(hImageCtrl);
break;
default:
bHandled = FALSE;
} // switch (wMsg)
if (!bHandled)
bHandled = DefRoomProc (hWnd,wMsg,wParam,lParam);
return bHandled;
}
LOCAL BOOL Align_OnInitDialog(HWND hDlg, HWND hWndFocus, LPARAM lParam)
/************************************************************************/
{
int i, nCount;
LPRECT pRect;
LPOBJECT lpObject;
LPIMAGE lpImage;
HWND hWnd, hWndChild;
RECT gRect;
LPALIGNOBJECTS_PARMS lpAlignParms;
int arObjects[] = { IDC_ALIGN_SQUARE, IDC_ALIGN_TRIANGLE,
IDC_ALIGN_CIRCLE };
lpAlignParms = ( LPALIGNOBJECTS_PARMS )lParam;
lpAlignParms->HorzAlign = HA_NONE;
lpAlignParms->VertAlign = VA_NONE;
lpAlignParms->RectAlign = RA_OBJECT;
lpAlignParms->bPreview = FALSE;
if( !( lpImage = GetActiveImage() ) )
return( FALSE );
if( !( ImgGetMask( lpImage ) ) )
ControlEnable( hDlg, IDC_ALIGN_MASK, NO );
if( !( ImgMultipleObjects( lpImage ) ) )
ControlEnable( hDlg, IDC_ALIGN_OBJECT, NO );
CheckComboItem( hDlg, IDC_ALIGN_COMBO, IDC_ALIGN_IMAGE, IDC_ALIGN_MASK,
IDC_ALIGN_IMAGE );
SendDlgItemMessage( hDlg, IDC_ALIGN_COMBO, CB_SETITEMDATA, PARMS_INDEX,
lParam );
nCount = 0;
if( !( lpObject = ImgGetBase( lpImage ) ) )
return( FALSE );
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
++nCount;
if( !( pRect = lpAlignParms->lpRect = ( LPRECT )Alloc( sizeof( RECT ) * nCount ) ) )
return( FALSE );
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
*(pRect)++ = lpObject->rObject;
hWnd = GetDlgItem( hDlg, IDC_ALIGN_GRID );
GetClientRect( hWnd, &gRect );
for( i = 0; i < ALIGN_NUM_OBJECTS; i++ )
{
InitPos[i].x = gRect.left + ( ( gRect.right / ( ALIGN_NUM_OBJECTS + 1 ) ) * ( i + 1 ) ) - 16;
InitPos[i].y = gRect.top + ( ( gRect.bottom / ( ALIGN_NUM_OBJECTS + 1 ) ) * ( i + 1 ) ) - 16;
hWndChild = CreateWindowEx(
WS_EX_TRANSPARENT,
"icon",
"",
WS_CHILD | WS_VISIBLE | WS_NOSHADOWS | WS_NOTENABLED | WS_NOBGND,
InitPos[i].x,
InitPos[i].y,
32,
32,
hWnd,
( HMENU )arObjects[i],
PictPubApp.GetResourceHandle(),
NULL );
ShowWindow( hWndChild, SW_SHOWNORMAL );
UpdateWindow( hWndChild );
}
CenterPopup( hDlg );
return(TRUE);
}
BOOL AlignObjects( LPIMAGE lpImage, LPALIGNOBJECTS_PARMS lpAlignParms )
/************************************************************************/
{
RECT bRect, gRect, uRect;
LPOBJECT lpObject, lpGroupObject;
int xOffset, yOffset, gXOffset, gYOffset, nWidth, nHeight, nCount;
LFIXED hSpace, vSpace, fx, fy;
WORD wGroupIDs[NUM_GROUPS];
if( !( lpImage ) )
return( FALSE );
if( !( lpObject = ImgGetBase( lpImage ) ) )
return( FALSE );
if( !( lpAlignParms->bPreview ) )
{
if( !( ImgEditInit( lpImage, ET_SELOBJECTS, UT_OBJECTRECT, lpObject ) ) )
return( FALSE );
}
if( lpAlignParms->RectAlign == RA_IMAGE )
{
ImgGetImageRect( lpImage, &bRect );
}
else
{
if( lpAlignParms->RectAlign == RA_MASK )
ImgGetMaskRect( lpImage, &bRect );
else
ImgGetSelObjectRect( lpImage, &bRect, YES );
}
ImgGetSelObjectRect( lpImage, &uRect, YES );
nWidth = RectWidth( &bRect );
nHeight = RectHeight( &bRect );
nCount = 0;
InitGroupList( wGroupIDs );
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
{
if( lpObject->wGroupID )
{
if( !( IsPrevGroup( lpObject->wGroupID, wGroupIDs ) ) &&
!( IsGroupLocked( lpObject->wGroupID ) ) )
{
SetGroupList( lpObject->wGroupID, wGroupIDs );
lpImage->GetGroupRect( lpObject, &gRect );
nWidth -= RectWidth( &gRect );
nHeight -= RectHeight( &gRect );
++nCount;
}
}
else if (!lpObject->bLocked)
{
nWidth -= RectWidth( &lpObject->rObject );
nHeight -= RectHeight( &lpObject->rObject );
++nCount;
}
}
if( nCount == 0 )
return( FALSE );
hSpace = FGET( nWidth, nCount - 1 );
vSpace = FGET( nHeight, nCount - 1 );
fx = fy = 0;
InitGroupList( wGroupIDs );
lpObject = ImgGetBase( lpImage );
while ( lpObject = ImgGetSelObject(lpImage, lpObject) )
{
if( lpObject->wGroupID )
{
if( !( IsPrevGroup( lpObject->wGroupID, wGroupIDs ) ) &&
!( IsGroupLocked( lpObject->wGroupID ) ) )
{
SetGroupList( lpObject->wGroupID, wGroupIDs );
lpImage->GetGroupRect( lpObject, &gRect );
ObjAlign( &bRect, &gRect, lpAlignParms, vSpace, hSpace,
&gXOffset, &gYOffset, &fx, &fy );
lpGroupObject = ImgGetBase( lpImage );
while( lpGroupObject = ImgGetSelObject( lpImage, lpGroupObject ) )
{
if( lpObject->wGroupID == lpGroupObject->wGroupID )
{
if( !( lpAlignParms->bPreview ) )
ImgEditedObject( lpImage, lpGroupObject, IDS_UNDOOBJALIGN,
NULL );
OffsetRect( &lpGroupObject->rObject, gXOffset, gYOffset );
}
}
}
}
else if (!lpObject->bLocked)
{
ObjAlign( &bRect, &lpObject->rObject, lpAlignParms, vSpace, hSpace,
&xOffset, &yOffset, &fx, &fy );
if( !( lpAlignParms->bPreview ) )
ImgEditedObject( lpImage, lpObject, IDS_UNDOOBJALIGN, NULL );
OffsetRect( &lpObject->rObject, xOffset, yOffset );
}
}
ImgGetSelObjectRect( lpImage, &bRect, YES );
AstralUnionRect( &uRect, &uRect, &bRect );
UpdateImage( lpImage, &uRect, YES );
return( TRUE );
}
LOCAL void Align_OnCommand(HWND hDlg, int id, HWND hControl, UINT codeNotify)
/************************************************************************/
{
LPRECT pRect;
LPALIGNOBJECTS_PARMS lpAlignParms;
int nType;
LPOBJECT lpObject;
LPIMAGE lpImage;
lpAlignParms = ( LPALIGNOBJECTS_PARMS )SendDlgItemMessage( hDlg,
IDC_ALIGN_COMBO, CB_GETITEMDATA, PARMS_INDEX, 0 );
switch (id)
{
case IDC_ALIGN_RIGHT:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_RIGHT;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_CENTER:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_CENTER;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_LEFT:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_LEFT;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_HSPACE:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_EQUAL;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_UP:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_TOP;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_MID:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_MID;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_DOWN:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_BOTTOM;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_VSPACE:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_EQUAL;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_PREVIEW:
nType = ( int )SendDlgItemMessage( hDlg, IDC_ALIGN_COMBO,
CB_GETCURSEL, 0, 0 );
if( nType == 0 )
lpAlignParms->RectAlign = RA_IMAGE;
else if( nType == 1 )
lpAlignParms->RectAlign = RA_OBJECT;
else
lpAlignParms->RectAlign = RA_MASK;
lpAlignParms->bPreview = TRUE;
AlignObjects( GetActiveImage(), lpAlignParms );
EnableWindow( GetDlgItem( hDlg, IDC_PREVIEW ), FALSE );
break;
case IDOK:
ALIGNOBJECTS_PARMS AlignParms;
if( lpAlignParms->bPreview )
{
AlignParms = *lpAlignParms;
lpAlignParms->HorzAlign = HA_NONE;
lpAlignParms->VertAlign = VA_NONE;
pRect = lpAlignParms->lpRect;
if( !( lpImage = GetActiveImage() ) )
break;
if( !( lpObject = ImgGetBase( lpImage ) ) )
break;
while ( lpObject = ImgGetSelObject( lpImage, lpObject) )
lpObject->rObject = *pRect++;
AlignObjects( GetActiveImage(), lpAlignParms );
*lpAlignParms = AlignParms;
}
nType = ( int )SendDlgItemMessage( hDlg, IDC_ALIGN_COMBO,
CB_GETCURSEL, 0, 0 );
if( nType == 0 )
lpAlignParms->RectAlign = RA_IMAGE;
else if( nType == 1 )
lpAlignParms->RectAlign = RA_OBJECT;
else
lpAlignParms->RectAlign = RA_MASK;
lpAlignParms->bPreview = FALSE;
AstralDlgEnd( hDlg, TRUE );
break;
case IDC_RESET:
DoReset(hDlg, lpAlignParms);
break;
case IDCANCEL:
DoReset(hDlg, lpAlignParms);
AstralDlgEnd( hDlg, FALSE );
break;
default:
break;
}
}
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 );
}
