void COlelistBox::OnLButtonDown(UINT nFlags, CPoint point)
{
FNAME *lpResult;
CDataItem *pDataItem;
LPIMAGE lpImage = GetActiveImage();
CServerDoc *pDoc = PictPubApp.GetDocument(lpImage);
int num;
CRect r,rr;
BOOL bCreateDoc = (pDoc == NULL);
CPoint p;
CListBox::OnLButtonDown(nFlags, point);
FORWARD_WM_LBUTTONUP(GetSafeHwnd(), point.x, point.y, nFlags, ::SendMessage);
lpResult = ExtBsr_GetSelection(GetParent()->GetSafeHwnd(), &num);
if (!lpResult || num != 1)
return;
lstrcpy(Names.Clipboard, lpResult[0]);
if (LookupExtFileN(Names.Clipboard, Names.PasteImageFile,
IDN_CLIPBOARD, NO))
{
if (bCreateDoc)
{
LPFRAME lpFrame = FrameOpen(FDT_GRAYSCALE, 1, 1, 72);
if (lpFrame)
{
POSITION Pos;
lpImage = CreateImage(NULL,lpFrame,NULL,NULL,
IDN_PP,IDC_SAVECT,IMG_DOCUMENT,NULL);
if (!lpImage)
{
FrameClose(lpFrame);
return;
}
pDoc = (CServerDoc*)PictPubApp.OpenDocumentFile(
lpImage->CurFile, lpImage, FALSE);
if (!pDoc)
{
DestroyImage(lpImage);
return;
}
}
else
return;
}
if (pDoc)
{
pDataItem = new CDataItem(pDoc, Names.Clipboard, YES);
GetParent()->GetWindowRect(&r);
ClientToScreen(&point);
GetItemRect(GetCurSel(), &rr);
ClientToScreen(&rr);
p.x = rr.Width() / 2;
p.y = rr.Height() / 2;
// NOTE!!the pDataItem will be internally destroyed once the drag/drop
// operation is completed therefore we do not need to delete the pDataItem
pDataItem->DoDragDrop(&rr, p, FALSE, DROPEFFECT_COPY, &r);
if (bCreateDoc)
pDoc->OnCloseDocument();
}
}
else if(Names.Clipboard[0])
{
// deleted the file...notify the browser
UpdatePasteFromFile(NULL);
}
}
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);
}
//************************************************************************
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);
}
