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 ); }