BOOL CChromaDlg::OnInitDialog()
{
HWND hDlg = GetSafeHwnd();
int i;
FRMTYPEINFO TypeInfo;
BOOL EnableFade;
PreDoModal(NULL);
bPreview = bProbePending = NO;
ImgGetTypeInfo(GetImage(), &TypeInfo);
EnableFade = TypeInfo.DataType != FDT_LINEART && TypeInfo.DataType != FDT_PALETTECOLOR;
CenterPopup(hDlg);
lpChromaMask = new CChromaMask(this);
ControlEnable(hDlg, IDC_DELETEMASK, ImgGetMask(GetImage()) != NULL);
iCombo[0] = IDC_CHROMA_NORMAL;
iCombo[1] = IDC_CHROMA_HSL;
iCombo[2] = IDC_CHROMA_LUMIN;
nCombo = 3;
TableCheckComboItem(hDlg, IDC_CHROMASELECT, &iCombo[0], nCombo, lpChromaMask->ChromaColorMode, NO);
for (i=0; i < NUM_CHROMAMASKS; i++)
{
InitDlgItemSpin(hDlg, IDC_MASKRANGE1+i, 10, NO, 0, 100);
CheckDlgButton(IDC_MASKACTIVE1+i, FALSE);
SetWindowLong(GetDlgItem(IDC_MASKCOLOR1+i)->GetSafeHwnd(),GWL_ACTIVE, 0);
}
InitDlgItemSpin(hDlg, IDC_CHROMA_FADE, 10, NO, 0, 100);
CheckRadioButton(IDC_MASKMODE_REVERSE, IDC_MASKMODE_SUBTRACT, IDC_MASKMODE_ADD);
lpChromaMask->SetupChroma();
ControlEnable(hDlg, IDC_CHROMA, NO);
ControlEnable(hDlg, IDC_RESET, NO);
ControlEnable( hDlg, IDC_CHROMA_FADE,EnableFade);
return(TRUE);
}
void CChromaDlg::ShowChromaPreview()
{
HWND hDlg = GetSafeHwnd();
RECT rMask;
HWND hActiveWnd;
LPIMAGE lpImage = GetImage();
hActiveWnd = m_pView->GetSafeHwnd();
if (!hActiveWnd)
return;
lpChromaMask->iMode = ImgGetViewMode(lpImage);
ImgSetViewMode(lpImage, VM_SLIME);
if (ImgGetMask(lpImage))
ImgGetMaskRect(lpImage, &rMask);
else
ImgGetSelObjectRect(lpImage, &rMask, NO);
File2DispRect(hActiveWnd, &rMask, &rMask);
if (Tool.id == IDC_CHROMA)
AstralUnionRect(&rMask, &rMask, &rPreview);
ImgGetMaskRect(lpImage, &rPreview);
File2DispRect(hActiveWnd, &rPreview, &rPreview);
SetMaskHook(hActiveWnd, (LPMASKHOOK)lpChromaMask);
AstralCursor( IDC_WAIT );
::InvalidateRect(hActiveWnd, &rMask, FALSE);
AstralUpdateWindow(hActiveWnd);
ControlEnable(hDlg, IDC_RESET, YES );
AstralCursor(NULL);
}
BOOL PosterizeImage(LPIMAGE lpImage, LPPOSTERIZE_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMap( &lpMaps->MasterMap, MAXPOINTS, NO );
ResetMap( &lpMaps->RedMap, MAXPOINTS, NO );
ResetMap( &lpMaps->GreenMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlackMap, MAXPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAXPOINTS, NO );
lpMaps->MasterMap.Levels = lpParms->MasterInfo.Levels;
lpMaps->MasterMap.Threshold = lpParms->MasterInfo.Threshold;
lpMaps->RedMap.Levels = lpParms->RedInfo.Levels;
lpMaps->RedMap.Threshold = lpParms->RedInfo.Threshold;
lpMaps->GreenMap.Levels = lpParms->GreenInfo.Levels;
lpMaps->GreenMap.Threshold = lpParms->GreenInfo.Threshold;
lpMaps->BlueMap.Levels = lpParms->BlueInfo.Levels;
lpMaps->BlueMap.Threshold = lpParms->BlueInfo.Threshold;
lpMaps->BlackMap.Levels = lpParms->BlackInfo.Levels;
lpMaps->BlackMap.Threshold = lpParms->BlackInfo.Threshold;
MakeMap(&lpMaps->MasterMap);
MakeMap(&lpMaps->RedMap);
MakeMap(&lpMaps->GreenMap);
MakeMap(&lpMaps->BlueMap);
MakeMap(&lpMaps->BlackMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
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);
}
}
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 HueImage(LPIMAGE lpImage, LPHUE_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART || type == FDT_GRAYSCALE)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMap( &lpMaps->MasterMap, MAXPOINTS, NO );
ResetMap( &lpMaps->RedMap, MAXPOINTS, NO );
ResetMap( &lpMaps->GreenMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlackMap, MAXPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAXPOINTS, NO );
lpMaps->HueMap.Points = lpParms->HueInfo.Points;
copy((LPTR)&lpParms->HueInfo.Pnt, (LPTR)&lpMaps->HueMap.Pnt, sizeof(lpMaps->HueMap.Pnt));
lpMaps->SatMap.Brightness[0] = lpParms->Saturation;
lpMaps->MasterMap.Brightness[0] = lpParms->Brightness;
MakeMap(&lpMaps->HueMap);
MakeMap(&lpMaps->SatMap);
MakeMap(&lpMaps->MasterMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
BOOL ContBritImage(LPIMAGE lpImage, LPCONTBRIT_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
int i;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMapEx( &lpMaps->MasterMap, MAPPOINTS, NO, YES);
ResetMap( &lpMaps->RedMap, MAPPOINTS, NO ); // sometimes Cyan
ResetMap( &lpMaps->GreenMap, MAPPOINTS, NO ); // sometimes Magenta
ResetMap( &lpMaps->BlueMap, MAPPOINTS, NO ); // sometimes Yellow
ResetMap( &lpMaps->BlackMap, MAPPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAPPOINTS, NO );
lpMaps->MasterMap.Contrast = lpParms->Contrast;
for (i = 0; i < NUM_BANDS; ++i)
lpMaps->MasterMap.Brightness[i] = lpParms->Brightness[i];
MakeMap(&lpMaps->MasterMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
BOOL ApplyCalImage(LPIMAGE lpImage, LPAPPLYCAL_PARMS lpParms)
/************************************************************************/
{
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
lpParms->Common.StatusCode = ApplyCalibration(lpImage, lpParms->Common.idDirty,
lpParms->szScanMap, lpParms->szPrintMap, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
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);
}
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);
}
