void ImgInitDisplay(LPIMAGE lpImage, BOOL fGeneratePaletteLUT)
/***********************************************************************/
{
LPTR lpPaletteLUT;
RGBS RGBmap[256];
LPRGB lpRGBmap;
int nColors;
FRMTYPEINFO TypeInfo, DstTypeInfo = ColorManager.Monitor.dst;
LPOBJECT lpObject;
lpObject = lpImage->GetDisplayObject();
if (!lpObject)
return;
FrameGetTypeInfo(ObjGetEditFrame(lpObject), &TypeInfo);
if ( lpBltScreen->BitMapInfo.bmiHeader.biBitCount == 8 &&
!lpImage->lpPaletteLUT)
{
ProgressBegin(1, PROGRESS_ID(IDS_UNDOSETUPDISPLAY));
if (TypeInfo.DataType == FDT_PALETTECOLOR)
lpPaletteLUT = Alloc(32768L);
else
lpPaletteLUT = NULL;
if (lpPaletteLUT)
{
if (TypeInfo.ColorMap->NumEntries > MAX8BITCOLORS)
{
nColors = MAX8BITCOLORS;
lpRGBmap = RGBmap;
if (!ReducePalette(TypeInfo.ColorMap->RGBData, TypeInfo.ColorMap->NumEntries,
lpRGBmap, nColors))
{
FreeUp(lpPaletteLUT);
lpPaletteLUT = NULL;
}
}
else
{
lpRGBmap = TypeInfo.ColorMap->RGBData;
nColors = TypeInfo.ColorMap->NumEntries;
}
}
if (lpPaletteLUT)
{
if (fGeneratePaletteLUT)
CreatePaletteLut15(lpRGBmap, nColors, lpPaletteLUT, AstralClockCursor);
lpImage->lpPaletteLUT = lpPaletteLUT;
lpImage->PaletteType = PT_CUSTOMPALETTE;
lpImage->hPal = CreateLogicalPalette(lpRGBmap, nColors);
GetObject(lpImage->hPal, sizeof(nColors), (void *)&nColors);
lpImage->nPaletteEntries = GetPaletteEntries(lpImage->hPal,
0, nColors, lpImage->Palette);
}
else
{
if ( FrameType(ImgGetBaseEditFrame(lpImage)) <= FDT_GRAYSCALE)
{
lpImage->hPal = lpBltScreen->hGrayPal;
lpImage->nPaletteEntries = lpBltScreen->nGrayEntries;
lpImage->PaletteType = lpBltScreen->GrayPaletteType;
lpImage->lpPaletteLUT = lpBltScreen->lpGrayPaletteLUT;
copy((LPTR)lpBltScreen->GrayPalette,
(LPTR)lpImage->Palette,
sizeof(lpImage->Palette));
}
else
{
lpImage->hPal = lpBltScreen->hColorPal;
lpImage->nPaletteEntries = lpBltScreen->nColorEntries;
lpImage->PaletteType = lpBltScreen->ColorPaletteType;
lpImage->lpPaletteLUT = lpBltScreen->lpColorPaletteLUT;
copy((LPTR)lpBltScreen->ColorPalette,
(LPTR)lpImage->Palette,
sizeof(lpImage->Palette));
}
}
ProgressEnd();
}
if (lpImage->m_cmsXform)
{
if( Control.CMSEnabled && lpKCMSFreeProc )
{
if (lpImage->PtInfo.toRCS != TypeInfo.ptInfo.toRCS &&
lpImage->PtInfo.frRCS != TypeInfo.ptInfo.frRCS )
{
( lpKCMSFreeProc )( lpImage->m_cmsXform );
lpImage->m_cmsXform = NULL;
}
}
else
lpImage->m_cmsXform = NULL;
}
if( Control.CMSEnabled &&
IsSrcPTSelected( &TypeInfo.ptInfo ) &&
IsDstPTSelected( &DstTypeInfo.ptInfo ) &&
lpKCMSCnctProc )
{
lpImage->m_bDoCmsGamma = YES;
if (!lpImage->m_cmsXform)
{
if( ( !FrameTypeInfoEqual( TypeInfo, DstTypeInfo ) ) &&
ConvertCRCtoUID( &TypeInfo, &DstTypeInfo ) )
{
// save for later check to avoid a monitor reconnect.
lpImage->PtInfo = TypeInfo.ptInfo;
lpImage->m_cmsXform = ( *lpKCMSCnctProc )( &TypeInfo, &DstTypeInfo );
}
else
lpImage->m_cmsXform = NULL;
}
}
else
lpImage->m_cmsXform = NULL;
}
BOOL GradientImage( LPIMAGE lpImage, LPGRADIENT_PARMS lpParms)
{
LPFRAME lpFrame;
RECT rMask;
LPINT lpD;
FRMTYPEINFO TypeInfo;
int dx, dy, iCount;
int index, prev, next, pi, ni;
long ldx, ldy, x, y, xs, xe, ys, ye, asqrd, bsqrd, r;
LPDATAPROC lpVignetteProc;
ENGINE Engine;
BOOL DoHSL;
GRADIENT_DATA data;
int res;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
if (!(lpFrame = ImgGetBaseEditFrame(lpImage)))
return(FALSE);
res = FrameResolution(lpFrame);
data.x1 = lpParms->x1;
data.y1 = lpParms->y1;
data.x2 = lpParms->x2;
data.y2 = lpParms->y2;
ResConvertUL(lpParms->iBaseRes, res, &data.x1, &data.y1);
ResConvertLR(lpParms->iBaseRes, res, &data.x2, &data.y2);
dx = data.x2 - data.x1;
dy = data.y2 - data.y1;
data.SoftTransition = lpParms->SoftTransition;
data.lpPaletteLUT = NULL;
if (lpParms->Gradient == IDC_VIGLINEAR || lpParms->Gradient == IDC_VIGRADIAL)
{
if (abs(dx) <= 3 && abs(dy) <= 3)
return(FALSE);
}
else
{
if (abs(dx) <= 3 || abs(dy) <= 3)
return(FALSE);
}
data.xc = (data.x1 + data.x2) / 2;
data.yc = (data.y1 + data.y2) / 2;
if ( (data.nRepetitions = lpParms->RepeatCount) <= 0 )
data.nRepetitions = 1;
FrameGetTypeInfo(lpFrame, &TypeInfo);
DoHSL = (lpParms->VigColorModel+IDC_FIRST_MODEL) != IDC_MODEL_RGB &&
(TypeInfo.DataType > FDT_GRAYSCALE);
switch (lpParms->Gradient)
{
case IDC_VIGLINEAR:
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
data.sine = FGET(-dy, data.D);
data.cosine = FGET(dx, data.D);
data.xr = WHOLE(( rotx(data.x2, data.y2, data.x1, data.y1,
data.cosine, data.sine) ));
lpVignetteProc = (LPDATAPROC)linear_vignette_proc;
break;
case IDC_VIGRADIAL:
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
lpVignetteProc = (LPDATAPROC)radial_vignette_proc;
break;
case IDC_VIGCIRCLE:
data.x1 = data.xc;
data.y1 = data.yc;
data.y2 = data.yc;
dx = data.x2 - data.x1;
dy = data.y2 - data.y1;
if (!dx && !dy)
return(FALSE);
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
lpVignetteProc = (LPDATAPROC)radial_vignette_proc;
break;
case IDC_VIGSQUARE:
case IDC_VIGRECTANGLE:
data.ymin = min(data.y1, data.y2);
data.ymax = max(data.y1, data.y2);
data.xmin = min(data.x1, data.x2);
data.xmax = max(data.x1, data.x2);
ldx = data.xmin-data.xc; // upper left
ldy = data.ymin-data.yc;
data.m1 = (256L * ldy) / ldx;
data.b1 = data.ymin - ((data.m1 * data.xmin)/256L);
data.D1 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmax-data.xc; // upper right
ldy = data.ymin-data.yc;
data.m2 = (256L * ldy) / ldx;
data.b2 = data.ymin - ((data.m2 * data.xmax)/256L);
data.D2 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmax-data.xc; // lower right
ldy = data.ymax-data.yc;
data.m3 = (256L * ldy) / ldx;
data.b3 = data.ymax - ((data.m3 * data.xmax)/256L);
data.D3 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmin-data.xc; // lower left
ldy = data.ymax-data.yc;
data.m4 = (256L * ldy) / ldx;
data.b4 = data.ymax - ((data.m4 * data.xmin)/256L);
data.D4 = lsqrt((ldx*ldx)+(ldy*ldy));
lpVignetteProc = (LPDATAPROC)rectangle_vignette_proc;
break;
case IDC_VIGELLIPSE:
if ( !(data.lpD = (LPINT)Alloc((long)sizeof(int)*(TSIZE+1))) )
{
Message(IDS_EMEMALLOC);
return(FALSE);
}
iCount = TSIZE+1;
lpD = data.lpD;
while (--iCount >= 0)
*lpD++ = -1;
data.ymin = min(data.y1, data.y2);
data.ymax = max(data.y1, data.y2);
data.xmin = min(data.x1, data.x2);
data.xmax = max(data.x1, data.x2);
data.ea = dx/2;
data.eb = dy/2;
if (!data.ea || !data.eb)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
asqrd = data.ea*data.ea;
bsqrd = data.eb*data.eb;
// fill in a table with radius information for the
// ellipse. The radius for a given point would be
// starting from the center of the ellipse, going
// through to point, and where it intersects the
// edge of the ellipse. We need the radius for
// the D value used in the ellipse_proc, which is
// the maximum distance used for determining how to
// calculate the gradient, which is d/D. d is the
// distance of the point from the center, D is extracted
// from the table built below. The index of the table is
// formed from the ratio of sides of the triangle formed.
// This is like looking up the angle to see where the
// point would intersect the circle. But we calculate
// the radii ahead of time to speed things up.
if (data.ea > data.eb) // step in x
{
xs = data.xc - data.xc;
xe = data.xmax - data.xc;
for (x = xs; x <= xe; ++x)
{
y = ((data.eb*(long)lsqrt(asqrd - (x*x)))+(data.ea/2))/data.ea;
r = (x*x)+(y*y);
if (r <= 0)
r = 1;
index = ((x * x * (long)TSIZE)+(r/2)) / r;
index = bound(abs(index), 0, TSIZE);
data.lpD[index] = lsqrt(r);
}
}
else // step in y
{
ys = data.yc - data.yc;
ye = data.ymax - data.yc;
for (y = ys; y <= ye; ++y)
{
x = ((data.ea*(long)lsqrt(bsqrd - (y*y)))+(data.eb/2))/data.eb;
r = (x*x)+(y*y);
if (r <= 0)
r = 1;
index = ((y * y * (long)TSIZE)+(r/2)) / r;
index = bound(abs(index), 0, TSIZE);
data.lpD[index] = lsqrt(r);
}
}
// find the first valid entry in our table
for (index = 0; index <= TSIZE && data.lpD[index] < 0; ++index)
;
// see if we have any entries
if (index > TSIZE)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
// fill in all entries before first with value of first
while (--index >= 0)
data.lpD[index] = data.lpD[index+1];
// find last valid entry in table
for (index = TSIZE; index >= 0 && data.lpD[index] < 0; --index)
;
// see if we have any entries
if (index < 0)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
// fill in all entries after last with value of last
while (++index <= TSIZE)
data.lpD[index] = data.lpD[index-1];
// interpolate values of all empty cells
for (index = 0; index <= TSIZE; ++index)
{
if (data.lpD[index] < 0)
{
pi = index - 1;
prev = data.lpD[pi];
ni = index;
while (data.lpD[ni] < 0)
++ni;
next = data.lpD[ni];
// remember here that (index-pi) == 1
data.lpD[index] = prev + ((next-prev)/(ni-pi));
}
}
lpVignetteProc = (LPDATAPROC)ellipse_vignette_proc;
break;
default:
return(FALSE);
break;
}
switch(TypeInfo.DataType)
{
case FDT_LINEART :
case FDT_GRAYSCALE :
data.lpProcessProc = (LPVIGPROC)ProcessVignette8;
break;
case FDT_PALETTECOLOR:
data.lpProcessProc = (LPVIGPROC)ProcessVignette8P;
data.lpPaletteLUT = CreatePaletteLut15(TypeInfo.ColorMap->RGBData,
TypeInfo.ColorMap->NumEntries, NULL, NULL);
break;
case FDT_RGBCOLOR :
data.lpProcessProc = (LPVIGPROC)ProcessVignette24;
break;
case FDT_CMYKCOLOR :
data.lpProcessProc = (LPVIGPROC)ProcessVignette32;
break;
}
data.lpMidpointTable = BuildMidPointTable(
DoHSL,
TypeInfo.DataType,
lpParms->Midpoint,
&lpParms->StartColor,
&lpParms->EndColor,
&data );
ImgGetMaskRect( lpImage, &rMask );
data.lplD = (LPLONG)Alloc((long)sizeof(long)*(long)RectWidth(&rMask));
data.lpld = (LPLONG)Alloc((long)sizeof(long)*(long)RectWidth(&rMask));
if (!data.lpld || !data.lplD || !data.lpMidpointTable ||
(TypeInfo.DataType == FDT_PALETTECOLOR && !data.lpPaletteLUT))
{
if (lpParms->Gradient == IDC_VIGELLIPSE)
FreeUp((LPTR)data.lpD);
if (data.lplD)
FreeUp((LPTR)data.lplD);
if (data.lpld)
FreeUp((LPTR)data.lpld);
if (data.lpMidpointTable)
FreeUp((LPTR)data.lpMidpointTable);
if (data.lpPaletteLUT)
FreeUp(data.lpPaletteLUT);
return(FALSE);
}
SetEngineDraw(&Engine,lpVignetteProc,lpParms->VigOpacity,lpParms->VigMergeMode);
Engine.lpParam = &data;
Engine.fThread = NO;
lpParms->Common.StatusCode = LineEngineSelObj(lpImage,&Engine,lpParms->Common.idDirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
lpParms->Common.UpdateType = UT_AREA;
lpParms->Common.rUpdateArea = Engine.rUpdate;
}
FreeUp((LPTR)data.lpld);
FreeUp((LPTR)data.lplD);
FreeUp((LPTR)data.lpMidpointTable);
if (data.lpPaletteLUT)
FreeUp(data.lpPaletteLUT);
if (lpParms->Gradient == IDC_VIGELLIPSE)
FreeUp((LPTR)data.lpD);
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
