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);
}
CChromaMask::CChromaMask(CChromaDlg* pDlg)
{
int i;
FRMTYPEINFO TypeInfo;
BOOL EnableFade;
m_pDlg = pDlg;
ImgGetTypeInfo(pDlg->GetImage(), &TypeInfo);
EnableFade = TypeInfo.DataType != FDT_LINEART && TypeInfo.DataType != FDT_PALETTECOLOR;
ChromaCombineMode = SHAPE_ADD;
Fade = EnableFade? 10 : 0;
Delete = FALSE;
ActiveChromaMask = Mask = 0;
ChromaColorMode = IDC_CHROMA_HSL;
for (i=0; i < NUM_CHROMAMASKS; i++)
{
MaskRange[i] = 10;
MaskColor[i].rgb.red = 255;
MaskColor[i].rgb.green = 255;
MaskColor[i].rgb.blue = 255;
RGBtoHSL(0, 0, 0, &MaskColor[i].hsl);
RGBtoCMYK(0,0, 0, &MaskColor[i].cmyk);
}
}
BOOL InvertImage(LPIMAGE lpImage, LPCMD_PARMS lpParms)
{
ENGINE Engine;
FRMTYPEINFO TypeInfo;
LPCOLORMAP lpColorMap;
ImgGetTypeInfo(lpImage, &TypeInfo);
if (TypeInfo.DataType == FDT_PALETTECOLOR)
{
lpColorMap = FrameCopyColorMap(TypeInfo.ColorMap);
if (!lpColorMap)
{
Message(IDS_EMEMALLOC);
lpParms->Common.StatusCode = SC_MEMERROR;
return(FALSE);
}
negate((LPTR)lpColorMap->RGBData, sizeof(RGBS)*lpColorMap->NumEntries);
lpParms->Common.StatusCode = ApplyColorMap(lpImage, lpColorMap, FALSE, DT_NONE, lpParms->Common.idDirty);
FrameDestroyColorMap(lpColorMap);
if (lpParms->Common.StatusCode == SC_SUCCESS)
lpParms->Common.UpdateType = UT_DATATYPE;
}
else
{
SetEngineDef(&Engine);
Engine.lpDataProc = invert_proc;
lpParms->Common.StatusCode = LineEngineSelObj(lpImage,&Engine,lpParms->Common.idDirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
lpParms->Common.UpdateType = UT_AREA;
lpParms->Common.rUpdateArea = Engine.rUpdate;
}
}
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
STATUS_CODE ApplyColorMap(LPIMAGE lpImage, LPCOLORMAP lpColorMap, BOOL fReMap,
DITHER_TYPE DitherType, ITEMID idDirty)
/************************************************************************/
{
UNDO_TYPE UndoType;
int iMaxWidth;
FRMTYPEINFO OldTypeInfo, NewTypeInfo;
LPOBJECT lpObject;
RECT rEdit;
CFrameTypeConvert TypeConvert;
UndoType = UT_COLORMAP;
if (fReMap)
UndoType |= UT_DATA;
if (!ImgEditInit(lpImage, ET_ALLOBJECTS, UndoType, NULL))
return(SC_UNDOERROR);
ProgressBegin(ImgCountObjects(lpImage), idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
if (fReMap)
{
ImgGetTypeInfo(lpImage, &OldTypeInfo);
FrameSetTypeInfo(&NewTypeInfo, FDT_PALETTECOLOR, lpColorMap);
iMaxWidth = 0;
lpObject = NULL;
while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO))
{
if (RectWidth(&lpObject->rObject) > iMaxWidth)
iMaxWidth = RectWidth(&lpObject->rObject);
}
if (!TypeConvert.Init(OldTypeInfo, NewTypeInfo, iMaxWidth, DitherType))
{
ProgressEnd();
Message(IDS_EMEMALLOC);
return(SC_MEMERROR);
}
}
lpObject = NULL;
while (lpObject = ImgGetNextObjectEx(lpImage, lpObject, YES, NO, YES))
{
if (fReMap)
PaletteMapPixmap(&lpObject->Pixmap, &TypeConvert);
FrameSetColorMap(ObjGetEditFrame(lpObject), lpColorMap);
rEdit = lpObject->rObject;
ImgEditedObject(lpImage, lpObject, idDirty, &rEdit);
}
ImgColorMapChanged(lpImage);
ProgressEnd();
return(SC_SUCCESS);
}
void 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();
}
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 TextureFillImage(
LPIMAGE lpImage,
LPTEXTUREFILL_PARMS lpParms)
{
ENGINE Engine;
FNAME szFileName;
LPFRAME lpTexture;
FRMTYPEINFO TypeInfo;
ImgGetTypeInfo(lpImage, &TypeInfo);
if (!LookupExtFile(lpParms->TextureName, szFileName, IDN_TEXTURE))
{
lpParms->Common.StatusCode = SC_FILENOTFOUND;
return(FALSE);
}
ProgressBegin(2, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
CReadImage read(szFileName);
if ( !(lpTexture = read.ReadFrame(TypeInfo) ))
{
ProgressEnd();
lpParms->Common.StatusCode = SC_READERROR;
return(FALSE);
}
SetEngineOld(&Engine, NO, NULL, NULL, lpTexture,
lpParms->fHorzFlip, lpParms->fVertFlip,
NULL, NULL, lpParms->TextureOpacity, lpParms->TextureMergeMode);
lpParms->Common.StatusCode = LineEngineSelObj(lpImage,&Engine,lpParms->Common.idDirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
lpParms->Common.UpdateType = UT_AREA;
lpParms->Common.rUpdateArea = Engine.rUpdate;
}
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
BOOL CExpandImageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
int id = LOWORD(wParam); //ID of control
WORD codeNotify = HIWORD(wParam); //Control notification code
HWND hControl = (HWND) lParam; //Handle of control
LPIMAGE lpImage;
FRMTYPEINFO TypeInfo;
long Color;
switch (id)
{
case IDC_EXPANDLEFT:
case IDC_EXPANDRIGHT:
case IDC_EXPANDTOP:
case IDC_EXPANDBOTTOM:
case IDC_HEIGHT:
case IDC_WIDTH:
case IDC_PREF_UNITS:
DoExpandControls(id, codeNotify);
break;
case IDC_FILLINCOLOR:
if (codeNotify != 1)
break;
lpImage = GetImage();
if (lpImage)
ImgGetTypeInfo(lpImage, &TypeInfo);
else
FrameSetTypeInfo(&TypeInfo, FDT_RGBCOLOR, NULL);
if (TypeInfo.DataType == FDT_LINEART)
{
if(m_FillColor.gray == 255)
m_FillColor.gray = 0;
else
m_FillColor.gray = 255;
SetColorInfo(&m_FillColor, &m_FillColor, CS_GRAY);
}
else if (TypeInfo.DataType == FDT_GRAYSCALE || TypeInfo.DataType == FDT_PALETTECOLOR)
{
if (!PalettePicker(&m_FillColor, NULL, TypeInfo.ColorMap))
break;
}
else if (!ColorPicker(&m_FillColor, NULL))
break;
CopyRGB( &m_FillColor.rgb, &Color );
SetWindowLong(::GetDlgItem(GetSafeHwnd(),IDC_FILLINCOLOR), GWL_ACTIVE, Color );
AstralControlRepaint(GetSafeHwnd(), IDC_FILLINCOLOR);
break;
case IDOK:
if ( (FMUL( m_Resolution, m_Width ) > MAX_IMAGE_WIDTH) ||
(FMUL( m_Resolution, m_Height) > MAX_IMAGE_HEIGHT))
{
Message( IDS_ETOOWIDE );
break;
}
SetUnitResolution( 0 );
Control.Units = m_SaveUnits;
SetUnitInfo((UNIT_TYPE)(Control.Units-IDC_PREF_UNITINCHES), Control.UnitRes,
Control.Points);
AstralDlgEnd( GetSafeHwnd(), TRUE );
break;
default:
break;
}
return CPPViewModalDlg::OnCommand(wParam, lParam);
}
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 );
}
BOOL ConvertTo(LPIMAGE lpImage, int iFunction)
/***********************************************************************/
{
CONVERT_PARMS parms;
DITHER_TYPE DitherType = DT_NONE;
if (ImgInMaskEditMode(lpImage))
return(FALSE);
ImgGetTypeInfo(lpImage, &parms.cmsInfo.src);
switch (iFunction)
{
case IDM_CONVLA:
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_LINEART);
break;
case IDM_CONVSP:
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_LINEART);
DitherType = DT_SCATTER;
break;
case IDM_CONVCT:
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_GRAYSCALE);
break;
case IDM_CONVPALETTE:
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_PALETTECOLOR);
if ( !AstralDlg( NO, PictPubApp.GetResourceHandle(), PictPubApp.Get_hWndAstral(), IDD_CONVERTTO, DlgConvertProc ))
return( NO );
DitherType = Convert.ConvertDitherType;
break;
case IDM_CONVRGBCOLOR:
if (Control.CMSEnabled && IsSrcPTSelected(&parms.cmsInfo.src.ptInfo))
{
CMSINFO CmsInfo;
CmsInfo.src.DataType = FDT_CMYKCOLOR;
if (!CmsGetDstPT(&CmsInfo))
return(FALSE);
else
parms.cmsInfo.dst = CmsInfo.dst;
}
else
{
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_RGBCOLOR);
}
break;
case IDM_CONVCMYKCOLOR:
if (Control.CMSEnabled && IsSrcPTSelected(&parms.cmsInfo.src.ptInfo))
{
CMSINFO CmsInfo;
CmsInfo.src.DataType = FDT_RGBCOLOR;
if (!CmsGetDstPT(&CmsInfo))
return(FALSE);
else
parms.cmsInfo.dst = CmsInfo.dst;
}
else
{
FrameSetTypeInfo(&parms.cmsInfo.dst, FDT_CMYKCOLOR);
}
break;
case IDM_COLORMANAGED:
if (!CmsGetSrcDstPT(&parms.cmsInfo))
return(TRUE);
break;
}
parms.DitherType = DitherType;
parms.ConvertType = Convert.ConvertType;
parms.iLevels = Convert.ConvertColors;
lstrcpy(parms.szPalette, Convert.ConvertPalette);
ProcessCommand(lpImage->lpCmdList, IDS_CMD_CONVERT, &parms);
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);
}
