static void PutRGB_8P(
LPFRAME lpFrame,
LPRGB lpSrcRGB,
LPTR lpDst,
int iPixelCount)
{
LPFRMCOLORMAP lpColorMap;
lpColorMap = FrameGetColorMap( lpFrame );
FrameTypeConvert(
(LPTR)lpSrcRGB,
FDT_RGBCOLOR,
NULL,
0,
lpDst,
FDT_PALETTECOLOR,
lpColorMap,
iPixelCount);
}
void CImage::ObjEditUndo(LPOBJECT lpObject, BOOL fUndoData, BOOL fUndoAlpha)
{
RECT rTemp;
BOOL fSelected, Resolution, fDeleted, fBase, bLocked;
LPALPHA lpAlpha, lpTemp;
LPOBJECT lpNext;
int XSize, YSize;
int tempDataType;
LPCOLORMAP lpColorMap;
int GroupID;
lpAlpha = lpObject->lpAlpha;
fBase = lpObject == GetBase();
if (fUndoData && lpObject->DataDirty)
{
if (lpObject->DataUndoType & UT_RESOLUTION)
Resolution = FrameResolution(lpObject->Pixmap.EditFrame);
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpColorMap = FrameGetColorMap(ObjGetEditFrame(lpObject)))
lpColorMap = FrameCopyColorMap(lpColorMap);
else
lpColorMap = NULL;
}
if (lpObject->DataUndoType & (UT_DATA|UT_NEWDATA))
{
PixmapEditUndo(&lpObject->Pixmap);
if (fBase)
{
npix = FrameXSize(ObjGetEditFrame(lpObject));
nlin = FrameYSize(ObjGetEditFrame(lpObject));
if (lpObject->DataUndoType & UT_NEWDATA)
{
tempDataType = DataType;
DataType = UndoDataType;
UndoDataType = tempDataType;
}
}
}
if (lpObject->DataUndoType & UT_OBJECTRECT)
{
rTemp = lpObject->rObject;
lpObject->rObject = lpObject->rUndoObject;
lpObject->rUndoObject = rTemp;
}
if (lpObject->DataUndoType & UT_RESOLUTION)
{
FrameSetResolution( lpObject->Pixmap.EditFrame,
lpObject->UndoResolution);
lpObject->UndoResolution = Resolution;
}
if (lpObject->DataUndoType & UT_UNDOTEXTDATA)
{
if (lpObject->lpUndoText)
{
CTextObject *pTmp = lpObject->lpUndoText;
lpObject->lpUndoText = lpObject->lpText;
lpObject->lpText = pTmp;
}
}
if (lpObject->DataUndoType & UT_COLORMAP)
{
if (lpObject->UndoColorMap)
{
FrameSetColorMap( ObjGetEditFrame(lpObject), lpObject->UndoColorMap);
FrameDestroyColorMap(lpObject->UndoColorMap);
}
lpObject->UndoColorMap = lpColorMap;
}
if (lpObject->DataUndoType & UT_SELECTION)
{
fSelected = lpObject->fSelected;
lpObject->fSelected = lpObject->fUndoSelected;
lpObject->fUndoSelected = fSelected;
}
if (lpObject->DataUndoType & UT_LOCKOBJECTS)
{
bLocked = lpObject->bLocked;
lpObject->bLocked = lpObject->bUndoLocked;
lpObject->bUndoLocked = bLocked;
}
if (lpObject->DataUndoType & UT_GROUPOBJECTS)
{
GroupID = lpObject->wGroupID;
lpObject->wGroupID = lpObject->UndoGroupID;
lpObject->UndoGroupID = GroupID;
}
if (lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted || lpNext->fDeleted)
{
fDeleted = lpNext->fDeleted;
lpNext->fDeleted = lpNext->fUndoDeleted;
lpNext->fUndoDeleted = fDeleted;
}
}
}
if (fBase && lpObject->DataUndoType & UT_MOVEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
{
rTemp = lpNext->rObject;
lpNext->rObject = lpNext->rUndoObject;
lpNext->rUndoObject = rTemp;
}
}
lpObject->DataUndoNotRedo = !lpObject->DataUndoNotRedo;
if (!fUndoAlpha)
fUndoAlpha = lpObject->fBothDirty;
}
else if (fUndoAlpha && lpObject->fBothDirty)
fUndoAlpha = NO;
if (fUndoAlpha && lpObject->AlphaDirty)
{
if (lpAlpha)
{
if (lpObject->AlphaUndoType & (UT_ALPHA|UT_NEWALPHA))
{
PixmapEditUndo(&lpAlpha->Pixmap);
rTemp = lpAlpha->rMask;
lpAlpha->rMask = lpAlpha->rUndoMask;
lpAlpha->rUndoMask = rTemp;
}
}
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK))
{
lpTemp = lpObject->lpAlpha;
lpObject->lpAlpha = lpObject->lpUndoAlpha;
lpObject->lpUndoAlpha = lpTemp;
}
lpObject->AlphaUndoNotRedo = !lpObject->AlphaUndoNotRedo;
}
lpAlpha = lpObject->lpAlpha;
// check to make sure the mask is still the same size
if (fUndoData && fBase && lpObject->Pixmap.fNewFrame)
{
// we just undid to a different size frame bag mask delete undo
if (lpObject->lpUndoAlpha && !lpObject->fBothDirty)
ObjEditApply(lpObject, NO, YES, NO);
if (lpAlpha)
{
XSize = FrameXSize(lpAlpha->Pixmap.EditFrame);
YSize = FrameYSize(lpAlpha->Pixmap.EditFrame);
if (XSize != FrameXSize(lpObject->Pixmap.EditFrame) ||
YSize != FrameYSize(lpObject->Pixmap.EditFrame))
{
ObjEditInit(lpObject, UT_DELETEMASK);
// dont free mask if it was stored for later undo/redo
if (!lpObject->lpUndoAlpha)
MaskClose(lpObject->lpAlpha);
lpObject->fBothDirty = YES;
lpObject->AlphaDirty = lpObject->DataDirty;
lpObject->lpAlpha = NULL;
}
}
}
}
BOOL CImage::ObjEditInit(LPOBJECT lpObject, UNDO_TYPE UndoType)
{
LPALPHA lpAlpha;
LPOBJECT lpNext;
BOOL fBase, fDataInit, fAlphaInit;
LPCOLORMAP lpColorMap;
// See if this objects the base, and get alpha channel of object
fBase = (lpObject == GetBase());
lpAlpha = lpObject->lpAlpha;
//
// HANDLE INITIALIZATION OF OBJECT DATA
//
fDataInit = (UndoType & UT_DATAUNDO) != 0;
if (fDataInit && !(Control.NoUndo || fDisableUndos))
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone
// the init flag is set only if we are doing an edit in place change
// to the data so we get rid of any useless undo's
if (!Control.UseApply || ( Control.UseApply && !lpObject->DataUndoNotRedo ) )
ObjEditApply(lpObject, YES, !fBase, (UndoType & UT_DATA) != 0);
// Save undo information for the specific type of operation
if (UndoType & UT_UNDOTEXTDATA && !(lpObject->DataUndoType & UT_UNDOTEXTDATA))
lpObject->lpUndoText = new CTextObject(*lpObject->lpText);
if (UndoType & UT_OBJECTRECT && !(lpObject->DataUndoType & UT_OBJECTRECT))
lpObject->rUndoObject = lpObject->rObject;
if (UndoType & UT_RESOLUTION && !(lpObject->DataUndoType & UT_RESOLUTION))
lpObject->UndoResolution = FrameResolution(ObjGetEditFrame(lpObject));
if (UndoType & UT_COLORMAP && !(lpObject->DataUndoType & UT_COLORMAP))
{
if (lpColorMap = FrameGetColorMap(ObjGetEditFrame(lpObject)))
lpObject->UndoColorMap = FrameCopyColorMap(lpColorMap);
else
lpObject->UndoColorMap = NULL;
}
if (UndoType & UT_SELECTION && !(lpObject->DataUndoType & UT_SELECTION))
lpObject->fUndoSelected = lpObject->fSelected;
// Size base is a special case for the base and base only
if (UndoType & UT_DATA)
{
// init the data pixmap for editing
if (!lpObject->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpObject->Pixmap))
return(FALSE);
}
if (UndoType & UT_NEWDATA)
{
if (fBase)
UndoDataType = DataType;
}
if (fBase && UndoType & UT_MOVEOBJECTS &&
!(lpObject->DataUndoType & UT_MOVEOBJECTS))
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, NO))
{
ObjEditApply(lpNext, TRUE, TRUE, FALSE);
lpNext->rUndoObject = lpNext->rObject;
}
}
// Delete objects is a special case for the base and base only
if (fBase && UndoType & UT_DELETEOBJECTS &&
!(lpObject->DataUndoType & UT_DELETEOBJECTS))
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
lpNext->fUndoDeleted = NO;
}
if (UndoType & UT_GROUPOBJECTS && !(lpObject->DataUndoType & UT_GROUPOBJECTS))
lpObject->UndoGroupID = lpObject->wGroupID;
if (UndoType & UT_LOCKOBJECTS && !(lpObject->DataUndoType & UT_LOCKOBJECTS))
lpObject->bUndoLocked = lpObject->bLocked;
}
// now that we have successfully initialized everything set UndoTypes
if (fDataInit)
{
lpObject->DataUndoNotRedo = YES;
lpObject->DataUndoType |= (UndoType & UT_DATAUNDO);
}
//
// HANDLE INITIALIZATION OF OBJECT ALPHA
//
fAlphaInit = (UndoType & UT_ALPHAUNDO) != 0;
if (fAlphaInit && !(Control.NoUndo || fDisableUndos) && (!fBase || Control.UndoMasks))
{
// Apply any changes that have been made if in auto apply mode
// or if in manual apply mode and changes have been undone or
// apply any changes only to the mask
// or if it is a change to both data and mask and
// both were not dirty before
// Initialize the data undo if the object is not the base and we didn't
// already do a data init
// the init flag is set only if we are doing an edit in place change
// to the alpha so we get rid of any useless undo's
if (!Control.UseApply ||
(Control.UseApply && !lpObject->AlphaUndoNotRedo) ||
(fBase && (!fDataInit || !lpObject->fBothDirty)))
ObjEditApply(lpObject, fDataInit ? NO : !fBase, YES,
(UndoType & UT_ALPHA) != 0);
// Save undo information for the specific type of operation
if (lpAlpha)
{
if (!lpObject->AlphaUndoType)
{
if (UndoType & UT_ALPHA)
{
// init the data pixmap for editing
if (!lpAlpha->Pixmap.UndoFrame)
if (!PixmapInitUndo(&lpAlpha->Pixmap))
return(FALSE);
lpAlpha->rUndoMask = lpAlpha->rMask;
}
if (UndoType & UT_NEWALPHA)
lpAlpha->rUndoMask = lpAlpha->rMask;
if (fBase && UndoType & UT_CREATEMASK)
lpObject->lpUndoAlpha = NULL;
if (fBase && UndoType & UT_DELETEMASK)
lpObject->lpUndoAlpha = lpAlpha;
if (UndoType & UT_ALPHAUNDO)
{
lpObject->AlphaUndoNotRedo = YES;
lpObject->AlphaUndoType |= (UndoType & UT_ALPHAUNDO);
}
}
}
}
return(TRUE);
}
int GetCompleteMemoryImage( HWND hWnd, TW_SETUPMEMXFER dcMemSetup )
{
TW_IMAGEINFO dcImageInfo;
TW_IMAGEMEMXFER dcImageData;
TW_UINT16 dcRC;
LPTR lpBuffer = NULL;
LPFRAME lpFrame;
int imageWidth;
int need_new;
int save_type, expand;
FRMDATATYPE Type;
dcImageData.Memory.Flags = TWMF_APPOWNS | TWMF_POINTER;
dcImageData.Memory.Length = dcMemSetup.Preferred;
dcImageData.Memory.TheMem = LineBuffer[0];
// Get the image information, nice to know a little about the
// image the Source will be sending
if( !( *lpDSM_Entry )( &appID, &dsID, DG_IMAGE, DAT_IMAGEINFO, MSG_GET,
( TW_MEMREF )&dcImageInfo ) == TWRC_SUCCESS )
{
return( FALSE );
}
// We have the information about the type/size/depth of the image
// Stored in dcImageInfo.
imageWidth = dcImageInfo.ImageWidth;
need_new = FALSE; // If we have to shrink the image.( hand scanners )
if( dcImageInfo.ImageLength == -1 )
{
// Unknown length - hand scanner
dcImageInfo.ImageLength = HS_MAXLENGTH * dcImageInfo.YResolution.Whole;
need_new = TRUE;
}
if( dcImageInfo.ImageWidth == -1 )
{
// Unknown width - hand scanner
dcImageInfo.ImageWidth = HS_MAXWIDTH * dcImageInfo.XResolution.Whole;
need_new = TRUE;
}
expand = 0;
lpTwainPalette = ( pTW_PALETTE8 )NULL;
// Find out the proper file save type for this image.
switch( dcImageInfo.PixelType )
{
case TWPT_BW :
if( Control.LineArtAsGray )
{
// Create Continuous tone
Type = FDT_GRAYSCALE;
save_type = IDC_SAVECT;
expand = 1;
}
else
{
// Line Art
Type = FDT_LINEART;
save_type = IDC_SAVELA;
}
break;
case TWPT_GRAY :
Type = FDT_GRAYSCALE;
save_type = IDC_SAVECT;
break;
case TWPT_RGB :
Type = FDT_RGBCOLOR;
save_type = IDC_SAVE24BITCOLOR;
break;
case TWPT_PALETTE :
lpTwainPalette = ( pTW_PALETTE8 )Alloc( sizeof( TW_PALETTE8 ) +
( 256 * sizeof( TW_ELEMENT8 )));
if( lpTwainPalette == ( pTW_PALETTE8 )NULL )
return( FALSE );
if( !( *lpDSM_Entry )( &appID, &dsID, DG_IMAGE, DAT_PALETTE8,
MSG_GET,( TW_MEMREF )lpTwainPalette ) == TWRC_SUCCESS )
{
twainError( IDS_UNSUPPORTEDPIXTYPE );
return( FALSE );
}
if( lpTwainPalette->PaletteType != TWPA_RGB )
{
twainError( IDS_UNSUPPORTEDPIXTYPE );
return( FALSE );
}
Type = FDT_PALETTECOLOR;
save_type = IDC_SAVE8BITCOLOR;
break;
default :
twainError( IDS_INVALIDPIXTYPE );
return( FALSE );
break;
}
// Open the new frame.
if( !( lpFrame = FrameOpen(
Type,
( WORD )imageWidth,
( WORD )dcImageInfo.ImageLength,
( WORD )dcImageInfo.XResolution.Whole )))
{
// Issue the error message
Message( IDS_ESCROPEN,( LPTR )Control.RamDisk );
return( FALSE );
}
if( Type == FDT_PALETTECOLOR )
{
int i;
LPCOLORMAP lpColorMap = FrameGetColorMap( lpFrame );
int NumColors = lpTwainPalette->NumColors;
if( NumColors > 256 )
NumColors = 256;
for( i = 0; i < NumColors; ++i )
{
lpColorMap->RGBData[i].red = lpTwainPalette->Colors[i].Channel1;
lpColorMap->RGBData[i].green = lpTwainPalette->Colors[i].Channel2;
lpColorMap->RGBData[i].blue = lpTwainPalette->Colors[i].Channel3;
if( fInvert )
{
lpColorMap->RGBData[i].red ^= 0xFF;
lpColorMap->RGBData[i].green ^= 0xFF;
lpColorMap->RGBData[i].blue ^= 0xFF;
}
}
lpColorMap->NumEntries = NumColors;
}
if( dcImageInfo.Planar )
ImagePlane = 0;
while( dcRC != TWRC_XFERDONE )
{
dcRC = ( *lpDSM_Entry )( &appID, &dsID,
DG_IMAGE, DAT_IMAGEMEMXFER, MSG_GET,( TW_MEMREF )&dcImageData );
switch( dcRC )
{
case TWRC_SUCCESS:
case TWRC_XFERDONE:
if( dcImageData.YOffset == 0 )
ImagePlane++;
StoreImageRect( lpFrame, dcImageInfo, dcImageData, Type, expand );
break;
case TWRC_CANCEL:
case TWRC_FAILURE:
default:
// something wrong, abort the transfer and delete the image
if( dcRC == TWRC_FAILURE )
{
twainError( IDS_TWAINFAILURE );
}
// Close the garbage frame
FrameClose( lpFrame );
return( FALSE );
break;
}
}
// Bring up the new image window.
SendMessage( hWnd, PM_XFERDONE,
( unsigned short )save_type,( unsigned long )lpFrame );
return( TRUE );
}
static LPTR FrameToPaletteDIB( LPFRAME lpFrame, LPRECT lpRect )
{
int y, bpl, i;
LPTR lpSrc, lpDIBMem;
HPTR lpDstLine;
HPTR lpDst;
DWORD lCount, lImageSize, lInfoSize;
int iCount, dx, dy;
LPBITMAPINFO lpInfo;
if ( !lpFrame )
return( NULL );
dx = (lpRect->right - lpRect->left) + 1;
dy = (lpRect->bottom - lpRect->top) + 1;
bpl = dx;
lInfoSize = sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD);
bpl = 4 * ((bpl + 3)/4); // DIB packing
lImageSize = (long)bpl * dy;
lCount = lInfoSize + lImageSize;
// Allocate the memory to hold the DIB
if ( !(lpDIBMem = Alloc( lCount )) )
{
FrameSetError( ERR_MALLOC );
return( NULL );
}
lpInfo = (LPBITMAPINFO)lpDIBMem;
lpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
lpInfo->bmiHeader.biWidth = dx;
lpInfo->bmiHeader.biHeight = dy;
lpInfo->bmiHeader.biPlanes = 1;
lpInfo->bmiHeader.biCompression = BI_RGB;
lpInfo->bmiHeader.biBitCount = 8;
lpInfo->bmiHeader.biSizeImage = lImageSize;
lpInfo->bmiHeader.biXPelsPerMeter = (10000L * (long) FrameResolution(lpFrame)) / 254L;
lpInfo->bmiHeader.biYPelsPerMeter = (10000L * (long) FrameResolution(lpFrame)) / 254L;
lpInfo->bmiHeader.biClrUsed = 256;
lpInfo->bmiHeader.biClrImportant = 256;
if (FrameType(lpFrame) == FDT_GRAYSCALE)
{
for (i = 0; i < 256; ++i)
{
lpInfo->bmiColors[i].rgbBlue = i;
lpInfo->bmiColors[i].rgbGreen = i;
lpInfo->bmiColors[i].rgbRed = i;
lpInfo->bmiColors[i].rgbReserved = 0;
}
}
else
{
LPCOLORMAP lpColorMap;
lpColorMap = FrameGetColorMap( lpFrame );
if (!lpColorMap)
{
for (i = 0; i < 256; ++i)
{
lpInfo->bmiColors[i].rgbBlue = i;
lpInfo->bmiColors[i].rgbGreen = i;
lpInfo->bmiColors[i].rgbRed = i;
lpInfo->bmiColors[i].rgbReserved = 0;
}
}
else
{
for (i = 0; i < 256; ++i)
{
lpInfo->bmiColors[i].rgbBlue = lpColorMap->RGBData[i].blue;
lpInfo->bmiColors[i].rgbGreen = lpColorMap->RGBData[i].green;
lpInfo->bmiColors[i].rgbRed = lpColorMap->RGBData[i].red;
lpInfo->bmiColors[i].rgbReserved = 0;
}
}
}
lpDstLine = (HPTR)lpDIBMem;
lpDstLine += lInfoSize;
// This goes backwards...
for (y = lpRect->bottom; y >= lpRect->top; y--)
{
lpDst = lpDstLine;
lpSrc = FramePointer(lpFrame, lpRect->left, y, NO);
if (lpSrc)
{
iCount = dx;
while (iCount-- > 0)
*lpDst++ = *lpSrc++;
}
lpDstLine += bpl;
}
return( lpDIBMem );
}
