/* This is a dynamic link library that runs under Windows 3.00. Duties of this library include saving screen image to a file, retrieving screen image from file & displaying it on screen, and comparing two screen images. Routines in this module are responsible for copying screen image to the clipboard or saving the image to a bitmap file (in Device-Independent format). For the usage of this libray, please refer to the WattScr user's guide, WattScrU.doc. For the technical information, please refer to the WattScr maintenance's guide, WattScrT.doc. Revision History: [ 0] 18-Apr-1990 AngelaCh: Created program [ 1] 04-Map-1990 AngelaCh: added checking for existence of DIB file [ 2] 10-Map-1990 AngelaCh: initial fssScreen if saving image clipboard or DIB (bug #66) [ 3] 03-Jul-1990 AngelaCh: added support for Video 7 and 8515/a (bug #64) [ 4] 18-Jul-1991 DavidSc: Added WattDrvr TRAP support ******************************************************************************/ #include "windows.h" #include #include "dump.h" /****************************************************************************** * PURPOSE: Copy the image of a bitmap into the clipboard * * RETURN: 0 will be returned if image is copied successfully * * GLOBALS: None * * CONDITIONS:hwnd is the valid handle to a window * * bhm is valid handle to a bitmap * ******************************************************************************/ INT PRIVATE fCopyToCB(hwnd, hbm) HWND hwnd ; /* handle of a window */ HBITMAP hbm ; /* handle of a device-dep bitmap */ { if ( !(OpenClipboard(hwnd)) ) /* if clipboard is opened by another */ return OpenCB ; /* application */ if ( !(EmptyClipboard()) ) /* if existing data in clipboard is */ { /* locked */ CloseClipboard () ; return EmptyCB ; } if ( !(SetClipboardData(CF_BITMAP, hbm)) ) /* copy image to clipboard */ { CloseClipboard () ; return CopyToCB ; } if ( !(CloseClipboard()) ) return CloseCB ; return NoError ; } /****************************************************************************** * PURPOSE: This is called everytime a request is received to copy the image* * of a screen region onto the clipboard * * RETURN: 0 will be returned if image is copied to the clipboard * * GLOBALS: None * * CONDITIONS:rnIn defines a screen region whose image will be copied to the * * clipboard * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fDumpSrnToClipActivate(OpenKeys,CloseKeys,rnIn, hFlag) LPSTR OpenKeys; /* keys to activate something */ LPSTR CloseKeys; /* keys to deactivate something */ REN FAR *rnIn ; /* coord of a screen region */ INT hFlag ; /* if window of the calling app needs to be hidden */ { INT ret; HWND hWndCallingApp ; /* window of the calling application */ if ( hFlag && !(hWndCallingApp = HideApp()) ) return ErrorTrap(HideWin) ; /* can't hide the window */ if (LoadTESTEVT()) return ErrorTrap(LibLoadErr); if (OpenKeys) { DoKeys(OpenKeys); /* do some yields to allow keys to get to app and some time for it ** to respond. */ yield(); yield(); yield(); yield(); yield(); } ret = fDumpSrnToClip(rnIn, FALSE); if (CloseKeys) DoKeys(CloseKeys); if ( hFlag ) /* restore window of the calling app */ RestoreApp(hWndCallingApp) ; FreeTESTEVT(); return NoTrap(ret); } /****************************************************************************** * PURPOSE: This is called everytime a request is received to copy the image* * of a screen region onto the clipboard * * RETURN: 0 will be returned if image is copied to the clipboard * * GLOBALS: None * * CONDITIONS:rnIn defines a screen region whose image will be copied to the * * clipboard * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fDumpSrnToClip(rnIn, hFlag) REN FAR *rnIn ; /* coord of a screen region */ INT hFlag ; /* if window of the calling app needs to be hidden */ { HWND hWndCallingApp ; /* window of the calling application */ HBITMAP hBitmap ; /* handle of a device-dep bitmap */ REN rn ; INT i ; rn = *rnIn ; fssScreen.cscr = 0 ; /* no image has been saved [2] */ if ( (i = fGetScreenParams(&rn)) != 0 ) /* check if screen region is */ return ErrorTrap(i) ; /* valid */ if ( hFlag ) /* need to hide window of the */ { /* calling application */ if ( !(hWndCallingApp = HideApp()) ) return ErrorTrap(HideWin) ; /* can't hide the window */ } else /* otherwise, obtain the handle */ { /* of the current active window */ // BabakJ: API changed // if ( !(hWndCallingApp = GetActiveWindow()) ) if ( !(hWndCallingApp = GetForegroundWindow()) ) return ErrorTrap(InValWHand) ; } /* get a bitmap representing a */ if ( !(hBitmap = GetBMap(rn.col, rn.row, rn.width, rn.height)) ) return ErrorTrap(CreateDDB) ; /* screen region */ i = fCopyToCB(hWndCallingApp, hBitmap) ; /* copy image to the clipboard */ if ( hFlag ) /* restore window of the calling app */ RestoreApp(hWndCallingApp) ; return ErrorTrap(i) ; } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to copy the * * image of a window to the clipboard * * RETURN: 0 will be returned if image is copied to the clipboard * * GLOBALS: None * * CONDITIONS:hWnd is a valid handle (Null is handle of the current active * * window) * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fDumpWndToClipActivate(OpenKeys, CloseKeys, hFlag) LPSTR OpenKeys ; /* dokeys string to bring up window */ LPSTR CloseKeys ; /* dokeys string to remove window */ INT hFlag ; /* if window of the calling app needs to be hidden */ { INT ret; HWND hWndCallingApp ; /* window of the calling application */ if ( hFlag && !(hWndCallingApp = HideApp()) ) /* application first */ return ErrorTrap(HideWin) ; if (LoadTESTEVT()) return ErrorTrap(LibLoadErr); if (OpenKeys) { DoKeys(OpenKeys); /* do some yields to allow keys to get to app and some time for it ** to respond. */ yield(); yield(); yield(); yield(); yield(); } ret = fDumpWndToClip(NULL, FALSE); if (CloseKeys) DoKeys(CloseKeys); if ( hFlag ) /* if window has been hidded */ RestoreApp(hWndCallingApp) ; /* restore it */ FreeTESTEVT(); return NoTrap(ret); } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to copy the * * image of a window to the clipboard * * RETURN: 0 will be returned if image is copied to the clipboard * * GLOBALS: None * * CONDITIONS:hWnd is a valid handle (Null is handle of the current active * * window) * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fDumpWndToClip(hwnd, hFlag) HWND hwnd ; /* handle of a particular window */ INT hFlag ; /* if window of the calling app needs to be hidden */ { REN rn ; /* coord of the window in concern */ HWND hWndCallingApp ; /* window of the calling application */ HBITMAP hBitmap ; /* handle of a device-dep bitmap */ INT i ; if( FWinTrapCheckAndTrap( hwnd )) return ErrorTrap(InValWHand) ; // BabakJ: API changed // if ( !(hWndCallingApp = GetActiveWindow()) ) /* obtain the handle */ if ( !(hWndCallingApp = GetForegroundWindow()) ) /* obtain the handle */ return ErrorTrap(InValWHand) ; /* of the current active window */ if ( !hwnd ) /* if handle of the window is unknown */ { /* assume that it is the window of */ if ( hFlag ) /* the current active window */ { /* need to hide window of the calling */ if ( !(hWndCallingApp = HideApp()) ) /* application first */ return ErrorTrap(HideWin) ; } // BabakJ: API changed // hwnd = GetActiveWindow() ; /* get handle of the active window */ hwnd = GetForegroundWindow() ; /* get handle of the active window */ } GetWindowRect(hwnd, (LPRECT)&rn) ; /* determine the coord of the window */ /* subtract 1 pixel from the lower- */ rn.width-- ; /* right corner - it seems that it */ rn.height--; /* returns 1 pixel many to the right */ /* and on the bottom */ fssScreen.cscr = 0 ; /* no image has been saved [2] */ if ( (i = fGetScreenParams((REN FAR *)&rn)) != 0 ) /* convert 2 pairs of */ return ErrorTrap(i) ; /* coord to upper-left, width, height */ if ( !(hBitmap = GetBMap(rn.col, rn.row, rn.width, rn.height)) ) return ErrorTrap(CreateDDB) ; /* create bitmap that represents the */ /* currently active window */ i = fCopyToCB(hWndCallingApp, hBitmap) ; /* copy image to the clipboard */ if ( hFlag ) /* if window has been hidded */ RestoreApp(hWndCallingApp) ; /* restore it */ return ErrorTrap(i) ; } /****************************************************************************** * PURPOSE: Create a bitmap in device-dependent format from a device- * * independent bitmap * * RETURN: Handle of the device-dependent bitmap if succeed * * GLOBALS: fssScreen * * CONDITIONS:fd is a valid file handle * * pscr is pointing to a particular screen table * ******************************************************************************/ HBITMAP PRIVATE SetDiBToBM(fd, pscr) FD fd ; /* handle to the screen file */ SCR *pscr ; /* pointer of a screen table */ { LPBITMAPINFOHEADER lpbi ; /* point to the DiBitmap header */ BITMAPINFOHEADER bi ; /* header of a DiBitmap */ GLOBALHANDLE hGlobalMemory ; /* handle of a global memory area */ HBITMAP hbm ; /* handle of the DDBitmap */ HPALETTE hPalO ; /* handle of the existing color pal */ LPSTR lp ; HDC hDC ; INT oHeight, nHeight ; INT y ; INT IsComp ; LONG fb ; WORD cb ; INT nStart ; INT i = 0 , j = NoError ; hDC = CreateDC("DISPLAY", NULL, NULL, NULL) ; hbm = CreateCompatibleBitmap(hDC, pscr->ren.width, pscr->ren.height) ; if ( IsPalDev ) /* this is a palette device, need */ { /* to obtain a logical palette which */ hPal = CreatePalFromDIB(); /* represents the available colours */ /* [3] */ if ( hPal ) /* logical color palette is available */ { hPalO = SelectPalette(hDC, hPal, FALSE) ; RealizePalette(hDC) ; } else // BabakJ: Casted the constant return code to prevent warning return( (HBITMAP)CreatePal ); /* error in creating logical pal */ } fb = sizeof(BITMAPINFOHEADER) + fssScreen.ClrUse + MaxSize ; hGlobalMemory = GlobalAlloc (GMEM_MOVEABLE | GMEM_DISCARDABLE, fb) ; if ( !hGlobalMemory ) /* no memory is allocated */ j = OutOMemory ; else { lpbi = (LPBITMAPINFOHEADER) GlobalLock (hGlobalMemory) ; lp = (LPSTR)lpbi+(WORD)sizeof(BITMAPINFOHEADER)+(WORD)fssScreen.ClrUse ; oHeight = pscr->ren.height ; y = 0 ; nStart = oHeight ; do /* read in bitmap as different 64k */ { /* sub-bitmaps if the original image */ if ( pscr->cb[i] ) /* is saved as different sub-bitmaps */ { nHeight = (INT)oHeight / (MaxCb-i) ; IsComp = (1<<(i % 16)) & pscr->cbComp[i>>4] ; /* info about */ /* compression [3] */ cb = ReadDibBytes((LPSTR)lpbi, fd, pscr->ren.width, nHeight, pscr->cb[i], IsComp) ; if ( !cb ) /* unsuccessfully reading the bytes */ j = ReadSrnFil ; else { /* cb = actual size of the sub-bitmap */ pscr->cb[i] = cb ; /* need to paste the sub-bitmap whose */ nStart -= nHeight ; /* origin is lower-left bottom up */ bi = *lpbi ; /* also need to specify the height */ bi.biHeight = pscr->ren.height ; /* of the entire bitmap */ *lpbi = bi ; /* get a DDB from a DIB */ if ( !(SetDIBits(hDC, hbm, nStart, (WORD)nHeight, lp, (LPBITMAPINFO)lpbi, DIB_RGB_COLORS)) ) j = CreateDDB ; /* DDB from the DIB */ } oHeight -= nHeight ; y += nHeight ; } /* if ( pscr->cb[i] ) */ i++ ; } while (i < MaxCb && j == 0 ) ; } /* if ( !hGlobalMemory ) */ if ( IsPalDev ) { SelectPalette(hDC, hPalO, FALSE) ; /* restore old color palette */ DeleteObject(hPal) ; } DeleteDC(hDC) ; /* release memory before return */ if ( GlobalUnlock(hGlobalMemory) ) /* problem in releasing */ j = RelMemory ; /* memories */ if ( GlobalFree(hGlobalMemory) ) j = RelMemory ; if ( j ) { DeleteObject(hbm) ; hbm = NULL ; } return hbm ; } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to copy the * * image of a screen region that is stored in a screen file to * * the clipboard * * RETURN: 0 will be returned if image is copied to the clipboard * * GLOBALS: None * * CONDITIONS:FileName is name of file in correct format (8.3) * * nscr is valid (> 0) * ******************************************************************************/ INT FARPUBLIC fDumpFileToClip(FileName, nscr) LPSTR FileName ; /* name of the screen file */ INT nscr ; /* identify which screen to copy */ { HBITMAP hBitmap ; /* handle of a device-dep bitmap */ HWND hWnd ; /* handle of a window */ FD fdScreen = fdNull ; /* handle of a file */ INT i ; if ( (i = ProcessSrnFile(FileName, &fdScreen, nscr, omRead)) != 0 ) return ErrorTrap(i) ; /* open and read the screen file */ if ( DetermineMode(&i, &i) != fssScreen.vmd ) /* check video mode */ { M_lclose(fdScreen) ; return ErrorTrap(InValSrnMd) ; } /* read file and convert the bitmap to Device-Dependent format */ if ( !(hBitmap = SetDiBToBM(fdScreen, &rgscr[nscr-1])) ) return ErrorTrap(CreateDDB) ; // BabakJ: API changed // if ( !(hWnd = GetActiveWindow()) ) /* obtain the handle */ if ( !(hWnd = GetForegroundWindow()) ) /* obtain the handle */ return ErrorTrap(InValWHand) ; /* of the current active window */ return ErrorTrap(fCopyToCB(hWnd, hBitmap)) ; /* copy image to clipboard */ } /****************************************************************************** * PURPOSE: Extract screen image from a screen file and save the image as * * a Device-Independent Bitmap * * RETURN: 0 will be returned if image is saved successfully * * GLOBALS: None * * CONDITIONS:fdIn and fdOut are valid file handles * * pscr is pointer to the screen table corresponding to the screen * * image to be saved * ******************************************************************************/ INT PRIVATE fWriteToDIB(fdIn, fdOut, pscr) FD fdIn ; /* file handle of the input file */ FD fdOut ; /* file handle of the output file */ SCR *pscr ; /* pointer to the screen table */ { GLOBALHANDLE hGMemIn ; /* handle of a global memory area */ GLOBALHANDLE hGMemOut ; LPSTR lpIn ; /* pointer to the global memory area */ LPSTR lpOut ; WORD cb ; /* number of bytes written */ LFO lfo ; INT i ; INT j = 0 ; INT k ; i = MaxCb - 1 ; do /* copy bytes in at most 64K block */ { if ( pscr->cb[i] ) /* if bytes exists */ { /* allocate memory for reading data */ k = 0 ; lfo = pscr->lfo ; /* origin of image store in file is */ while ( k < i ) /* the upper-left corner; however, */ lfo += (LFO)pscr->cb[k++] ; /* origin of a device-independent */ if ( M_llseek(fdIn, lfo, smFromBegin) != (LONG2DWORD)lfo ) /* bitmap is the */ j = ReadSrnFil ; /* lower left corner, so need to */ else /* move all the bytes from the */ { /* bottom up */ hGMemIn = GlobalAlloc(GMEM_MOVEABLE | GMEM_DISCARDABLE, (DWORD)pscr->cb[i]) ; if ( !hGMemIn ) /* no memory is available */ j = OutOMemory ; else { lpIn = (LPSTR) GlobalLock(hGMemIn) ; if ( M_lread(fdIn, lpIn, pscr->cb[i]) != (UINT)pscr->cb[i] ) j = ReadSrnFil ; else { if ( (1 << (i % 16)) & pscr->cbComp[i>>4] ) /* compression's */ { /* been performed need to decompress the data [3] */ hGMemOut = GlobalAlloc(GMEM_MOVEABLE | GMEM_DISCARDABLE, (DWORD)MaxSize) ; if ( !hGMemOut ) /* first; so allocate memory for */ j = OutOMemory ; /* the decompressed data */ else { lpOut = (LPSTR) GlobalLock(hGMemOut) ; cb = DeCompressBytes(lpIn, lpOut, pscr->cb[i]) ; // Babakj: Bypassed compression by replacing lpOut with lpIn // if ( M_lwrite(fdOut, lpOut, cb) != (UINT)cb ) if ( M_lwrite(fdOut, lpIn, cb) != (UINT)cb ) j = WSrnImage ; pscr->cb[i] = cb ; /* actual size of the bitmap */ if ( GlobalUnlock(hGMemOut) || GlobalFree(hGMemOut) ) j = RelMemory ; } /* if ( !hGMemOut ) */ } /* if ( 1 << i ) */ else /* no de-compression need to be */ if ( M_lwrite(fdOut, lpIn, pscr->cb[i]) != (UINT)pscr->cb[i] ) j = WSrnImage ; /* performed, copy the bytes */ } /* directly */ if ( GlobalUnlock(hGMemIn) || GlobalFree(hGMemIn) ) j = RelMemory ; } /* if ( !hGMemIn ) */ } /* if LSeek */ } /* if pscr->cb[i] */ i-- ; } while ( i >= 0 && j == 0 ) ; return j ; } /****************************************************************************** * PURPOSE: Write header of the device-indpendent bitmap file to a bitmap * * file before closing that file * * RETURN: 0 will be returned if header is written to the file successfully* * GLOBALS: None * * CONDITIONS:fdIn and fdOut are valid file handles * * pscr is pointer to the screen table corresponding to the screen * * image to be copied * ******************************************************************************/ INT PRIVATE fCloseDIB(fd, pscr) FD fd ; /* file handle of the DI-Bitmap file */ SCR *pscr ; /* pointer to the screen table */ { BITMAPFILEHEADER bf ; /* header of the DI-bitmap file */ BITMAPINFOHEADER bi ; /* header of the DI-bitmap info */ DWORD lInfo ; /* size of headers + colour tables */ DWORD lfo = 0 ; /* size of bitmap bytes */ INT i ; for (i = 0 ; i < MaxCb ; i++) /* size of the array representing */ lfo += (DWORD)pscr->cb[i] ; /* bytes of the bitmap */ lInfo = (DWORD)sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+fssScreen.ClrUse ; /* fill in information about the type, size and layout of the device independent bitmap */ bf.bfType = (WORD) DIBid ; /* file type = BM */ bf.bfSize = lInfo + lfo ; /* file size = size of info + bytes */ bf.bfReserved1 = 0 ; bf.bfReserved2 = 0 ; bf.bfOffBits = lInfo ; /* offset to bytes = size of info */ /* fill in information about the dimension and colour format of the device-independent bitmap */ bi.biSize = (DWORD)sizeof(BITMAPINFOHEADER) ; /* size of the info header */ bi.biWidth = (DWORD)pscr->ren.width ; /* width of bitmap */ bi.biHeight = (DWORD)pscr->ren.height ; /* height of bitmap */ bi.biPlanes = dbiPlanes ; /* number of planes - must be 1 */ bi.biBitCount = fssScreen.BitCount ;/* no of bit per pixel */ bi.biCompression = (DWORD)MaxComp ; /* Max compression style */ bi.biSizeImage = lfo ; /* size of the bitmap */ bi.biXPelsPerMeter = 0 ; bi.biYPelsPerMeter = 0 ; bi.biClrUsed = (DWORD)fssScreen.ClrUse / sizeof(RGBQUAD) ; bi.biClrImportant = 0 ; M_llseek(fd, 0L, smFromBegin) ; /* go the the beginning of file */ if ( M_lwrite(fd, (LPSTR)&bf, sizeof(BITMAPFILEHEADER)) != (UINT)sizeof(BITMAPFILEHEADER) ) { /* and write out headers */ M_lclose(fd) ; return WFileHead ; } if ( M_lwrite(fd, (LPSTR)&bi, sizeof(BITMAPINFOHEADER)) != (UINT)sizeof(BITMAPINFOHEADER) ) { M_lclose(fd) ; return WFileHead ; } M_lclose(fd) ; return NoError ; } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to save a screen* * image to a file in straight Device-Independent Bitmap format * * RETURN: 0 will be returned if image is copied to the file successfully * * GLOBALS: None * * CONDITIONS:FileName is name of file in correct format (8.3) * * rn defines a screen region whose image will be saved to file * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fSaveSrnToDIBActivate(FileName, OpenKeys,CloseKeys,rn, hFlag) LPSTR FileName ; /* name of the bitmap file */ LPSTR OpenKeys; /* keys to activate something */ LPSTR CloseKeys; /* keys to deactivate something */ REN FAR *rn ; /* coord of a screen region */ INT hFlag ; /* need to hide wnd of calling app? */ { INT ret; HWND hWndCallingApp ; /* window of the calling application */ if ( hFlag && !(hWndCallingApp = HideApp()) ) /* application first */ return ErrorTrap(HideWin) ; if (LoadTESTEVT()) return ErrorTrap(LibLoadErr); if (OpenKeys) { DoKeys(OpenKeys); /* do some yields to allow keys to get to app and some time for it ** to respond. */ yield(); yield(); yield(); yield(); yield(); } ret = fSaveSrnToDIB(FileName,rn, FALSE); if (CloseKeys) DoKeys(CloseKeys); if ( hFlag ) /* if window has been hidded */ RestoreApp(hWndCallingApp) ; /* restore it */ FreeTESTEVT(); return NoTrap(ret); } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to save a screen* * image to a file in straight Device-Independent Bitmap format * * RETURN: 0 will be returned if image is copied to the file successfully * * GLOBALS: None * * CONDITIONS:FileName is name of file in correct format (8.3) * * rn defines a screen region whose image will be saved to file * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fSaveSrnToDIB(FileName, rn, hFlag) LPSTR FileName ; /* name of the bitmap file */ REN FAR *rn ; /* coord of a screen region */ INT hFlag ; /* need to hide wnd of calling app? */ { FD fdScreen = fdNull ; /* handle of the output file */ INT fFlag = DIBFirst ; /* type of file is DIB */ INT i ; if ( (fdScreen = M_lopen(FileName,omRead)) != fdNull ) /* [1] */ { M_lclose(fdScreen) ; /* file already exists */ return ErrorTrap(FileExist) ; } if ( (fdScreen = M_lcreat(FileName, 0)) == fdNull ) /* create output file */ return ErrorTrap(FileAccess) ; fssScreen.cscr = 0 ; /* no image has been saved [2] */ rgscr[0].ren = *rn ; rgscr[0].lfo = (LFO)sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) ; /* write data to output file */ if ( (i = fAddScreen(fdScreen, &rgscr[0], hFlag, &fFlag)) != 0 ) { M_lclose(fdScreen) ; return ErrorTrap(i) ; } return ErrorTrap( fCloseDIB(fdScreen, &rgscr[0]) ) ; /* close file */ } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to save image of* * a window to file in straight Device-Independent Bitmap format * * RETURN: 0 will be returned if image is copied to the file successfully * * GLOBALS: None * * CONDITIONS:FileName is name of file in correct format (8.3) * * hwnd is valid handle of window * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fSaveWndToDIBActivate(FileName, OpenKeys, CloseKeys, hFlag) LPSTR FileName ; /* name of the bitmap file */ LPSTR OpenKeys ; /* dokeys string to bring up window */ LPSTR CloseKeys ; /* dokeys string to remove window */ INT hFlag ; /* need to hide wnd of calling app? */ { INT ret; HWND hWndCallingApp ; /* window of the calling application */ if ( hFlag && !(hWndCallingApp = HideApp()) ) /* application first */ return ErrorTrap(HideWin) ; if (LoadTESTEVT()) return ErrorTrap(LibLoadErr); if (OpenKeys) { DoKeys(OpenKeys); /* do some yields to allow keys to get to app and some time for it ** to respond. */ yield(); yield(); yield(); yield(); yield(); } ret = fSaveWndToDIB(FileName,NULL, FALSE); if (CloseKeys) DoKeys(CloseKeys); if ( hFlag ) /* if window has been hidded */ RestoreApp(hWndCallingApp) ; /* restore it */ FreeTESTEVT(); return NoTrap(ret); } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to save image of* * a window to file in straight Device-Independent Bitmap format * * RETURN: 0 will be returned if image is copied to the file successfully * * GLOBALS: None * * CONDITIONS:FileName is name of file in correct format (8.3) * * hwnd is valid handle of window * * hFlag is valid (0 no need to hide the calling app's window) * ******************************************************************************/ INT FARPUBLIC fSaveWndToDIB(FileName, hWnd, hFlag) LPSTR FileName ; /* name of the bitmap file */ HWND hWnd ; /* handle of a window */ INT hFlag ; /* need to hide wnd of calling app? */ { REN rn ; /* store coordinates of the window */ HWND hWndCallingApp = NULL ; /* handle of the calling app's window */ INT i ; if( FWinTrapCheckAndTrap( hWnd ) ) return ErrorTrap(InValWHand) ; /* get dimenions of the active window */ if ( (i = fGetWndDim(hWnd, &hWndCallingApp, &hFlag, (REN FAR *)&rn)) != 0 ) return ErrorTrap(i) ; i = fSaveSrnToDIB(FileName, (REN FAR *)&rn, hFlag) ; /* take picture of the screen region */ if ( hWndCallingApp ) /* need to restore the calling app's */ RestoreApp(hWndCallingApp) ; /* window if it has been hidden */ return NoTrap(i) ; // EventError already called in fSaveSrnToDIB } /****************************************************************************** * PURPOSE: This is called everytime a request is receieved to copy the * * image of a screen region that is stored in a screen file to* * another file in straight Device-Independent Bitmap format * * RETURN: 0 will be returned if image is copied to the file successfully * * GLOBALS: None * * CONDITIONS:FileIn and FileOut are names of files in correct format (8.3) * * nscr is valid (> 0) * ******************************************************************************/ INT FARPUBLIC fSaveFileToDIB(FileIn, nscr, FileOut) LPSTR FileIn; /* name of the screen file */ INT nscr ; /* identify which screen to copy */ LPSTR FileOut ; /* name of bitmap file */ { FD fdIn ; /* file handle of the input file */ FD fdOut = fdNull ; /* file handle of the output file */ LFO lfo ; INT i ; /* validate input file */ if ( (i = ProcessSrnFile(FileIn, &fdIn, nscr, omRead)) != 0) return ErrorTrap(i) ; if ( DetermineMode(&i, &i) != fssScreen.vmd ) /* validate screen mode */ { M_lclose(fdIn) ; return ErrorTrap(InValSrnMd) ; } if ( (fdOut = M_lopen(FileOut,omRead)) != fdNull ) /* [1] */ { M_lclose(fdIn) ; /* file already exists */ M_lclose(fdOut) ; return ErrorTrap(FileExist) ; } if ( (fdOut = M_lcreat(FileOut, 0)) == fdNull ) /* create bitmap file */ { M_lclose(fdIn) ; return ErrorTrap(FileAccess) ; } /* move pass the header for writing */ lfo = (LFO) sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) ; if ( M_llseek(fdOut, lfo, smFromBegin) != (LONG2DWORD)lfo ) /* the colour table */ { M_lclose(fdIn) ; M_lclose(fdOut) ; return ErrorTrap(RWColTable) ; } if ( M_lwrite(fdOut, (LPSTR)ClrTab, fssScreen.ClrUse) != (UINT)fssScreen.ClrUse ) { /* write information about the colour */ M_lclose(fdIn) ; /* of the Device-Independent Bitmap */ M_lclose(fdOut) ; /* to the file */ return ErrorTrap(RWColTable) ; } i = fWriteToDIB(fdIn, fdOut, &rgscr[nscr-1]) ; /* write data to DIB file */ M_lclose(fdIn) ; /* (it is at the correct position) */ if ( i ) /* error occurs when writing to */ { /* the bitmap file */ M_lclose(fdOut) ; return ErrorTrap(i) ; } else /* otherwise, write header to the */ return ErrorTrap(fCloseDIB(fdOut, &rgscr[nscr-1])) ; /* bitmap file before */ /* closing the file */ }