void ResizePuzzleFrame(LPFRAME lpNewFrame)
{
LPFRAME lpOldFrame;
LPFRAME lpPrevFrame;
double fXMult;
double fYMult;
double fMult;
int iXNew;
int iYNew;
int iXOld;
int iYOld;
lpOldFrame = ImgGetBaseEditFrame(lpImage);
iXNew = FrameXSize(lpNewFrame);
iYNew = FrameYSize(lpNewFrame);
iXOld = FrameXSize(lpOldFrame);
iYOld = FrameYSize(lpOldFrame);
fXMult = (double)iXOld / (double)iXNew;
fYMult = (double)iYOld / (double)iYNew;
if (fXMult < fYMult)
fMult = fXMult;
else fMult = fYMult;
iXNew = (int)((double)iXNew * fMult);
iYNew = (int)((double)iYNew * fMult);
lpPrevFrame = lpNewFrame;
lpNewFrame = SizeFrame(
lpNewFrame,
iXNew,
iYNew,
FrameResolution(lpOldFrame),
FALSE);
FrameClose(lpPrevFrame);
iXNew = (FrameXSize(lpOldFrame) - FrameXSize(lpNewFrame)) / 2;
iYNew = (FrameYSize(lpOldFrame) - FrameYSize(lpNewFrame)) / 2;
iXNew = max(0, iXNew);
iYNew = max(0, iYNew);
lpPrevFrame = lpNewFrame;
lpNewFrame = ExpandFrame(lpNewFrame,
FrameXSize(lpOldFrame), /*pix*/
FrameYSize(lpOldFrame), /*lin*/
iXNew, /*left*/
iYNew, /*top*/
FrameGetBackground(lpOldFrame));
ImgReplaceBaseEditFrame(lpImage, lpNewFrame);
FrameClose(lpPrevFrame);
}
void CImage::GetImageRect(LPRECT lpRect)
{
LPFRAME lpFrame;
lpFrame = GetBaseEditFrame();
SetRect(lpRect, 0, 0, FrameXSize(lpFrame)-1, FrameYSize(lpFrame)-1);
}
BOOL CImage::Create()
{
// if a command list was not passed in then create one
if (!lpCmdList)
{
// if we don't have a command list, create one
lpCmdList = CreateCommandList();
if ( !lpCmdList)
return(FALSE);
}
// link command list back to image
lpCmdList->ThreadData.lpImage = this;
// setup image information for easy access
LPFRAME lpFrame = GetBaseEditFrame();
npix = FrameXSize(lpFrame);
nlin = FrameYSize(lpFrame);
// if using threading and no command list already existence
// create the command thread
#ifdef WIN32
if (Control.UseThreading)
{
lstrcpy(lpCmdList->ThreadData.ThreadInfo.szThreadName,
filename(CurFile));
}
#endif
return(TRUE);
}
LOCAL LPFRAME ConvertFrame(LPFRAME lpSrcFrame, FRMTYPEINFO OutTypeInfo, CFrameTypeConvert *pTypeConvert)
/***********************************************************************/
{
int y, Xsize, Ysize;
LPFRAME lpDstFrame;
FRMTYPEINFO InTypeInfo;
LPTR lpSrc, lpDst;
CFrameTypeConvert TypeConvert;
Xsize = FrameXSize(lpSrcFrame);
Ysize = FrameYSize(lpSrcFrame);
FrameGetTypeInfo(lpSrcFrame, &InTypeInfo);
if (!pTypeConvert)
{
if (!TypeConvert.Init(InTypeInfo, OutTypeInfo, Xsize))
{
Message(IDS_EMEMALLOC);
return(NULL);
}
pTypeConvert = &TypeConvert;
}
lpDstFrame = FrameOpen(OutTypeInfo, Xsize, Ysize, FrameResolution(lpSrcFrame));
if (!lpDstFrame)
{
FrameError(IDS_EPROCESSOPEN);
return(NULL);
}
ProgressBegin(1, 0);
for (y = 0; y < Ysize; ++y)
{
if (AstralClockCursor(y, Ysize, YES))
{
FrameClose(lpDstFrame);
goto ExitError;
}
if (!(lpSrc = FramePointerRaw(lpSrcFrame, 0, y, NO)))
continue;
if (!(lpDst = FramePointerRaw(lpDstFrame, 0, y, YES)))
continue;
pTypeConvert->ConvertData(lpSrc, lpDst, y, Xsize);
}
ProgressEnd();
return(lpDstFrame);
ExitError:
ProgressEnd();
return(NULL);
}
void CImage::EditedObjectFrame(LPOBJECT lpObject, int iDirty,
LPRECT lpEditRect,
LPFRAME lpDataFrame, LPFRAME lpAlphaFrame)
{
LPALPHA lpAlpha;
BOOL fEditedData, fEditedAlpha, fBase;
fBase = (lpObject == GetBase());
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 (lpObject->lpText)
lpObject->lpText->Dirty = (iDirty == IDS_UNDOEDITTEXT)? FALSE:TRUE;
if (fEditedData)
{
fChanged = YES;
if (!(Control.NoUndo || fDisableUndos) && !lpObject->fUndoFailed)
lpObject->DataDirty = iDirty;
if (lpDataFrame)
{
PixmapNewFrame(&lpObject->Pixmap, lpDataFrame, lpEditRect, Control.UseApply);
if (lpObject == GetBase())
{
npix = FrameXSize(lpDataFrame);
nlin = FrameYSize(lpDataFrame);
}
}
}
if (fEditedAlpha)
{
if (lpObject != GetBase())
fChanged = YES;
if (!(Control.NoUndo || fDisableUndos) && (!fBase || Control.UndoMasks) &&
!lpObject->fUndoFailed)
lpObject->AlphaDirty = iDirty;
if (lpAlpha && lpAlphaFrame)
PixmapNewFrame(&lpAlpha->Pixmap, lpAlphaFrame, lpEditRect, Control.UseApply);
}
if (Control.NoUndo || fDisableUndos)
PurgeObjects();
if (!(Control.NoUndo || fDisableUndos) && !lpObject->fUndoFailed && !lpObject->fBothDirty)
lpObject->fBothDirty = fEditedData && fEditedAlpha;
if (lpEditRect)
OffsetRect(lpEditRect, lpObject->rObject.left, lpObject->rObject.top);
}
void RemoveCodedBackground()
{
LPFRAME lpFrame;
int x, y;
int Width;
int Height;
LPTR lpSrcLine;
BYTE r, g, b;
if (!lpImage) return;
ImgCombineObjects(lpImage, TRUE, FALSE, TRUE);
lpFrame = ImgGetBaseEditFrame(lpImage);
if (!lpFrame) return;
Width = FrameXSize (lpFrame);
Height = FrameYSize (lpFrame);
for (y=0;y<Height;y++)
{
AstralClockCursor( y, Height, NO );
lpSrcLine = FramePointer (lpFrame,0,y,TRUE);
for (x=0;x<Width;x++)
{
RGBS Pixel;
FrameGetRGB (lpFrame,lpSrcLine,&Pixel,1);
r = Pixel.red;
g = Pixel.green;
b = Pixel.blue;
if (r >= 100 && !g && !b)
{ // a dot
Pixel.red = 255;
Pixel.green = 255;
Pixel.blue = 255;
FrameSetRGB (lpFrame,&Pixel,lpSrcLine,1);
}
else
if ( (r != g) || (g != b) )
{ // not white or black
Pixel.red = 0;
Pixel.green = 0;
Pixel.blue = 0;
FrameSetRGB (lpFrame,&Pixel,lpSrcLine,1);
}
lpSrcLine += 3;
} // Width
} // Height
}
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 );
}
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);
}
