LPTR FAR EXPORT ExportDataPointer(int x, int y, BOOL bModify)
{
LPIMAGE lpImage = GetActiveImage();
int iPixelCount = iExportXSize - x;
if (x <= iExportXSize || (y <= iExportYSize))
ImgGetLine( lpImage, NULL, x, y, iPixelCount, lpExportBuffer );
return(lpExportBuffer);
}
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();
}
int TiffWriteFrame(
int oFile,
LPSTR lpFileName,
LPOBJECT lpObject,
LPFRAME lpFrame,
LPRECT lpRect,
int flag,
BOOL fCompressed,
BOOL bEscapable)
{
TAG tag;
int y, bpl, npix, nlin, ofp;
LPLONG lngptr,boffptr;
LPWORD shtptr;
DWORD byteoffset;
WORD i, numtags, photomet, samples;
BYTE bpp;
LPWORD lpRed, lpGreen, lpBlue;
RGBS RGBmap[256];
LPTR lp, lpBuffer, lpOutputPointer, lpImgScanline;
FNAME temp;
RECT rSave;
BOOL compressInit;
#ifdef STATIC16 // only in new framelib
CFrameTypeConvert FrameTypeConvert;
FRMTYPEINFO SrcTypeInfo;
FRMTYPEINFO DstTypeInfo;
#endif
lpBuffer = NULL;
lpImgScanline = NULL;
if (!lpFrame)
return( -1 );
ProgressBegin(1,0);
if ((ofp = oFile) < 0)
bEscapable = !FileExists(lpFileName);
if ((ofp = oFile) < 0 && (ofp = _lcreat(lpFileName,0)) < 0)
{
Message( IDS_EWRITE, lpFileName );
goto Exit;
}
if (lpRect)
rSave = *lpRect;
else
{
rSave.top = rSave.left = 0;
rSave.bottom = FrameYSize(lpFrame)-1;
rSave.right = FrameXSize(lpFrame)-1;
}
npix = RectWidth(&rSave);
nlin = RectHeight(&rSave);
switch(flag)
{
case IDC_SAVELA :
case IDC_SAVESP :
bpp = 1;
bpl = ((npix + 7) / 8);
numtags = 11;
photomet = 1;
samples = 1;
break;
case IDC_SAVECT :
bpp = 8;
bpl = npix;
numtags = 11;
photomet = 1;
samples = 1;
break;
case IDC_SAVE4BITCOLOR :
case IDC_SAVE8BITCOLOR :
bpp = 8;
bpl = npix;
numtags = 12;
photomet = 3;
samples = 1;
break;
case IDC_SAVE24BITCOLOR :
bpp = 24;
bpl = npix * 3;
numtags = 11;
photomet = 2;
samples = 3;
break;
case IDC_SAVE32BITCOLOR :
bpp = 32;
bpl = npix * 4;
numtags = 11;
photomet = 5;
samples = 4;
break;
default :
goto Exit;
break;
}
compressInit = NO;
if ( bpp == 1 )
{
AllocLines( &lpBuffer, 1, npix, 2 );
AllocLines( &lpImgScanline, 1, npix, 1 );
}
else
{
AllocLines( &lpBuffer, 1, max(bpl, FrameByteWidth(lpFrame)), 1 );
AllocLines( &lpImgScanline, 1, max(bpl, FrameByteWidth(lpFrame)), 1 );
}
if ( !lpBuffer || !lpImgScanline )
{
Message( IDS_EMEMALLOC );
_lclose( ofp );
goto Exit;
}
/* first location where any extra data can be stored */
/* 10 byte header + all tag data (12 bytes each) + 4 bytes (null ifd) */
byteoffset = 10 + (numtags * sizeof(TAG)) + 4;
shtptr = (LPWORD)LineBuffer[0];
SetNextWord(&shtptr, 0x4949); /* byte order is LSB,MSB */
SetNextWord(&shtptr, 0x2a); /* tiff version number */
SetNextWord(&shtptr, 8); /* byte offset to first image file directory LSW */
SetNextWord(&shtptr, 0); /* byte offset to first image file directory MSW */
SetNextWord(&shtptr, numtags); /* number of entries in IFD */
tag.tagno = 0xff; /* tag 0xff, subfile type */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = 1; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x100; /* tag 0x100, number of pixels */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = npix; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x101; /* tag 0x101, number of lines */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = nlin; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x102; /* tag 0x102, bits per sample */
tag.type = 3; /* field type is short */
tag.length = samples; /* number of values */
if ( samples == 3 || samples == 4)
{
tag.value = byteoffset; /* deferred value */
byteoffset += (samples*sizeof(short));
}
else
tag.value = bpp; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x103; /* tag 0x103, compression */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = (fCompressed ? 5:1); /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x106; /* tag 0x106,photometric inter.(0 = black) */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = photomet; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x111; /* tag 0x111, strip byte offsets */
tag.type = 4; /* field type is long */
tag.length = 1; /* number of values */
tag.value = 0; /* dummy location of the start of image data */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
boffptr = (LPLONG)(shtptr+4); // make boffptr point at tag.value
shtptr += 6;
tag.tagno = 0x115; /* tag 0x115, samples per pixel*/
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = samples; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x11a; /* tag 0x11a, xresolution */
tag.type = 5; /* field type is rational */
tag.length = 1; /* number of values */
tag.value = byteoffset; /* deferered value */
byteoffset += 8;
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x11b; /* tag 0x11b, yresolution */
tag.type = 5; /* field type is rational */
tag.length = 1; /* number of values */
tag.value = byteoffset; /* deferred value */
byteoffset += 8;
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
tag.tagno = 0x11c; /* tag 0x11c, planar configuration */
tag.type = 3; /* field type is short */
tag.length = 1; /* number of values */
tag.value = 1; /* value */
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
if ( photomet == 3 ) // Palette color map
{
tag.tagno = 0x140; /* tag 0x140, colormap */
tag.type = 3; /* field type is short */
tag.length = 3*256; /* number of values */
tag.value = byteoffset; /* value */
byteoffset += (2*3*256);
#ifdef _MAC
SwapTag(&tag);
#endif
lmemcpy((LPTR)shtptr,(LPTR)&tag.tagno,12);
shtptr += 6;
}
// Copy the NULL Image File Directory pointer
SetNextWord(&shtptr, 0); /* pointer to next IFD */
SetNextWord(&shtptr, 0);
// Copy out the Bits Per Sample, if multiple samples
if ( samples == 3 ) // The bits per pixel per sample
{
SetNextWord(&shtptr, 8);
SetNextWord(&shtptr, 8);
SetNextWord(&shtptr, 8);
}
// Copy out the Bits Per Sample, if multiple samples
if ( samples == 4 ) // The bits per pixel per sample
{
SetNextWord(&shtptr, 8);
SetNextWord(&shtptr, 8);
SetNextWord(&shtptr, 8);
SetNextWord(&shtptr, 8);
}
// Copy out the X and Y resolution fields
lngptr = (LPLONG)shtptr;
#ifdef PPVIDEO
SetNextLong(&lngptr, FrameResolution(lpFrame) * 2); /* xreso numerator */
SetNextLong(&lngptr, 2); /* xreso denominator */
SetNextLong(&lngptr, FrameResolution(lpFrame) * 2); /* yreso numerator */
SetNextLong(&lngptr, 2); /* yreso denominator */
#else
SetNextLong(&lngptr, FrameResolution(lpFrame)); /* xreso numerator */
SetNextLong(&lngptr, 1); /* xreso denominator */
SetNextLong(&lngptr, FrameResolution(lpFrame)); /* yreso numerator */
SetNextLong(&lngptr, 1); /* yreso denominator */
#endif
*boffptr = byteoffset;
#ifdef _MAC
swapl((LPDWORD)boffptr);
#endif
// Write out the tags, the bpp, and the resolutions
i = (LPTR)lngptr - (LPTR)LineBuffer[0];
if ( _lwrite(ofp, LineBuffer[0], i) != i )
goto BadWrite;
// Write the color palette, if necessary
if ( photomet == 3 ) // Palette color map
{
if (!OptimizeBegin(lpObject, lpFrame, RGBmap, 256,
NULL /*(LPROC)AstralClockCursor*/, // No Progress report
NO, Convert.fOptimize, Convert.fScatter, Convert.fDither, npix))
goto BadWrite;
lpRed = (LPWORD)LineBuffer[0];
lpGreen = lpRed + 256;
lpBlue = lpGreen + 256;
for ( i=0; i<256; i++ )
{
*lpRed++ = (WORD)RGBmap[i].red << 8;
*lpGreen++ = (WORD)RGBmap[i].green << 8;
*lpBlue++ = (WORD)RGBmap[i].blue << 8;
}
if ( _lwrite(ofp, LineBuffer[0], 2*3*256) != 2*3*256 )
goto BadWrite;
}
if ( fCompressed )
{
if ( CompressLZW( ofp, NULL, 0 ) < 0 ) /* Initialize */
goto BadWrite;
compressInit = YES;
}
switch(bpp)
{
case 1 :
for( y=rSave.top; y<=rSave.bottom; y++ )
{
if (AstralClockCursor( y-rSave.top, nlin, bEscapable ))
goto Cancelled;
if ( lpObject )
{
if (!ImgGetLine( NULL, lpObject, rSave.left, y,
(rSave.right - rSave.left) + 1, lpImgScanline))
goto BadRead;
lp = lpImgScanline;
}
else
{
if ( !(lp = FramePointer( lpFrame, rSave.left, y, NO )) )
goto BadRead;
}
if (FrameDepth(lpFrame) == 0)
{
if (flag == IDC_SAVESP)
diffuse( 0, i, 0, NULL, lp, npix, lpBuffer );
else
con2la( lp, npix, lpBuffer );
}
else
{
ConvertData( lp, FrameDepth(lpFrame), npix, lpBuffer+npix, 1 );
if ( flag == IDC_SAVESP )
diffuse( 0, i, 0, NULL, lpBuffer+npix, npix, lpBuffer );
else
con2la( lpBuffer+npix, npix, lpBuffer );
}
if ( fCompressed )
{
if ( CompressLZW( ofp, lpBuffer, bpl ) < 0 )
goto BadWrite;
}
else
{
if ( _lwrite( ofp, (LPSTR)lpBuffer, bpl ) != bpl )
goto BadWrite;
}
}
break;
case 8 :
for( y=rSave.top; y<=rSave.bottom; y++ )
{
if (AstralClockCursor( y-rSave.top, nlin, bEscapable ))
goto Cancelled;
if ( lpObject )
{
if (!ImgGetLine( NULL, lpObject, rSave.left, y,
(rSave.right - rSave.left) + 1, lpImgScanline))
goto BadRead;
lp = lpImgScanline;
}
else
{
if ( !(lp = FramePointer( lpFrame, rSave.left, y, NO )) )
goto BadRead;
}
if (FrameDepth(lpFrame) == 0)
{
if ( photomet == 3 ) // If we are storing palette color
OptimizeData(0, y, npix, lp, lpBuffer, 1 );
else
ConvertData( lp, 1, npix, lpBuffer, 1 );
}
else
{
if ( photomet == 3 ) // If we are storing palette color
OptimizeData(0, y, npix, lp, lpBuffer, FrameDepth(lpFrame));
else
ConvertData( lp, FrameDepth(lpFrame), npix, lpBuffer, 1 );
}
if ( fCompressed )
{
if ( CompressLZW( ofp, lpBuffer, bpl ) < 0 )
goto BadWrite;
}
else
{
if ( _lwrite( ofp, (LPSTR)lpBuffer, bpl ) != bpl )
goto BadWrite;
}
}
break;
case 24 :
for( y=rSave.top; y<=rSave.bottom; y++ )
{
if (AstralClockCursor( y-rSave.top, nlin, bEscapable ))
goto Cancelled;
if ( lpObject )
{
if (!ImgGetLine( NULL, lpObject, rSave.left, y,
(rSave.right - rSave.left) + 1, lpImgScanline))
goto BadRead;
lp = lpImgScanline;
}
else
{
if ( !(lp = FramePointer( lpFrame, rSave.left, y, NO )) )
goto BadRead;
}
if (FrameType(lpFrame) != FDT_RGBCOLOR)
{
if (FrameType(lpFrame) != FDT_LINEART)
{
#ifdef STATIC16
SrcTypeInfo.DataType = FrameType(lpFrame);
SrcTypeInfo.ColorMap = NULL;
SrcTypeInfo.DataType = FDT_RGBCOLOR;
SrcTypeInfo.ColorMap = NULL;
FrameTypeConvert.Init(SrcTypeInfo, DstTypeInfo, npix);
FrameTypeConvert.ConvertData((LPTR)lp, (LPTR)lpBuffer, y, npix);
#else
FrameTypeConvert(
(LPTR)lp, FrameType(lpFrame), NULL,
y,
(LPTR)lpBuffer, FDT_RGBCOLOR, NULL,
npix);
#endif
}
else
{
#ifdef STATIC16
SrcTypeInfo.DataType = FDT_GRAYSCALE;
SrcTypeInfo.ColorMap = NULL;
SrcTypeInfo.DataType = FDT_RGBCOLOR;
SrcTypeInfo.ColorMap = NULL;
FrameTypeConvert.Init(SrcTypeInfo, DstTypeInfo, npix);
FrameTypeConvert.ConvertData((LPTR)lp, (LPTR)lpBuffer, y, npix);
#else
FrameTypeConvert(
(LPTR)lp, FDT_GRAYSCALE, NULL,
y,
(LPTR)lpBuffer, FDT_RGBCOLOR, NULL,
npix);
#endif
}
lpOutputPointer = lpBuffer;
}
else
{
lpOutputPointer = lp;
}
if ( fCompressed )
{
if ( CompressLZW( ofp, lpOutputPointer, bpl ) < 0 )
goto BadWrite;
}
else
{
if ( _lwrite( ofp, (LPSTR)lpOutputPointer, bpl ) != bpl )
goto BadWrite;
}
}
break;
case 32 :
for( y=rSave.top; y<=rSave.bottom; y++ )
{
if (AstralClockCursor( y-rSave.top, nlin, bEscapable ))
goto Cancelled;
if ( lpObject )
{
if (!ImgGetLine( NULL, lpObject, rSave.left, y,
(rSave.right - rSave.left) + 1, lpImgScanline))
goto BadRead;
lp = lpImgScanline;
}
else
{
if ( !(lp = FramePointer( lpFrame, rSave.left, y, NO )) )
goto BadRead;
}
if (FrameType(lpFrame) != FDT_CMYKCOLOR)
{
if (FrameType(lpFrame) != FDT_LINEART)
{
#ifdef STATIC16
SrcTypeInfo.DataType = FrameType(lpFrame);
SrcTypeInfo.ColorMap = NULL;
SrcTypeInfo.DataType = FDT_CMYKCOLOR;
SrcTypeInfo.ColorMap = NULL;
FrameTypeConvert.Init(SrcTypeInfo, DstTypeInfo, npix);
FrameTypeConvert.ConvertData((LPTR)lp, (LPTR)lpBuffer, y, npix);
#else
FrameTypeConvert(
(LPTR)lp, FrameType(lpFrame), NULL,
y,
(LPTR)lpBuffer, FDT_CMYKCOLOR, NULL,
npix);
#endif
}
else
{
#ifdef STATIC16
SrcTypeInfo.DataType = FDT_GRAYSCALE;
SrcTypeInfo.ColorMap = NULL;
SrcTypeInfo.DataType = FDT_CMYKCOLOR;
SrcTypeInfo.ColorMap = NULL;
FrameTypeConvert.Init(SrcTypeInfo, DstTypeInfo, npix);
FrameTypeConvert.ConvertData((LPTR)lp, (LPTR)lpBuffer, y, npix);
#else
FrameTypeConvert(
(LPTR)lp, FDT_GRAYSCALE, NULL,
y,
(LPTR)lpBuffer, FDT_CMYKCOLOR, NULL,
npix);
#endif
}
lpOutputPointer = lpBuffer;
}
else
{
lpOutputPointer = lp;
}
if ( fCompressed )
{
if ( CompressLZW( ofp, lpOutputPointer, bpl ) < 0 )
goto BadWrite;
}
else
{
if ( _lwrite( ofp, (LPSTR)lpOutputPointer, bpl ) != bpl )
goto BadWrite;
}
}
break;
}
if ( compressInit )
if ( CompressLZW( ofp, NULL, 0 ) < 0 ) /* Terminate */
goto BadWrite;
compressInit = NO;
OptimizeEnd();
if (ofp != oFile)
_lclose(ofp);
if (lpBuffer)
FreeUp( lpBuffer );
if (lpImgScanline)
FreeUp( lpImgScanline );
ProgressEnd();
return( 0 );
BadWrite:
Message( IDS_EWRITE, lpFileName );
goto BadTiff;
BadRead:
Message( IDS_EREAD, (LPTR)Control.RamDisk );
Cancelled:
BadTiff:
if ( compressInit )
if ( CompressLZW( ofp, NULL, 0 ) < 0 ) /* Terminate */
goto BadWrite;
compressInit = NO;
OptimizeEnd();
if (ofp != oFile)
_lclose(ofp);
lstrcpy(temp,lpFileName);
FileDelete(temp);
Exit:
if (lpBuffer)
FreeUp( lpBuffer );
if (lpImgScanline)
FreeUp( lpImgScanline );
ProgressEnd();
return( -1 );
}
BOOL CImage::CombineObjects(BOOL fNoUndo, BOOL fCreateMask,
BOOL fForceIt, ITEMID idDirty, LPRECT lpUpdateRect)
{
LPOBJECT lpBase, lpObject;
int iWidth, iHeight, depth, y, iImageWidth, iImageHeight;
LPTR lpDataBuf, lpMaskPtr;
RECT rFloaters, rMask, rTemp;
BOOL fNewMask;
LPMASK lpMask;
UNDO_TYPE UndoType;
AstralSetRectEmpty(lpUpdateRect);
// get rectangle for all floating objects
if (!GetFloatingObjectsRect(&rFloaters))
return(FALSE);
// Get base object
lpBase = GetBase();
// get pixmap information
PixmapGetInfo(&lpBase->Pixmap, PMT_EDIT, &iImageWidth, &iImageHeight, &depth, NULL);
BoundRect(&rFloaters, 0, 0, iImageWidth-1, iImageHeight-1);
iWidth = RectWidth(&rFloaters);
iHeight = RectHeight(&rFloaters);
// allocate buffer for alpha channel combining
if (!(lpDataBuf = Alloc((long)iWidth*depth)))
{
Message(IDS_EMEMALLOC);
return(FALSE);
}
lpMask = NULL;
if (fCreateMask)
{
lpMask = GetMaskEx(OFF, Control.NoUndo, &fNewMask, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
// do it to it
ProgressBegin(lpMask != NULL ? 2 : 1, idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
if (!fNoUndo)
{
UndoType = UT_DATA|UT_DELETEOBJECTS;
if (lpMask)
{
if (fNewMask)
UndoType |= UT_CREATEMASK;
else
UndoType |= UT_ALPHA;
}
if (!ImgEditInit(this, ET_OBJECT, UndoType, lpBase))
{
if (!fForceIt)
{
ProgressEnd();
FreeUp(lpDataBuf);
return(FALSE);
}
}
}
// do it to it
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
ImgGetLine(this, NULL, rFloaters.left, y, iWidth, lpDataBuf);
PixmapWrite(&lpBase->Pixmap, PMT_EDIT, rFloaters.left, y, iWidth,
lpDataBuf, iWidth);
}
ProgressEnd();
if (lpMask && (lpObject = GetNextObject(lpBase, YES, NO)))
{
ProgressBegin(1, 0);
for (y = rFloaters.top; y <= rFloaters.bottom; ++y)
{
AstralClockCursor(y-rFloaters.top, iHeight, NO);
lpMaskPtr = PixmapPtr(&lpMask->Pixmap, PMT_EDIT, rFloaters.left,
y, YES);
if (!lpMaskPtr)
continue;
ImgMaskLoad(this, lpObject, NULL,
rFloaters.left, y, iWidth, lpDataBuf, NO,
CR_OR, 0, 0);
CombineData(lpDataBuf, lpMaskPtr, iWidth, NO, CR_OR);
}
MaskRectUpdate(lpMask, &rMask);
ProgressEnd();
}
FreeUp(lpDataBuf);
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
lpObject = lpBase;
while (lpObject = GetNextObject(lpObject, YES, NO))
{
// always let undo stuff initialize this
// lpObject->fUndoDeleted = NO;
lpObject->fDeleted = YES;
}
//DeleteObjects((LPOBJECT)lpBase->lpNext, NO);
if (!fNoUndo)
ImgEditedObject(this, lpBase, idDirty, &rFloaters);
else
fChanged = YES;
//if ( Tool.hRibbon )
// SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
ProgressEnd();
//SetupMiniViews(NULL, NO);
return(TRUE);
}
BOOL PSPrint(
LPIMAGE lpImage,
LPFRAME lpFrame,
BYTE cSep,
int xSrc,
int ySrc,
int dxSrc,
int dySrc,
int xDest,
int yDest,
int dxDest,
int dyDest,
int iPrResX,
int iPrResY )
{
int y, yline, ystart, ylast, x, depth;
LFIXED yrate, yoffset;
LPTR lpBuffer[5], p1Buf, p2Buf, p3Buf, p4Buf;
LPSTR lpAngle, lpRuling;
LPTR lpImageData;
BOOL Negative, Asciize;
STRING szAngle, szRuling;
long lSize;
LPFRAME lpBaseFrame;
#define C_ANGLE Halftone.ScreenAngle[0]
#define M_ANGLE Halftone.ScreenAngle[1]
#define Y_ANGLE Halftone.ScreenAngle[2]
#define K_ANGLE Halftone.ScreenAngle[3]
#define C_RULING Halftone.ScreenRuling[0]
#define M_RULING Halftone.ScreenRuling[1]
#define Y_RULING Halftone.ScreenRuling[2]
#define K_RULING Halftone.ScreenRuling[3]
ProgressBegin(1,0);
lpAngle = szAngle;
lpRuling = szRuling;
Negative = Page.Negative;
Asciize = !Page.BinaryPS;
PS_ID( IDS_PS_DICTDEF );
/* Send the definition of the read data function */
if ( Asciize )
{
PS_ID( IDS_PS_HEXDATA );
}
else
{
PS_ID( IDS_PS_BINDATA );
}
if ( !Halftone.DoHalftoning )
goto HalftoningDone;
/* Send the definition of the spot function */
if ( Halftone.DotShape == IDC_ELLIPSEDOT )
{
PS_ID( IDS_PS_ELLDOT1 );
PS_ID( IDS_PS_ELLDOT2 );
}
else
if ( Halftone.DotShape == IDC_SQUAREDOT )
{
PS_ID( IDS_PS_SQUDOT );
}
else
if ( Halftone.DotShape == IDC_CIRCLEDOT )
{
PS_ID( IDS_PS_CIRDOT );
}
else
if ( Halftone.DotShape == IDC_TRIANGLEDOT )
{
PS_ID( IDS_PS_TRIDOT );
}
else
if ( Halftone.DotShape == IDC_PROPELLERDOT )
{
PS_ID( IDS_PS_PROPDOT );
}
if ( Page.OutputType == IDC_PRINT_BLACKSEPS ||
Page.OutputType == IDC_PRINT_GRAY )
{ // Setup the "image" screen angles and freqs based on the sep
if ( cSep == 'C' )
{
FixedAscii( C_ANGLE, lpAngle, -2 );
FixedAscii( C_RULING, lpRuling, -2 );
}
else
if ( cSep == 'M' )
{
FixedAscii( M_ANGLE, lpAngle, -2 );
FixedAscii( M_RULING, lpRuling, -2 );
}
else
if ( cSep == 'Y' )
{
FixedAscii( Y_ANGLE, lpAngle, -2 );
FixedAscii( Y_RULING, lpRuling, -2 );
}
else
//if ( cSep == 'K' || cSep == 'X' || !cSep )
{
FixedAscii( K_ANGLE, lpAngle, -2 );
FixedAscii( K_RULING, lpRuling, -2 );
}
PS_ID2( IDS_PS_SETSCREEN, lpRuling, lpAngle );
}
else
{ // Setup the "colorimage" screen angles and frequencies
PS_ID( IDS_PS_COLOREXT );
PS_ID( IDS_PS_STARTBLOCK );
FixedAscii( C_RULING, lpRuling, -2 );
FixedAscii( C_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( M_RULING, lpRuling, -2 );
FixedAscii( M_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( Y_RULING, lpRuling, -2 );
FixedAscii( Y_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( K_RULING, lpRuling, -2 );
FixedAscii( K_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
PS_ID( IDS_PS_SETCOLORSCREEN );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
FixedAscii( K_RULING, lpRuling, -2 );
FixedAscii( K_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSCREEN, lpRuling, lpAngle );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
}
HalftoningDone:
// Setup a null transfer curve unless doing seps w/black ink (image operator)
if ( Page.OutputType == IDC_PRINT_BLACKSEPS )
{
PS_ID( IDS_PS_BLACKSEPS );
}
else
if ( Page.OutputType == IDC_PRINT_COLORSEPS )
{
PS_ID( IDS_PS_COLORSEPS );
}
else
{
PS_ID( IDS_PS_NOINVERT );
}
PS_ID( IDS_PS_CHECKINVERT );
/* Send the destination point (x,y) in spots */
PS_ID2( IDS_PS_TRANSLATE, xDest, yDest );
/* Send the destination size (w,h) in spots */
PS_ID2( IDS_PS_SCALE, dxDest, dyDest );
if (lpImage)
lpBaseFrame = ImgGetBaseEditFrame(lpImage);
else
lpBaseFrame = lpFrame;
/* Compute how many pixels we're going to send */
/* Never send more than 16 pixels per halftone grid (or 4/grid in x and y) */
if (depth = FrameDepth( lpBaseFrame ))
{
if ( iPrResX < 600 )
dxDest /= 4;
else dxDest /= 8;
if ( iPrResY < 600 )
dyDest /= 4;
else dyDest /= 8;
}
if (depth == 0) depth = 1;
/* Let the printer do any upsizing */
if ( dySrc < dyDest )
{
yrate = UNITY;
dxDest = dxSrc;
dyDest = dySrc;
}
else yrate = FGET( dySrc, dyDest );
/* Send the definition for the line buffers */
PS_ID1( IDS_PS_LINE1, dxDest );
PS_ID1( IDS_PS_LINE2, dxDest );
PS_ID1( IDS_PS_LINE3, dxDest );
PS_ID1( IDS_PS_LINE4, dxDest );
PS_ID1( IDS_PS_LINE5, dxDest );
if ( cSep ) // Plane at a time
{ // cSep is either 'C', 'M', 'Y', 'K', 'X'(gray) or NULL
if ( Page.OutputType == IDC_PRINT_COLORSEPS )
{
PS_ID( IDS_PS_DOCOLORSEPDEF );
}
else
{
PS_ID( IDS_PS_NOCOLORSEPDEF );
}
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLORSEPVAL );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
if ( cSep == 'C' )
{
PS_ID( IDS_PS_SEPCYAN );
}
else
if ( cSep == 'M' )
{
PS_ID( IDS_PS_SEPMAGENTA );
}
else
if ( cSep == 'Y' )
{
PS_ID( IDS_PS_SEPYELLOW );
}
else
if ( cSep == 'K' || cSep == 'X' )
{
PS_ID( IDS_PS_SEPBLACK );
}
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_IMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
else
if ( Page.Type == IDC_PRINTER_IS_CMYK )
{
if (Page.OutputType == IDC_PRINT_COLORGRAY)
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_GETLINE5 );
PS_ID( IDS_PS_POP );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_GETLINE5 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
else
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_NOIMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
}
else
if ( Page.Type == IDC_PRINTER_IS_RGB )
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
PS_ID( IDS_PS_DUMPLINE4 );
}
PS_ID( IDS_PS_COLORIMAGE3 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IMAGE );
}
else
{
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_NOIMAGE );
}
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
/* Send the inline image's size, packing, and transform */
PS_ID5( IDS_PS_TRANSFORM, dxDest, dyDest, 8, dxDest, dyDest );
if ( !Asciize )
{
// The size must include the doimage command that follows
lSize = (long)dxDest * dyDest * depth;
PS_ID1( IDS_PS_BEGINBINARY, lSize + 9 + 2 );
}
PS_ID( IDS_PS_DOIMAGE ); // Should be 9 characters
for ( x=0; x<5; x++ )
lpBuffer[x] = NULL;
if (!AllocLines((LPPTR)&lpImageData, 1, dxSrc, depth))
{
ProgressEnd();
return(FALSE);
}
if (!AllocLines((LPPTR)&lpBuffer[0], 1, dxDest, depth))
{
FreeUp( lpImageData );
ProgressEnd();
return( FALSE );
}
if (!AllocLines((LPPTR)&lpBuffer[1], 4, dxDest, 1))
{
FreeUp(lpBuffer[0]);
FreeUp( lpImageData );
ProgressEnd();
return( FALSE );
}
p1Buf = lpBuffer[1];
p2Buf = lpBuffer[2];
p3Buf = lpBuffer[3];
p4Buf = lpBuffer[4];
ystart = ySrc;
yline = -1;
yoffset = (long)yrate>>1;
for (y=0; y<dyDest; y++)
{
if (AstralClockCursor( y, dyDest, YES ))
{
fAbortPrint = YES;
break;
}
/* Check for user input to abort dialog box */
(*lpAbortTest)(hPrinterDC, 0);
if ( fAbortPrint )
break;
ylast = yline;
#ifdef WIN32
yline = ystart + WHOLE( yoffset );
#else
yline = ystart + HIWORD( yoffset );
#endif
yoffset += yrate;
if ( yline != ylast )
{
LFIXED rate;
if (lpImage)
ImgGetLine( lpImage, NULL, xSrc, yline, dxSrc, lpImageData );
else
copy(FramePointer(lpBaseFrame, xSrc, yline, NO), lpImageData, dxSrc*depth);
rate = FGET( dxSrc, dxDest );
FrameSample(
lpBaseFrame,
lpImageData,
0,
lpBuffer[0],
0,
dxDest,
rate);
}
if ( cSep )
{ // cSep is either 'C', 'M', 'Y', 'K', 'X'(gray) or NULL
if (cSep != 'X')
{
LPTR lpOutBuf;
int iPlaneOffset;
switch(cSep)
{
case 'C' : lpOutBuf = p1Buf; iPlaneOffset = 0; break;
case 'M' : lpOutBuf = p2Buf; iPlaneOffset = 1; break;
case 'Y' : lpOutBuf = p3Buf; iPlaneOffset = 2; break;
case 'K' : lpOutBuf = p4Buf; iPlaneOffset = 3; break;
}
switch(depth)
{
case 0 :
case 1 :
lpOutBuf = (LPTR)lpBuffer[0];
break;
case 3 :
ClrRGBtoCMYK( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf,p4Buf,dxDest,YES);
break;
case 4 :
{
LPTR lpSrc = (LPTR)lpBuffer[0];
LPTR lpDst = lpOutBuf;
int iCount = dxDest;
lpSrc += iPlaneOffset;
while(iCount-- > 0)
{
*lpDst++ = *lpSrc;
lpSrc += 4;
}
}
break;
}
if (Negative)
negate(lpOutBuf, (long)dxDest);
if ( !SendPSData( Asciize, lpOutBuf, dxDest ) )
goto ErrorExit;
}
else
{
ConvertData( lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES );
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
else if ( Page.Type == IDC_PRINTER_IS_CMYK )
{
switch(depth)
{
case 0 :
case 1 :
copy( lpBuffer[0], p1Buf, dxDest );
copy( lpBuffer[0], p2Buf, dxDest );
copy( lpBuffer[0], p3Buf, dxDest );
copy( lpBuffer[0], p4Buf, dxDest );
break;
case 3 :
ClrRGBtoCMYK( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf,p4Buf,dxDest,YES);
break;
case 4 :
{
LPTR lpSrc = (LPTR)lpBuffer[0];
LPTR lpDst1 = p1Buf;
LPTR lpDst2 = p2Buf;
LPTR lpDst3 = p3Buf;
LPTR lpDst4 = p4Buf;
int iCount = dxDest;
while(iCount-- > 0)
{
*lpDst1++ = *lpSrc++;
*lpDst2++ = *lpSrc++;
*lpDst3++ = *lpSrc++;
*lpDst4++ = *lpSrc++;
}
}
break;
}
if (Negative)
{
negate(p1Buf, (long)dxDest);
negate(p2Buf, (long)dxDest);
negate(p3Buf, (long)dxDest);
negate(p4Buf, (long)dxDest);
}
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p2Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p3Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p4Buf, dxDest ) )
goto ErrorExit;
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
ConvertData( lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES);
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
else if ( Page.Type == IDC_PRINTER_IS_RGB )
{
switch(depth)
{
case 0 :
case 1 :
copy( lpBuffer[0], p1Buf, dxDest );
copy( lpBuffer[0], p2Buf, dxDest );
copy( lpBuffer[0], p3Buf, dxDest );
break;
case 3 :
UnshuffleRGB( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf, dxDest );
break;
case 4 :
{
LPCMYK lpCMYK = (LPCMYK)lpBuffer[0];
LPTR lpDst1 = p1Buf;
LPTR lpDst2 = p2Buf;
LPTR lpDst3 = p3Buf;
RGBS rgb;
int iCount = dxDest;
while(iCount-- > 0)
{
CMYKtoRGB(lpCMYK->c, lpCMYK->m, lpCMYK->y, lpCMYK->k, &rgb);
lpCMYK++;
*lpDst1++ = rgb.red;
*lpDst2++ = rgb.green;
*lpDst3++ = rgb.blue;
}
}
break;
}
if (Negative)
{
negate( p1Buf, dxDest );
negate( p2Buf, dxDest );
negate( p3Buf, dxDest );
}
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p2Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p3Buf, dxDest ) )
goto ErrorExit;
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
ConvertData( (LPTR)lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES);
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
}
if ( !Asciize )
{
PS_ID( IDS_PS_ENDBINARY );
}
/* Send the save restore command */
PS_ID( IDS_PS_MYSAVERESTORE );
PS_ID( IDS_PS_END );
ErrorExit:
if ( lpBuffer[0] )
FreeUp(lpBuffer[0]);
if ( lpBuffer[1] )
FreeUp(lpBuffer[1]);
if ( lpImageData )
FreeUp( lpImageData );
ProgressEnd();
return( TRUE );
}