841 lines
36 KiB
C
841 lines
36 KiB
C
|
/*
|
||
|
|
|
||
|
|
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 <port1632.h>
|
||
|
|
#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 */
|
||
|
|
}
|