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); }
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 TextureFillProc( HWND hWindow, UINT msg, int x, int y, UINT32 Option ) /************************************************************************/ { FNAME szFileName; LPIMAGE lpImage; TEXTUREFILL_PARMS parms; switch (msg) { case WM_CREATE: // The first mouse down message // Load the texture if (!IsOnImage(hWindow, x, y)) break; if (!LookupExtFile(Texture.TextureName, szFileName, IDN_TEXTURE)) break; if (!FileExists(szFileName)) { Message(IDS_EOPEN, (LPSTR)szFileName); break; } lpImage = (LPIMAGE)GetImagePtr ( hWindow ); parms.TextureOpacity = Texture.TextureOpacity; parms.TextureMergeMode = Texture.TextureMergeMode; lstrcpy(parms.TextureName, Texture.TextureName); parms.fHorzFlip = Texture.fHorzFlip; parms.fVertFlip = Texture.fVertFlip; ProcessCommand(lpImage->lpCmdList, IDS_CMD_TEXTUREFILL, &parms); break; case WM_ACTIVATE: if (!Option) // a deactivate { FrameClose( lpTextureFrame ); lpTextureFrame = NULL; } return; case WM_LBUTTONDOWN: break; case WM_LBUTTONUP: Tool.bActive = NO; break; case WM_MOUSEMOVE: // sent when ToolActive is on break; case WM_LBUTTONDBLCLK: break; case WM_DESTROY: // The cancel operation message Tool.bActive = NO; break; } }
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); }
BOOL RenderToClipboard( HWND hWindow, WORD wFormat ) /************************************************************************/ { DWORD dwValue; HGLOBAL hMem; LPTR lpMem; LPFRAME lpFrame; int iDataType, iFileType, fNative; // This routine assumes that the 2 files to read and render // are identified by Names.ClipImageFile and Names.ClipMaskFile fNative = ( pOLE && (wFormat == pOLE->cfNative || !wFormat) ); // Native format is a DIB if ( wFormat == Control.cfImage || !wFormat ) { if ( hMem = ConstructMGXImage( Names.ClipImageFile, Names.ClipMaskFile ) ) SetClipboardData( Control.cfImage, hMem ); else return( FALSE ); } if ( wFormat == CF_DIB || wFormat == CF_BITMAP || wFormat == CF_METAFILEPICT || !wFormat || fNative ) { if ( !(lpFrame = AstralFrameLoad( Names.ClipImageFile, -1, &iDataType, &iFileType )) ) return(FALSE); } else lpFrame = NULL; if ( wFormat == CF_DIB || !wFormat || fNative ) { if ( lpMem = FrameToDIB( lpFrame, NULL ) ) { #ifdef WIN32 hMem = GlobalHandle( lpMem ); #else dwValue = GlobalHandle( HIWORD(lpMem) ); hMem = (HGLOBAL)LOWORD( dwValue ); #endif GlobalUnlock(hMem); if ( wFormat == CF_DIB || !wFormat ) SetClipboardData( CF_DIB, hMem ); if ( fNative ) SetClipboardData( pOLE->cfNative, hMem ); } else { FrameClose( lpFrame ); return(FALSE); } } if ( wFormat == CF_BITMAP || (!wFormat && Control.DoBitmap) ) { if ( hMem = FrameToBitmap( lpFrame, NULL ) ) SetClipboardData( CF_BITMAP, hMem ); else { FrameClose( lpFrame ); return(FALSE); } } if ( wFormat == CF_METAFILEPICT || (!wFormat && Control.DoPicture) ) { if ( hMem = FrameToMetafile( lpFrame, NULL ) ) SetClipboardData( CF_METAFILEPICT, hMem ); else { FrameClose( lpFrame ); return(FALSE); } } if ( lpFrame ) FrameClose( lpFrame ); if ( wFormat == CF_PALETTE || !wFormat ) { if ( hMem = ConstructPalette( lpBltScreen->hPal ) ) SetClipboardData( CF_PALETTE, hMem ); } 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 ); }
void EXPORT grabber_frame_close( LPFRAME lpFrame ) /************************************************************************/ { FrameClose(lpFrame); }
void grabber( LPSTR lpExtName, int port, HINSTANCE hInstance, HWND hWindow ) { HWND hWnd; /* special conditions: hand scan interface -- with hand scanners the dialog box has a scan frame which gets filled with image data. the dialog box must remain up during reads, so we use the exported frame_open, cacheptr, and frame_close to create the frame instead of device reads. Devopen just returns devcaps, devstart does everything else. special willow gs -- the gs board has 4 different buffers, which contain the following: 0-even pix/even lines, 1-odd pix/even lines, 2-even pix/odd lines, 3-odd pix/odd lines. each call to devread will layer the data so that the buffers will be combined correctly. Device Requirements Byte Decoding: XXXXXXX1b = need to take over display XXXXXXX0b = no need to take over display XXXXXX1Xb = special willow gs read XXXXXX0Xb = no special read XXXX00XXb = image depth, special case palette color 8-bit XXXX01XXb = depth == 1 XXXX10XXb = depth == 2 XXXX11XXb = depth == 3 X1XXXXXXb = special hand scan i/f X0XXXXXXb = standard grab i/f XX1XXXXXb = don't free DLL after exit XX0XXXXXb = free DLL after exit 1XXXXXXXb = putting data from cache to external device 0XXXXXXXb = putting data from external device into cache */ BYTE devreq; // device requirements LPFRAME lpFrame, lpOldFrame; BYTE depth; int lncnt,Datatype; HMODULE hDLL; LPIMAGE lpImage; if ( !(hDLL = (HMODULE)LoadGrabberLibrary(lpExtName)) ) { Message( IDS_EBADDRIVER, NULL ); return; } if ( !(lpImage = GetActiveImage())) lpFrame = NULL; else lpFrame = ImgGetBaseEditFrame(lpImage); lpfnDevName = (DEVNAMEPROC)GetProcAddress(hDLL, MAKEINTRESOURCE(301)); lpfnDevOpen = (DEVOPENPROC)GetProcAddress(hDLL, MAKEINTRESOURCE(302)); lpfnDevCall = (DEVCALLPROC)GetProcAddress(hDLL, MAKEINTRESOURCE(303)); lpfnDevClose = (DEVCLOSEPROC)GetProcAddress(hDLL, MAKEINTRESOURCE(304)); lpfnAcquireProc = (DLGPROC)GetProcAddress(hDLL, MAKEINTRESOURCE(305)); /* get device's intentions -- is this a put to or read from cache */ DevInfo.hInst = hInstance; /* set the data structures */ DevInfo.hPw = hWindow; DevInfo.bFile_is_open = ( lpFrame != NULL ); if(DevInfo.bFile_is_open) { DevInfo.bImg_type = (lpImage->DataType==IDC_SAVECT ? TRUE : FALSE); /* pass the current filename */ lstrcpy(DevInfo.cfname, lpImage->CurFile); } if(!DevOpen(&DevInfo)) { DevCall(DEV_MSG, (LPTR)&DevMsg); /* if MsgNo == 0, then user cancelled */ if(DevMsg.MsgNo) { if(DevMsg.MsgNo > 0) { Message( DevMsg.MsgNo ); } else { /* print the driver's message */ Print("%ls", (LPTR)DevMsg.szMsg); } } return; } bKeepDLL = (DevInfo.device_caps & 0x20); devreq = DevInfo.device_caps; /* doing a put cache to an external device */ if(!(devreq & 0x80)) { /* fill up the device info data structure */ DevInfo.npix = FrameXSize( lpFrame ); DevInfo.nlin = FrameYSize( lpFrame ); DevInfo.bpl = FrameXSize( lpFrame ); DevInfo.xres = DevInfo.yres = FrameResolution( lpFrame ); DevInfo.bpp = 8; } else { DevInfo.port = port; /* set the port for devices which require it */ #ifndef WIN32 DevInfo.vgaaddr = GetA000H(); /* set the VGA buffer address */ #endif } /* see if we need to take over display */ if(devreq & 1) { /* Hide the Cursor */ ShowCursor( FALSE ); /* Create the acquire window: it doesn't have the visable bit set */ AstralDlg( YES, hInstance, hWindow, IDD_GRAB, AcquireProc); AstralDlgShow( IDD_GRAB ); /* Enter the picture window command processor */ SetCapture( AstralDlgGet( IDD_GRAB ) ); /* set the data structures */ DevInfo.hInst = hInstance; DevInfo.hPw = AstralDlgGet( IDD_GRAB ); /* call display driver disable */ #ifndef WIN32 PicwinOn((LPSTR)palette1); #endif } if(devreq & 0x40) { // devstart does everything DevInfo.FpPtr = (LPTRPROC)MakeProcInstance( (FARPROC)grabber_frame_ptr, DevInfo.hInst); DevInfo.FoPtr = (LPTRPROC)MakeProcInstance( (FARPROC)grabber_frame_open, DevInfo.hInst); DevInfo.FsPtr = (LPTRPROC)MakeProcInstance( (FARPROC)grabber_frame_set, DevInfo.hInst); DevInfo.FcPtr = (LPROC)MakeProcInstance( (FARPROC)grabber_frame_close, DevInfo.hInst); DevInfo.CcPtr = (LPROC)MakeProcInstance( (FARPROC)grabber_AstralClockCursor, DevInfo.hInst); } DevInfo.bLineArtAsGray = Control.LineArtAsGray; if(!DevCall(DEV_START, (LPTR)&DevInfo)) { /* if get, fill struct */ back_to_windows(devreq & 1); /* restore if true */ DevCall(DEV_MSG, (LPTR)&DevMsg); /* if MsgNo == 0, then user cancelled */ if(DevMsg.MsgNo) { if(DevMsg.MsgNo > 0) { Message( DevMsg.MsgNo ); } else { /* print the driver's message */ Print("%ls", (LPTR)DevMsg.szMsg); } } if(devreq & 0x40) { // devstart does everything FreeProcInstance((FARPROC)DevInfo.FpPtr); FreeProcInstance((FARPROC)DevInfo.FoPtr); FreeProcInstance((FARPROC)DevInfo.FsPtr); FreeProcInstance((FARPROC)DevInfo.FcPtr); FreeProcInstance((FARPROC)DevInfo.CcPtr); } DevClose(); /* close the device */ return; } /* DEV_START returned ok, now get or put image data if not done */ if((devreq & 0xc0) == 0x80) { // putting data into the cache with devreads if(((devreq & 4) == 4) || ((devreq & 0x0c) == 0)) { depth = 1; } else { if((devreq & 8) == 8) { depth = 2; } else { if((devreq & 0x0c) == 0x0c) { depth = 3; } } } lpOldFrame = frame_set( NULL ); if(!(lpFrame = FrameOpen( (FRMDATATYPE)depth,DevInfo.npix,DevInfo.nlin,DevInfo.xres))) { back_to_windows(devreq & 1); /* Restore if true */ FrameError(IDS_EIMAGEOPEN); return; } frame_set(lpFrame); if(!(devreq & 2)) { for ( lncnt=0; lncnt<DevInfo.nlin; lncnt++ ) { DevData.ImageAddress = FramePointer(lpFrame, 0, lncnt, YES); if(!DevCall(DEV_READ, (LPTR)&DevData)) { back_to_windows(devreq & 1); /* Restore if true */ DevCall(DEV_MSG, (LPTR)&DevMsg); /* if MsgNo == 0, then user cancelled */ if(DevMsg.MsgNo) { Print("Unable to get data from device"); } else { DevInfo.nlin = lncnt; // hand scanner, get total lines } return; } } } else { /* special willow gs reader */ /* read even bytes, even lines */ for ( lncnt=0; lncnt<DevInfo.nlin; lncnt+=2 ) { DevData.ImageAddress = FramePointer(lpFrame, 0, lncnt, YES); if(!DevCall(DEV_READ0, (LPTR)&DevData)) { back_to_windows(devreq & 1); /* Restore if true */ Print("Unable to get data from device"); return; } } /* read odd bytes, even lines */ for ( lncnt=0; lncnt<DevInfo.nlin; lncnt+=2 ) { DevData.ImageAddress = FramePointer(lpFrame, 1, lncnt, YES); if(!DevCall(DEV_READ1, (LPTR)&DevData)) { back_to_windows(devreq & 1); /* Restore if true */ Print("Unable to get data from device"); return; } } /* read even bytes, odd lines */ for ( lncnt=1; lncnt<DevInfo.nlin; lncnt+=2 ) { DevData.ImageAddress = FramePointer(lpFrame, 0, lncnt, YES); if(!DevCall(DEV_READ2, (LPTR)&DevData)) { back_to_windows(devreq & 1); /* Restore if true */ Print("Unable to get data from device"); return; } } /* read odd bytes, odd lines */ for ( lncnt=1; lncnt<DevInfo.nlin; lncnt+=2 ) { DevData.ImageAddress = FramePointer(lpFrame, 1, lncnt, YES); if(!DevCall(DEV_READ3, (LPTR)&DevData)) { back_to_windows(devreq & 1); /* Restore if true */ Print("Unable to get data from device"); return; } } } FrameClose( lpOldFrame ); back_to_windows(devreq & 1); /* Restore if true */ if(DevInfo.bpp == 1) { Datatype = IDC_SAVELA; } else { if(DevInfo.bpp == 8) { Datatype = IDC_SAVECT; } else { Datatype = IDC_SAVE24BITCOLOR; } } /* Setup the new image and bring up the new image window */ LPIMAGE lpNewImage = CreateImage(NULL, lpFrame, NULL, NULL, Control.DefaultFileType, Datatype, IMG_DOCUMENT, NULL); if (lpNewImage) { if (PictPubApp.OpenDocumentFile((LPSTR)lpNewImage->CurFile, lpNewImage)) { /* only version of image is in the cache */ /* so insure user is asked about saving when done */ lpNewImage->fChanged = TRUE; } else DestroyImage(lpNewImage); } DevClose(); /* close the device */ } else { LPIMAGE lpNewImage = NULL; /* enable the frame created by DevStart */ lpFrame = frame_set(NULL); /* putting data to external device with DevWrites */ if((devreq & 0xc0) == 0) { for ( lncnt=0; lncnt<DevInfo.nlin; lncnt++ ) { AstralClockCursor( lncnt, DevInfo.nlin, NO ); DevData.ImageAddress = FramePointer(lpFrame, 0, lncnt, NO); if(!DevCall(DEV_WRITE, (LPTR)&DevData)) { Print("Unable to put data to device"); return; } } } else { /* devstart has created a frame with image data */ FreeProcInstance((FARPROC)DevInfo.FpPtr); FreeProcInstance((FARPROC)DevInfo.FoPtr); FreeProcInstance((FARPROC)DevInfo.FsPtr); FreeProcInstance((FARPROC)DevInfo.FcPtr); if(DevInfo.bpp == 1) { Datatype = IDC_SAVELA; } else { if(DevInfo.bpp == 8) { Datatype = IDC_SAVECT; } else { Datatype = IDC_SAVE24BITCOLOR; } } back_to_windows(devreq & 1); /* Restore if true */ /* enable the frame created by DevStart */ lpFrame = frame_set(NULL); /* DevInfo.nlin returns the actual line count */ if(FrameYSize(lpFrame) <= DevInfo.nlin) { /* Setup the new image and bring up the new image window */ { lpNewImage = CreateImage(NULL, lpFrame, NULL, NULL, Control.DefaultFileType, Datatype, IMG_DOCUMENT, NULL); if (lpNewImage) { if (!PictPubApp.OpenDocumentFile((LPSTR)lpNewImage->CurFile, lpNewImage)) { DestroyImage(lpNewImage); lpNewImage = NULL; } } } } else { /* create a new frame of the right size and copy */ /* the right number of lines to it */ lpOldFrame = FrameOpen( FrameType(lpFrame), FrameXSize(lpFrame), DevInfo.nlin, FrameResolution(lpFrame)); AstralCursor( IDC_WAIT ); for(lncnt=0; lncnt<DevInfo.nlin; lncnt++) { FrameCopyLine(lpFrame, lpOldFrame, lncnt); } FrameClose(lpFrame); lpFrame = lpOldFrame; AstralCursor( NULL ); /* Setup the new image and bring up the new image window */ lpNewImage = CreateImage(NULL, lpFrame, NULL, NULL, Control.DefaultFileType, Datatype, IMG_DOCUMENT, NULL); if (lpNewImage) { if (!PictPubApp.OpenDocumentFile((LPSTR)lpNewImage->CurFile, lpNewImage)) { DestroyImage(lpNewImage); lpNewImage = NULL; } } } /* only version of image is in the cache */ /* so insure user is asked about saving when done */ if (lpNewImage) lpNewImage->fChanged = TRUE; DevClose(); /* close the device */ } } }
BOOL ConvertImage(LPIMAGE lpImage, LPCONVERT_PARMS lpParms) /***********************************************************************/ { BOOL fRet = FALSE; LPFRAME lpDstFrame, lpBaseFrame; LPOBJECT lpBase, lpObject; BOOL fError, fOptimize, fProgressSet; INTERNAL_DATA data; int inDepth, iMaxWidth, nColors, i; LPCOLORMAP lpColorMap; LPRGB lpRGB; FRMTYPEINFO InTypeInfo, OutTypeInfo; CFrameTypeConvert TypeConvert; DITHER_TYPE DitherType = DT_DEFAULT; if (ImgInMaskEditMode(lpImage)) return(TRUE); lpColorMap = NULL; lpBase = ImgGetBase(lpImage); lpBaseFrame = ObjGetEditFrame(lpBase); inDepth = FrameDepth(lpBaseFrame); OutTypeInfo = lpParms->cmsInfo.dst; FrameGetTypeInfo(lpBaseFrame, &InTypeInfo); // are we try to convert to a color managed image? if (Control.CMSEnabled && IsDstPTSelected(&OutTypeInfo.ptInfo)) { // see if our image already has a color managed source if (!IsSrcPTSelected(&InTypeInfo.ptInfo)) { // nope, see if the source passed in is valid for this image if (IsSrcPTSelected(&lpParms->cmsInfo.src.ptInfo) && (lpParms->cmsInfo.src.DataType == InTypeInfo.DataType)) { InTypeInfo = lpParms->cmsInfo.src; } // go get a source from the user else { CMSINFO CmsInfo2; if( CmsGetSrcPTType( &InTypeInfo, &CmsInfo2) ) InTypeInfo = CmsInfo2.src; } } } else FrameSetTypeInfo(&InTypeInfo, InTypeInfo.DataType, InTypeInfo.ColorMap); // no conversion necessary if (FrameTypeInfoEqual(InTypeInfo, OutTypeInfo)) return(TRUE); DitherType = lpParms->DitherType; fOptimize = lpParms->ConvertType == CT_OPTIMIZED; fProgressSet = FALSE; if ( OutTypeInfo.DataType == FDT_PALETTECOLOR/* && inDepth >= 3 */) { if (lpParms->ConvertType == CT_CUSTOM) { FNAME szFileName; if ( !LookupExtFileN( lpParms->szPalette, szFileName, IDN_PALETTE, NO ) ) return(FALSE); if (!(lpColorMap = Palette_ReadColorMap(szFileName))) return(FALSE); } else { // allocate a map to carry around with image lpColorMap = FrameCreateColorMap(); if (!lpColorMap) { Message(IDS_EMEMALLOC); goto MemError; } lpColorMap->NumEntries = lpParms->iLevels; if (InTypeInfo.DataType == FDT_GRAYSCALE && lpColorMap->NumEntries == 256 && fOptimize) { DitherType = DT_NONE; lpRGB = lpColorMap->RGBData; for (i = 0; i < lpColorMap->NumEntries; ++i) { lpRGB->red = lpRGB->green = lpRGB->blue = i; ++lpRGB; } } else { // 1. CreateOptimizedPalette phase - only if fOptimize // 2. Mapping phase ProgressBegin(fOptimize ? 2 : 1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST); fProgressSet = TRUE; if (fOptimize) ProgressBegin(1, 0); if (!CreateOptimizedPalette(lpBase, ObjGetEditFrame(lpBase), lpColorMap->RGBData, &lpColorMap->NumEntries, fOptimize, fOptimize ? AstralClockCursor : NULL)) { if (fOptimize) ProgressEnd(); Message(IDS_EMEMALLOC); goto ExitFalse; } if (fOptimize) ProgressEnd(); } } if (lpColorMap->NumEntries <= 16) lpColorMap->NumEntries = 16; else lpColorMap->NumEntries = 256; FrameSetTypeInfo(&OutTypeInfo, FDT_PALETTECOLOR, lpColorMap); } if (!fProgressSet) ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST); fProgressSet = TRUE; iMaxWidth = 0; lpObject = NULL; while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO)) { if (RectWidth(&lpObject->rObject) > iMaxWidth) iMaxWidth = RectWidth(&lpObject->rObject); } if (!TypeConvert.Init(InTypeInfo, OutTypeInfo, iMaxWidth, DitherType)) { Message(IDS_EMEMALLOC); goto ExitFalse; } if (ImgMultipleObjects(lpImage)) { ProgressBegin(ImgCountObjects(lpImage), 0); if ( !ImgEditInit(lpImage, ET_ALLOBJECTS, UT_NEWDATA|UT_COLORMAP, lpBase) ) goto ExitFalse; fError = NO; lpObject = NULL; while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO)) { lpDstFrame = ConvertFrame(ObjGetEditFrame(lpObject), OutTypeInfo, &TypeConvert); if (!lpDstFrame) { fError = YES; break; } ImgEditedObjectFrame( lpImage, lpObject, lpParms->Common.idDirty, NULL, lpDstFrame, NULL); } if (fError) { lpObject = NULL; while (lpObject = ImgGetNextObject(lpImage, lpObject, YES, NO)) { if (lpObject->Pixmap.UndoFrame) { lpDstFrame = lpObject->Pixmap.EditFrame; lpObject->Pixmap.EditFrame = lpObject->Pixmap.UndoFrame; lpObject->Pixmap.UndoFrame = NULL; FrameClose(lpDstFrame); } } } ProgressEnd(); } else { if ( !ImgEditInit(lpImage, ET_OBJECT, UT_NEWDATA|UT_COLORMAP, lpBase) ) goto ExitFalse; ProgressBegin(1, 0); lpDstFrame = ConvertFrame(lpBaseFrame, OutTypeInfo, &TypeConvert); ProgressEnd(); if (!lpDstFrame) goto ExitFalse; /* Setup the new image and bring up the new image window */ ImgEditedObjectFrame( lpImage, lpBase, lpParms->Common.idDirty, NULL, lpDstFrame, NULL); } switch (lpParms->cmsInfo.dst.DataType) { case FDT_LINEART: lpImage->DataType = IDC_SAVELA; break; case FDT_GRAYSCALE: lpImage->DataType = IDC_SAVECT; break; case FDT_PALETTECOLOR: lpImage->DataType = IDC_SAVE8BITCOLOR; break; case FDT_RGBCOLOR: lpImage->DataType = IDC_SAVE24BITCOLOR; break; case FDT_CMYKCOLOR: lpImage->DataType = IDC_SAVE32BITCOLOR; break; } ImgColorMapChanged(lpImage); lpParms->Common.UpdateType = UT_DATATYPE; fRet = TRUE; ExitFalse: if (fProgressSet) ProgressEnd(); MemError: if (lpColorMap) FrameDestroyColorMap(lpColorMap); return(fRet); }
void COlelistBox::OnLButtonDown(UINT nFlags, CPoint point) { FNAME *lpResult; CDataItem *pDataItem; LPIMAGE lpImage = GetActiveImage(); CServerDoc *pDoc = PictPubApp.GetDocument(lpImage); int num; CRect r,rr; BOOL bCreateDoc = (pDoc == NULL); CPoint p; CListBox::OnLButtonDown(nFlags, point); FORWARD_WM_LBUTTONUP(GetSafeHwnd(), point.x, point.y, nFlags, ::SendMessage); lpResult = ExtBsr_GetSelection(GetParent()->GetSafeHwnd(), &num); if (!lpResult || num != 1) return; lstrcpy(Names.Clipboard, lpResult[0]); if (LookupExtFileN(Names.Clipboard, Names.PasteImageFile, IDN_CLIPBOARD, NO)) { if (bCreateDoc) { LPFRAME lpFrame = FrameOpen(FDT_GRAYSCALE, 1, 1, 72); if (lpFrame) { POSITION Pos; lpImage = CreateImage(NULL,lpFrame,NULL,NULL, IDN_PP,IDC_SAVECT,IMG_DOCUMENT,NULL); if (!lpImage) { FrameClose(lpFrame); return; } pDoc = (CServerDoc*)PictPubApp.OpenDocumentFile( lpImage->CurFile, lpImage, FALSE); if (!pDoc) { DestroyImage(lpImage); return; } } else return; } if (pDoc) { pDataItem = new CDataItem(pDoc, Names.Clipboard, YES); GetParent()->GetWindowRect(&r); ClientToScreen(&point); GetItemRect(GetCurSel(), &rr); ClientToScreen(&rr); p.x = rr.Width() / 2; p.y = rr.Height() / 2; // NOTE!!the pDataItem will be internally destroyed once the drag/drop // operation is completed therefore we do not need to delete the pDataItem pDataItem->DoDragDrop(&rr, p, FALSE, DROPEFFECT_COPY, &r); if (bCreateDoc) pDoc->OnCloseDocument(); } } else if(Names.Clipboard[0]) { // deleted the file...notify the browser UpdatePasteFromFile(NULL); } }
LPFRAME DIBToPaletteFrame( LPTR lpDIBMem, BOOL bForceRGB ) { FRMDATATYPE FrameDataType; LPBITMAPINFO lpInfo; LPCOLORMAP lpColorMap; LPRGBQUAD lpRGBQColorMap; LPFRAME lpFrame; HPTR lpSrcLine; HPTR lpSrc; LPTR lpDst; BOOL bGrayMap; int iColorMapEntries; int iResolution; int iFrameXSize; int iFrameYSize; int iSrcWidth; int iDstWidth; int iCount; int y; int i; lpInfo = (LPBITMAPINFO)lpDIBMem; // Get the important bitmap information iFrameXSize = lpInfo->bmiHeader.biWidth; iFrameYSize = lpInfo->bmiHeader.biHeight; iResolution = ((lpInfo->bmiHeader.biXPelsPerMeter) * 254L) / 10000L; // Make sure that we have something to do if ((iFrameXSize <= 0) || (iFrameYSize <= 0)) { return(NULL); } // Validate the image resolution if (iResolution <= 0) { iResolution = 75; } lpRGBQColorMap = &lpInfo->bmiColors[0]; bGrayMap = TRUE; if (lpInfo->bmiHeader.biBitCount == 4) iColorMapEntries = 16; else iColorMapEntries = 256; // Find out whether or not this is a grayscale image for(i=0;i<iColorMapEntries;i++) { if (bGrayMap) { if ((lpRGBQColorMap[i].rgbBlue != lpRGBQColorMap[i].rgbRed) || (lpRGBQColorMap[i].rgbBlue != lpRGBQColorMap[i].rgbRed)) { bGrayMap = FALSE; break; } } } if (bGrayMap) { FrameDataType = FDT_GRAYSCALE; bForceRGB = FALSE; } else { if (bForceRGB) { FrameDataType = FDT_RGBCOLOR; } else { FrameDataType = FDT_PALETTECOLOR; } } // Create the new image frame lpFrame = FrameOpen(FrameDataType, iFrameXSize, iFrameYSize, iResolution); if (!lpFrame) return(NULL); // Add the colormap to the frame if necessary if (!bGrayMap) { // Allocate space for the colormap lpColorMap = (LPCOLORMAP)Alloc( sizeof(COLORMAP)+ sizeof(RGBS) * 256); if (!lpColorMap) { FrameClose(lpFrame); return(NULL); } lpColorMap->NumEntries = 256; for(i=0;i<iColorMapEntries;i++) { lpColorMap->RGBData[i].red = lpRGBQColorMap[i].rgbRed; lpColorMap->RGBData[i].green = lpRGBQColorMap[i].rgbGreen; lpColorMap->RGBData[i].blue = lpRGBQColorMap[i].rgbBlue; } for(i=iColorMapEntries;i<256;i++) { lpColorMap->RGBData[i].red = 0; lpColorMap->RGBData[i].green = 0; lpColorMap->RGBData[i].blue = 0; } if (FrameDataType == FDT_RGBCOLOR) if (!FrameSetColorMap( lpFrame, lpColorMap )) { FrameClose( lpFrame ); return(NULL); } } // Find the DIB data pointer and width lpSrcLine = lpDIBMem + lpInfo->bmiHeader.biSize + iColorMapEntries * (sizeof(RGBQUAD)); //OLD VERSION USED lpInfo->bmiHeader.biClrUsed instead of iColorMapEntries // some 4 bit DIB's don't set biCLrUsed that way if (lpInfo->bmiHeader.biBitCount == 4) iSrcWidth = ((lpInfo->bmiHeader.biWidth+7)/8)*4; else iSrcWidth = ((lpInfo->bmiHeader.biWidth+3)/4)*4; iDstWidth = FrameByteWidth( lpFrame ); if (bForceRGB) { // Copy the DIB data into the RGB Frame if (lpInfo->bmiHeader.biBitCount == 4) { for(y=iFrameYSize-1;y >= 0;y--) { lpSrc = lpSrcLine; lpDst = FramePointer( lpFrame, 0, y, TRUE ); iCount = (iFrameXSize+1)/2; while(iCount-- > 0) { *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].red; *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].green; *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0xF0)>>4].blue; *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].red; *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].green; *lpDst++ = lpColorMap->RGBData[(*lpSrc & 0x0F)].blue; lpSrc++; } lpSrcLine += iSrcWidth; } } else { for(y=iFrameYSize-1;y >= 0;y--) { lpSrc = lpSrcLine; lpDst = FramePointer( lpFrame, 0, y, TRUE ); iCount = iFrameXSize; while(iCount-- > 0) { *lpDst++ = lpColorMap->RGBData[*lpSrc].red; *lpDst++ = lpColorMap->RGBData[*lpSrc].green; *lpDst++ = lpColorMap->RGBData[*lpSrc].blue; lpSrc++; } lpSrcLine += iSrcWidth; } } }
BOOL CReadBitmap::GIFRead() /************************************************************************/ { GIFHDR hdr; GIFDESC ImDesc; GIFMAP GlobalMap; GIFMAP LocalMap; BYTE cTemp; LPTR lpFileLine, lpLineBuffer, lpOut; LPFRAME lpFrame; FILEBUF ifd; /* file descriptor (buffered) */ BOOL graymap; int i; int sy; int xres; /* pixels per inch */ int npix; /* image width (pixels) */ int nlin; /* image height (pixels) */ BYTE codeSize; int iCodeSize; int iRowMapIndex; BOOL compressInit; LPLZW_STUFF lpLZW; FRMTYPEINFO inType, outType; LPCOLORMAP lpColorMap; CFrameTypeConvert TypeConvert; CFile theFile; CFile* pTheFile; BOOL fRet = FALSE; ProgressBegin(1); if ((pTheFile = OpenFile()) == NULL) { ProgressEnd(); return(FALSE); } TRY { lpFileLine = NULL; lpFrame = NULL; lpLineBuffer = NULL; compressInit = NO; lpColorMap = NULL; if (!(lpLineBuffer = Alloc (BUF_SIZE))) goto Exit; FileFDOpenRdr (&ifd, pTheFile, lpLineBuffer, BUF_SIZE); /* initialize the Global and local color maps */ gifInitColorMap (&GlobalMap); gifInitColorMap (&LocalMap); /* read gif file header */ if (gifReadHeader (&ifd, &hdr)) goto BadRead; /* get global color map, if any */ if (hdr.GlobalMap) { if (gifReadColorMap (&ifd, hdr.bpp, &GlobalMap)) goto BadRead; } /* look for start of image */ while (1) { FileFDRead (&ifd, (LPTR) &cTemp, 1); if (ifd.err) goto BadRead; /* test for image separator character */ if (cTemp == GIFImSep) break; /* test for terminator character (no image blocks in file?) */ if (cTemp == GIFImSep) goto BadRead; /* test for extension block character */ if (cTemp == GIFExtBlk) { /* Skip over the extension block */ /* read function code */ FileFDRead (&ifd, (LPTR) &cTemp, 1); do { /* read byte count */ FileFDRead (&ifd, (LPTR) &cTemp, 1); /* skip data bytes */ if (cTemp) FileFDSeek (&ifd, (long) cTemp, 1); } while (cTemp); } } /* now at the start of the first image */ if (gifReadImDesc (&ifd, &ImDesc)) goto BadRead; /* read local color map, if any */ if (ImDesc.LocalMap) { if (gifReadColorMap (&ifd, ImDesc.bpp, &LocalMap)) goto BadRead; } else { LocalMap = GlobalMap; ImDesc.bpp = hdr.bpp; } /* check for gray map */ graymap = TRUE; for (i = 0; (i < LocalMap.Length) && graymap; i++) graymap = (LocalMap.Map[i].red == LocalMap.Map[i].green) && (LocalMap.Map[i].red == LocalMap.Map[i].blue); lpColorMap = FrameCreateColorMap(); if (!lpColorMap) { SetError(BEC_errMemory); goto Exit; } lpColorMap->NumEntries = LocalMap.Length; for (i = 0; i < LocalMap.Length; ++i) lpColorMap->RGBData[i] = LocalMap.Map[i]; /* get width of image in pixels */ npix = ImDesc.ImWidth; nlin = ImDesc.ImHeight; xres = 75; if (hdr.bpp == 1) FrameSetTypeInfo(&inType, FDT_LINEART); else FrameSetTypeInfo(&inType, FDT_PALETTECOLOR, lpColorMap); if (!SetupTypes(&inType, &outType, graymap)) goto Exit; FrameSetTypeInfo(&inType, FDT_PALETTECOLOR, lpColorMap); if (!TypeConvert.Init(inType, outType, npix, m_DitherType)) { SetError(BEC_errMemory); goto Exit; } /* allocate space for one line of the image (file) */ if ( !AllocLines (&lpFileLine, 1, npix, 1)) { SetError(BEC_errMemory); goto BadWrite; } /* Create the image frame store */ lpFrame = FrameOpen(outType, npix, nlin, xres); if ( !lpFrame ) { SetError(BEC_errFrameOpen); goto Exit; } /* convert the image */ if (FileFDRead (&ifd, &codeSize, 1) == -1) goto BadRead; iCodeSize = codeSize; if (FileFDSeek (&ifd, 0L, 1) == -1) goto BadRead; if ( !( lpLZW = DecompressLZW_GIF (ifd.pFile, NULL, 0, iCodeSize, NULL))) goto BadRead; compressInit = YES; if (ImDesc.Interlaced) iRowMapIndex = 1; else iRowMapIndex = 0; sy = gifRowMap [iRowMapIndex].first; for (i = 0; i < nlin; i++) { if (Progress (i, nlin, YES)) goto Exit; if (!(DecompressLZW_GIF (ifd.pFile, lpFileLine, npix, iCodeSize, lpLZW))) goto BadRead; if ( !(lpOut = FramePointerRaw(lpFrame, 0, sy, YES)) ) goto BadWrite; TypeConvert.ConvertData(lpFileLine, lpOut, sy, npix); sy += gifRowMap [iRowMapIndex].step; if (sy >= ImDesc.ImHeight) { iRowMapIndex++; sy = gifRowMap [iRowMapIndex].first; } } m_iWidth = npix; m_iHeight = nlin; m_iRes = xres; m_lpFrame = lpFrame; fRet = TRUE; goto Exit; } CATCH_ALL(e) { goto BadRead; } END_CATCH_ALL ProgressEnd(); return (TRUE); BadRead: SetError(BEC_errFileRead); goto Exit; BadWrite: SetError(BEC_errFrameRead); Exit: if (compressInit) DecompressLZW_GIF (ifd.pFile, NULL, 0, iCodeSize, lpLZW); compressInit = NO; if ( lpFileLine ) FreeUp( lpFileLine ); if ( lpLineBuffer ) FreeUp (lpLineBuffer); if ( lpColorMap ) FrameDestroyColorMap(lpColorMap); CloseFile(pTheFile); if (!fRet && lpFrame) FrameClose(lpFrame); ProgressEnd(); return(fRet); }
BOOL CReadBitmap::CTRead() { LPCTHEADER lpTH; LPFRAME lpFrame; BOOL fConvert = FALSE, fRet = FALSE; CFile theFile; CFile* pTheFile; FRMTYPEINFO inType, outType; LPTR lpIn, lpIn2,lpOut, lpFrmLine; int x,y,j; UINT bytes_read; BOOL GrayScale; BITMAP_ERROR_CODE err; CFrameTypeConvert Convert; ProgressBegin(1); if ((pTheFile = OpenFile()) == NULL) { ProgressEnd(); return(FALSE); } lpFrame = NULL; if ( !(lpTH = ReadCTHeader(pTheFile, m_lpFileName, &err))) { SetError(err); goto Exit; } GrayScale = lpTH->ColSepMask == 8 && lpTH->NumColSep == 1; if (GrayScale) FrameSetTypeInfo(&inType, FDT_GRAYSCALE, NULL); else FrameSetTypeInfo(&inType, FDT_CMYKCOLOR, NULL); if (!SetupTypes(&inType, &outType)) goto Exit; fConvert = !FrameTypeInfoEqual( inType, outType ); if( fConvert ) { if( !Convert.Init( inType, outType, lpTH->Pixels ) ) { SetError(BEC_errMemory); goto Exit; } } /* Create the image frame store */ if ( !(lpFrame = FrameOpen(outType, lpTH->Pixels, lpTH->Lines, lpTH->Resolution))) { SetError(BEC_errFrameOpen); goto Exit; } pTheFile->Seek (2048, CFile::begin); for (y=0; y < lpTH->Lines; y++) { if ( Progress(y, lpTH->Lines, YES)) goto Exit; TRY { bytes_read = pTheFile->Read(lpTH->lpCTLine, lpTH->LineSize); } CATCH_ALL(e) { goto BadRead; } END_CATCH_ALL if (bytes_read != lpTH->LineSize) goto BadRead; if ( !(lpFrmLine = FramePointerRaw( lpFrame, 0, y, YES))) goto BadWrite; lpIn = lpTH->lpCTLine; lpOut = lpFrmLine; lpIn2 = lpIn; for (x=0; x < lpTH->Pixels; x++) { j = 0; if (!GrayScale) { if (lpTH->ColSepMask & 0x1) // cyan { j += lpTH->ChannelSize; *lpOut++ = 255 - *lpIn2; } else *lpOut++ = 0; if (lpTH->ColSepMask & 0x2) // magenta { *lpOut++ = 255 - *(lpIn2 + j); j += lpTH->ChannelSize; } else *lpOut++ = 0; if (lpTH->ColSepMask & 0x4) // yellow { *lpOut++ = 255 - *(lpIn2 + j); j += lpTH->ChannelSize; } else *lpOut++ = 0; } if (lpTH->ColSepMask & 0x8) // black *lpOut++ = 255 - *(lpIn2 + j); else *lpOut++ = 0; lpIn2++; } if( fConvert ) Convert.ConvertData( lpFrmLine, lpFrmLine, y, lpTH->Pixels ); } m_iWidth = lpTH->Pixels; m_iHeight = lpTH->Lines; m_iRes = (int)lpTH->Resolution; m_lpFrame = lpFrame; fRet = TRUE; goto Exit; BadRead: SetError(BEC_errFileRead); goto Exit; BadWrite: SetError(BEC_errFrameRead); Exit: FreeCTHeader(lpTH); CloseFile(pTheFile); if (!fRet && lpFrame) FrameClose(lpFrame); ProgressEnd(); return( fRet ); }