1766 lines
39 KiB
C++
1766 lines
39 KiB
C++
//
|
||
// CCL32.CPP
|
||
// Common Control Classes
|
||
//
|
||
// Copyright Microsoft 1998-
|
||
//
|
||
|
||
// PRECOMP
|
||
#include "precomp.h"
|
||
#define COMPILE_MULTIMON_STUBS
|
||
#include <multimon.h>
|
||
|
||
LRESULT CALLBACK DummyMouseHookProc( int code, WPARAM wParam, LPARAM lParam );
|
||
|
||
|
||
|
||
HHOOK g_utMouseHookHandle = NULL;
|
||
HWND g_utCaptureWindow = NULL;
|
||
|
||
|
||
|
||
|
||
|
||
void UT_CaptureMouse( HWND hwnd )
|
||
{
|
||
// disable asynchronous input so we don't lose capture because the
|
||
// left button isn't down
|
||
g_utMouseHookHandle = SetWindowsHookEx( WH_JOURNALRECORD,
|
||
DummyMouseHookProc,
|
||
g_hInstance,
|
||
NULL );
|
||
|
||
if( g_utMouseHookHandle == NULL )
|
||
{
|
||
WARNING_OUT(("Failed to insert JournalRecord hook"));
|
||
}
|
||
|
||
// grap mouse
|
||
::SetCapture(hwnd);
|
||
g_utCaptureWindow = hwnd;
|
||
}
|
||
|
||
|
||
void UT_ReleaseMouse( HWND hwnd )
|
||
{
|
||
::ReleaseCapture();
|
||
g_utCaptureWindow = NULL;
|
||
|
||
if (g_utMouseHookHandle != NULL )
|
||
{
|
||
// le go my lego
|
||
::UnhookWindowsHookEx( g_utMouseHookHandle );
|
||
g_utMouseHookHandle = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
LRESULT CALLBACK DummyMouseHookProc( int code, WPARAM wParam, LPARAM lParam )
|
||
{
|
||
return( CallNextHookEx( g_utMouseHookHandle, code, wParam, lParam ) );
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
// General definitions
|
||
//
|
||
#define MAX_OPTIONS_LINE_LENGTH 255
|
||
#define MAX_SECTION_LEN 200
|
||
|
||
|
||
//
|
||
//
|
||
// Function: HexDigitToByte
|
||
//
|
||
// Purpose: Helper function to convert a single hex digit to a byte value.
|
||
//
|
||
//
|
||
BOOL HexDigitToByte(char cHexDigit, BYTE& byte);
|
||
|
||
BOOL HexDigitToByte(char cHexDigit, BYTE& byte)
|
||
{
|
||
// Decimal digits
|
||
if ( (cHexDigit >= '0')
|
||
&& (cHexDigit <= '9'))
|
||
{
|
||
byte = (BYTE) (cHexDigit - '0');
|
||
return(TRUE);
|
||
}
|
||
|
||
// Uppercase characters
|
||
if ( (cHexDigit >= 'A')
|
||
&& (cHexDigit <= 'F'))
|
||
{
|
||
byte = (BYTE) ((cHexDigit - 'A') + 10);
|
||
return(TRUE);
|
||
}
|
||
|
||
// Lowercase characters
|
||
if ( (cHexDigit >= 'a')
|
||
&& (cHexDigit <= 'f'))
|
||
{
|
||
byte = (BYTE) ((cHexDigit - 'a') + 10);
|
||
return(TRUE);
|
||
}
|
||
|
||
// The character is not a valid hex digit
|
||
return(FALSE);
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: GetIntegerOption
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and convert the
|
||
// option string to a long integer value.
|
||
//
|
||
//
|
||
LONG OPT_GetIntegerOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
LONG lDefault
|
||
)
|
||
{
|
||
LONG lResult;
|
||
TCHAR cstrValue[MAX_OPTIONS_LINE_LENGTH];
|
||
|
||
if (OPT_Lookup(cstrOptionName, cstrValue, MAX_OPTIONS_LINE_LENGTH))
|
||
{
|
||
// Option has been found, convert it to a long
|
||
lResult = RtStrToInt(cstrValue);
|
||
}
|
||
else
|
||
{
|
||
// The option is not in the dictionary, return the default
|
||
lResult = lDefault;
|
||
}
|
||
|
||
return lResult;
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: GetBooleanOption
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and convert it to
|
||
// a boolean value.
|
||
//
|
||
//
|
||
BOOL OPT_GetBooleanOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
BOOL bDefault
|
||
)
|
||
{
|
||
TCHAR cstrValue[MAX_OPTIONS_LINE_LENGTH];
|
||
|
||
// Lookup the option
|
||
if (OPT_Lookup(cstrOptionName, cstrValue,MAX_OPTIONS_LINE_LENGTH))
|
||
{
|
||
return(cstrValue[0] == 'y' || cstrValue[0] =='Y') ;
|
||
}
|
||
|
||
return bDefault;
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: GetStringOption
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and return a copy
|
||
// of it. No conversion of the string is performed.
|
||
//
|
||
//
|
||
void OPT_GetStringOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
LPSTR cstrValue,
|
||
UINT size
|
||
)
|
||
{
|
||
if (!OPT_Lookup(cstrOptionName, cstrValue, size) || !(lstrlen(cstrValue)))
|
||
{
|
||
*cstrValue = _T('\0');
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: Lookup
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and return a copy
|
||
// of it in the CString object passed. No conversion is performed.
|
||
//
|
||
//
|
||
BOOL OPT_Lookup
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
LPCSTR cstrResult,
|
||
UINT size
|
||
)
|
||
{
|
||
BOOL fSuccess = FALSE;
|
||
HKEY read_hkey = NULL;
|
||
DWORD read_type;
|
||
DWORD read_bufsize;
|
||
|
||
// open key
|
||
if (RegOpenKeyEx( HKEY_CURRENT_USER,
|
||
WHITEBOARD_KEY,
|
||
0,
|
||
KEY_EXECUTE,
|
||
&read_hkey )
|
||
!= ERROR_SUCCESS )
|
||
{
|
||
TRACE_MSG(("Could not open key"));
|
||
goto bail_out;
|
||
}
|
||
|
||
|
||
// read key's value
|
||
read_bufsize = size;
|
||
if (RegQueryValueEx( read_hkey,
|
||
cstrOptionName,
|
||
NULL,
|
||
&read_type,
|
||
(LPBYTE)cstrResult,
|
||
&read_bufsize )
|
||
!= ERROR_SUCCESS )
|
||
{
|
||
TRACE_MSG(("Could not read key"));
|
||
goto bail_out;
|
||
}
|
||
|
||
|
||
// check for valid type
|
||
if (read_type != REG_SZ)
|
||
{
|
||
WARNING_OUT(("Bad key data"));
|
||
goto bail_out;
|
||
}
|
||
|
||
fSuccess = TRUE;
|
||
|
||
bail_out:
|
||
if (read_hkey != NULL)
|
||
RegCloseKey(read_hkey);
|
||
|
||
return (fSuccess);
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: GetWindowRectOption
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and convert it to
|
||
// a window rectangle. The rectangle is checked to make sure that
|
||
// it is at least partially on screen, and not zero sized.
|
||
//
|
||
//
|
||
void OPT_GetWindowRectOption
|
||
(
|
||
LPCSTR optionName,
|
||
LPRECT lprc,
|
||
LPCRECT lprcDefault
|
||
)
|
||
{
|
||
int iLeft;
|
||
int iTop;
|
||
int iRight;
|
||
int iBottom;
|
||
TCHAR cstrValue[MAX_OPTIONS_LINE_LENGTH];
|
||
|
||
if (OPT_Lookup(optionName, cstrValue,MAX_OPTIONS_LINE_LENGTH))
|
||
{
|
||
// Option has been found, parse it to a rectangle
|
||
iLeft = RtStrToInt(StrTok(cstrValue, " ,"));
|
||
iTop = RtStrToInt(StrTok(NULL, " ,"));
|
||
iRight = RtStrToInt(StrTok(NULL, " ,"));
|
||
iBottom = RtStrToInt(StrTok(NULL, " ,"));
|
||
|
||
// Check for non-zero size
|
||
if ((iRight <= iLeft) || (iBottom <= iTop))
|
||
{
|
||
*lprc = *lprcDefault;
|
||
}
|
||
else
|
||
{
|
||
// Make sure that the window rectangle is (at least partially) on
|
||
// screen, and not too large. First get the screen size
|
||
int screenWidth = ::GetSystemMetrics(SM_CXSCREEN);
|
||
int screenHeight = ::GetSystemMetrics(SM_CYSCREEN);
|
||
|
||
// Check the window size
|
||
if ((iRight - iLeft) > screenWidth)
|
||
{
|
||
iRight = iLeft + screenWidth;
|
||
}
|
||
|
||
if ((iBottom - iTop) > screenHeight)
|
||
{
|
||
iTop = screenHeight;
|
||
}
|
||
|
||
// Check the window position
|
||
if (iLeft >= screenWidth)
|
||
{
|
||
// Off screen to the right - keep the width the same
|
||
iLeft = screenWidth - (iRight - iLeft);
|
||
iRight = screenWidth;
|
||
}
|
||
|
||
if (iRight < 0)
|
||
{
|
||
// Off screen to the left - keep the width the same
|
||
iRight = iRight - iLeft;
|
||
iLeft = 0;
|
||
}
|
||
|
||
if (iTop >= screenHeight)
|
||
{
|
||
// Off screen to the bottom - keep the height the same
|
||
iTop = screenHeight - (iBottom - iTop);
|
||
iBottom = screenHeight;
|
||
}
|
||
|
||
if (iBottom < 0)
|
||
{
|
||
// Off screen to the top - keep the height the same
|
||
iBottom = (iBottom - iTop);
|
||
iTop = 0;
|
||
}
|
||
|
||
lprc->left = iLeft;
|
||
lprc->top = iTop;
|
||
lprc->right = iRight;
|
||
lprc->bottom = iBottom;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// The option is not in the dictionary, return the default
|
||
*lprc = *lprcDefault;
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: GetDataOption
|
||
//
|
||
// Purpose: Retrieve a named option from the dictionary and parse it as
|
||
// an ASCII representation of a string of hex bytes.
|
||
//
|
||
//
|
||
int OPT_GetDataOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
int iBufferLength,
|
||
BYTE* pbResult
|
||
)
|
||
{
|
||
TCHAR cstrValue[MAX_OPTIONS_LINE_LENGTH];
|
||
BYTE* pbSaveResult = pbResult;
|
||
|
||
// Lookup the option
|
||
OPT_GetStringOption(cstrOptionName, cstrValue,MAX_OPTIONS_LINE_LENGTH);
|
||
if (lstrlen(cstrValue))
|
||
{
|
||
// Calculate the maximum number of characters to convert
|
||
int iMaxChars = min(2 * iBufferLength, lstrlen(cstrValue));
|
||
|
||
// Option found, convert the string to hex bytes
|
||
for (int iIndex = 0; iIndex < iMaxChars; iIndex += 2)
|
||
{
|
||
BYTE bByteHigh = 0;
|
||
BYTE bByteLow = 0;
|
||
|
||
if ( (HexDigitToByte(cstrValue[iIndex], bByteHigh) == FALSE)
|
||
|| (HexDigitToByte(cstrValue[iIndex + 1], bByteLow) == FALSE))
|
||
{
|
||
// The character was not a valid hex digit
|
||
break;
|
||
}
|
||
|
||
// Build the result byte
|
||
*pbResult++ = (BYTE) ((bByteHigh << 4) | bByteLow);
|
||
}
|
||
}
|
||
|
||
// Return the length of data in the buffer
|
||
return (int)(pbResult - pbSaveResult);
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: SetStringOption
|
||
//
|
||
// Purpose: Set the value of an option in the dictionary.
|
||
//
|
||
|
||
//
|
||
BOOL OPT_SetStringOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
LPCSTR cstrValue
|
||
)
|
||
{
|
||
BOOL fSuccess = FALSE;
|
||
HKEY write_hkey = NULL;
|
||
DWORD disposition;
|
||
|
||
// open or create the key
|
||
if (RegCreateKeyEx( HKEY_CURRENT_USER,
|
||
WHITEBOARD_KEY,
|
||
0,
|
||
NULL,
|
||
REG_OPTION_NON_VOLATILE,
|
||
KEY_ALL_ACCESS,
|
||
NULL,
|
||
&write_hkey,
|
||
&disposition) != ERROR_SUCCESS)
|
||
{
|
||
WARNING_OUT(("Could not write key"));
|
||
goto bail_out;
|
||
}
|
||
|
||
// got data, write the value
|
||
if (RegSetValueEx( write_hkey,
|
||
cstrOptionName,
|
||
0,
|
||
REG_SZ,
|
||
(LPBYTE)cstrValue,
|
||
_tcsclen(cstrValue) + sizeof(TCHAR)) != ERROR_SUCCESS )
|
||
{
|
||
WARNING_OUT(("Could not write key value"));
|
||
goto bail_out;
|
||
}
|
||
|
||
fSuccess = TRUE;
|
||
|
||
bail_out:
|
||
if (write_hkey != NULL)
|
||
RegCloseKey(write_hkey);
|
||
|
||
return(fSuccess);
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: SetIntegerOption
|
||
//
|
||
// Purpose: Write an integer option
|
||
//
|
||
//
|
||
BOOL OPT_SetIntegerOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
LONG lValue
|
||
)
|
||
{
|
||
char cBuffer[20];
|
||
|
||
// Convert the integer value to ASCII decimal
|
||
wsprintf(cBuffer, "%ld", lValue);
|
||
|
||
// Write the option
|
||
return OPT_SetStringOption(cstrOptionName, cBuffer);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: SetBooleanOption
|
||
//
|
||
// Purpose: Write a boolean option
|
||
//
|
||
//
|
||
BOOL OPT_SetBooleanOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
BOOL bValue
|
||
)
|
||
{
|
||
char cBuffer[8];
|
||
|
||
wsprintf(cBuffer, "%c", (bValue ? 'Y' : 'N'));
|
||
|
||
// Write the option
|
||
return OPT_SetStringOption(cstrOptionName, cBuffer);
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: SetWindowRectOption
|
||
//
|
||
// Purpose: Write a window position rectangle
|
||
//
|
||
//
|
||
BOOL OPT_SetWindowRectOption
|
||
(
|
||
LPCSTR optionName,
|
||
LPCRECT lpwindowRect
|
||
)
|
||
{
|
||
char cBuffer[64];
|
||
|
||
// Convert the integer values to ASCII decimal
|
||
wsprintf(cBuffer, "%d,%d,%d,%d",
|
||
lpwindowRect->left, lpwindowRect->top, lpwindowRect->right,
|
||
lpwindowRect->bottom);
|
||
|
||
// Write the option
|
||
return OPT_SetStringOption(optionName, cBuffer);
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: SetDataOption
|
||
//
|
||
// Purpose: Write a data option to the options file
|
||
//
|
||
//
|
||
BOOL OPT_SetDataOption
|
||
(
|
||
LPCSTR cstrOptionName,
|
||
int iBufferLength,
|
||
BYTE* pbBuffer
|
||
)
|
||
{
|
||
char cBuffer[1024];
|
||
LPSTR cTmp;
|
||
|
||
ASSERT(iBufferLength*2 < sizeof(cBuffer));
|
||
|
||
// Loop through the data array converting a byte at a time
|
||
cTmp = cBuffer;
|
||
for (int iIndex = 0; iIndex < iBufferLength; iIndex++)
|
||
{
|
||
// Convert the next byte to ASCII hex
|
||
wsprintf(cTmp, "%02x", pbBuffer[iIndex]);
|
||
|
||
// add it to the string to be written
|
||
cTmp += lstrlen(cTmp);
|
||
}
|
||
|
||
// Write the option
|
||
return OPT_SetStringOption(cstrOptionName, cBuffer);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: CreateSystemPalette
|
||
//
|
||
// Purpose: Get a palette representing the system palette
|
||
//
|
||
//
|
||
HPALETTE CreateSystemPalette(void)
|
||
{
|
||
LPLOGPALETTE lpLogPal;
|
||
HDC hdc;
|
||
HPALETTE hPal = NULL;
|
||
int nColors;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "CreateSystemPalette");
|
||
|
||
hdc = ::CreateIC("DISPLAY", NULL, NULL, NULL);
|
||
|
||
if (!hdc)
|
||
{
|
||
ERROR_OUT(("Couldn't create DISPLAY IC"));
|
||
return(NULL);
|
||
}
|
||
|
||
nColors = ::GetDeviceCaps(hdc, SIZEPALETTE);
|
||
|
||
::DeleteDC(hdc);
|
||
|
||
if (nColors == 0)
|
||
{
|
||
TRACE_MSG(("CreateSystemPalette: device has no palette"));
|
||
return(NULL);
|
||
}
|
||
|
||
// Allocate room for the palette and lock it.
|
||
lpLogPal = (LPLOGPALETTE)::GlobalAlloc(GPTR, sizeof(LOGPALETTE) +
|
||
nColors * sizeof(PALETTEENTRY));
|
||
|
||
if (lpLogPal != NULL)
|
||
{
|
||
lpLogPal->palVersion = PALVERSION;
|
||
lpLogPal->palNumEntries = (WORD) nColors;
|
||
|
||
for (int iIndex = 0; iIndex < nColors; iIndex++)
|
||
{
|
||
lpLogPal->palPalEntry[iIndex].peBlue = 0;
|
||
*((LPWORD) (&lpLogPal->palPalEntry[iIndex].peRed)) = (WORD) iIndex;
|
||
lpLogPal->palPalEntry[iIndex].peFlags = PC_EXPLICIT;
|
||
}
|
||
|
||
hPal = ::CreatePalette(lpLogPal);
|
||
|
||
// Free the logical palette structure
|
||
::GlobalFree((HGLOBAL)lpLogPal);
|
||
}
|
||
|
||
return(hPal);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: CreateColorPalette
|
||
//
|
||
// Purpose: Get a 256-color palette
|
||
//
|
||
//
|
||
HPALETTE CreateColorPalette(void)
|
||
{
|
||
HDC hdc;
|
||
HPALETTE hPal = NULL;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "CreateColorPalette");
|
||
|
||
// Find out how many colors are reserved
|
||
hdc = ::CreateIC("DISPLAY", NULL, NULL, NULL);
|
||
if (!hdc)
|
||
{
|
||
ERROR_OUT(("Couldn't create DISPLAY IC"));
|
||
return(NULL);
|
||
}
|
||
|
||
UINT uiSystemUse = ::GetSystemPaletteUse(hdc);
|
||
|
||
// Get the number of static colors
|
||
int iCountStatic = 20;
|
||
int iHalfCountStatic = 10;
|
||
if (uiSystemUse == SYSPAL_NOSTATIC)
|
||
{
|
||
iCountStatic = 2;
|
||
iHalfCountStatic = 1;
|
||
}
|
||
|
||
LOGPALETTE_NM gIndeoPalette = gcLogPaletteIndeo;
|
||
|
||
// put system colors in correct lower and upper pal entries (bug NM4db:817)
|
||
::GetSystemPaletteEntries(hdc,
|
||
0,
|
||
iHalfCountStatic,
|
||
&(gIndeoPalette.aEntries[0]) );
|
||
|
||
::GetSystemPaletteEntries(hdc,
|
||
MAXPALETTE - iHalfCountStatic,
|
||
iHalfCountStatic,
|
||
&(gIndeoPalette.aEntries[MAXPALETTE - iHalfCountStatic]) );
|
||
|
||
// Create the windows object for this palette
|
||
// from the logical palette
|
||
hPal = CreatePalette( (LOGPALETTE *)&gIndeoPalette );
|
||
|
||
// Delete the display DC
|
||
::DeleteDC(hdc);
|
||
|
||
return(hPal);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: FromScreenAreaBmp
|
||
//
|
||
// Purpose: Create a bitmap from an area of the screen
|
||
//
|
||
//
|
||
HBITMAP FromScreenAreaBmp(LPCRECT lprect)
|
||
{
|
||
RECT rcScreen;
|
||
HBITMAP hBitMap = NULL;
|
||
|
||
//
|
||
// Get screen boundaries, in a way that works for single and multiple
|
||
// monitor scenarios.
|
||
//
|
||
if (rcScreen.right = ::GetSystemMetrics(SM_CXVIRTUALSCREEN))
|
||
{
|
||
//
|
||
// This is Win98, NT 4.0 SP-3, or NT5
|
||
//
|
||
rcScreen.bottom = ::GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
||
rcScreen.left = ::GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||
rcScreen.top = ::GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// The VIRTUALSCREEN size metrics are zero on older platforms
|
||
// which don't support them.
|
||
//
|
||
rcScreen.right = ::GetSystemMetrics(SM_CXSCREEN);
|
||
rcScreen.bottom = ::GetSystemMetrics(SM_CYSCREEN);
|
||
rcScreen.left = 0;
|
||
rcScreen.top = 0;
|
||
}
|
||
|
||
rcScreen.right += rcScreen.left;
|
||
rcScreen.bottom += rcScreen.top;
|
||
|
||
//
|
||
// Clip bitmap rectangle to the screen.
|
||
//
|
||
if (IntersectRect(&rcScreen, &rcScreen, lprect))
|
||
{
|
||
// Create a DC for the screen and create
|
||
// a memory DC compatible to screen DC
|
||
HDC hdisplayDC;
|
||
hdisplayDC = ::CreateDC("DISPLAY", NULL, NULL, NULL);
|
||
|
||
HDC hmemDC;
|
||
hmemDC = ::CreateCompatibleDC(hdisplayDC);
|
||
|
||
// Create a bitmap compatible with the screen DC
|
||
hBitMap = ::CreateCompatibleBitmap(hdisplayDC,
|
||
rcScreen.right - rcScreen.left,
|
||
rcScreen.bottom - rcScreen.top);
|
||
if (hBitMap != NULL)
|
||
{
|
||
// Select new bitmap into memory DC
|
||
HBITMAP hOldBitmap = SelectBitmap(hmemDC, hBitMap);
|
||
|
||
// BitBlt screen DC to memory DC
|
||
::BitBlt(hmemDC, 0, 0, rcScreen.right - rcScreen.left,
|
||
rcScreen.bottom - rcScreen.top, hdisplayDC,
|
||
rcScreen.left, rcScreen.top, SRCCOPY);
|
||
|
||
// Select old bitmap back into memory DC and get handle to
|
||
// bitmap of the screen
|
||
SelectBitmap(hmemDC, hOldBitmap);
|
||
}
|
||
|
||
::DeleteDC(hmemDC);
|
||
|
||
::DeleteDC(hdisplayDC);
|
||
}
|
||
|
||
// return handle to the bitmap
|
||
return hBitMap;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// Macro to round off the given value to the closest byte
|
||
#define WIDTHBYTES(i) (((i+31)/32)*4)
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_NumberOfColors
|
||
//
|
||
// Purpose: Calculates the number of colours in the DIB
|
||
//
|
||
//
|
||
UINT DIB_NumberOfColors(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
UINT numColors;
|
||
int bits;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_NumberOfColors");
|
||
|
||
ASSERT(lpbi != NULL);
|
||
|
||
// With the BITMAPINFO format headers, the size of the palette
|
||
// is in biClrUsed, whereas in the BITMAPCORE - style headers, it
|
||
// is dependent on the bits per pixel ( = 2 raised to the power of
|
||
// bits/pixel).
|
||
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
|
||
{
|
||
// Old DIB format, some apps still put this on the clipboard
|
||
numColors = 0;
|
||
bits = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
|
||
}
|
||
else
|
||
{
|
||
numColors = lpbi->biClrUsed;
|
||
bits = lpbi->biBitCount;
|
||
}
|
||
|
||
if ((numColors == 0) && (bits <= 8))
|
||
{
|
||
numColors = (1 << bits);
|
||
}
|
||
|
||
return numColors;
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_PaletteLength
|
||
//
|
||
// Purpose: Calculates the palette size in bytes
|
||
//
|
||
//
|
||
UINT DIB_PaletteLength(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
UINT size;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_PaletteLength");
|
||
|
||
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
|
||
{
|
||
size = DIB_NumberOfColors(lpbi) * sizeof(RGBTRIPLE);
|
||
}
|
||
else
|
||
{
|
||
size = DIB_NumberOfColors(lpbi) * sizeof(RGBQUAD);
|
||
}
|
||
|
||
TRACE_MSG(("Palette length %d", size));
|
||
return(size);
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: DIB_DataLength
|
||
//
|
||
// Purpose: Return the length of the DIB data (after the header and the
|
||
// color table.
|
||
//
|
||
//
|
||
UINT DIB_DataLength(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_DataLength");
|
||
|
||
ASSERT(lpbi);
|
||
|
||
UINT dwLength = 0;
|
||
|
||
// If the image is not compressed, calculate the length of the data
|
||
if (lpbi->biCompression == BI_RGB)
|
||
{
|
||
// Image is not compressed, the size can be given as zero in the header
|
||
|
||
// Calculate the width in bytes of the image
|
||
DWORD dwByteWidth = ( ((DWORD) lpbi->biWidth) * (DWORD) lpbi->biBitCount);
|
||
TRACE_MSG(("Data byte width is %ld",dwByteWidth));
|
||
|
||
// Round the width to a multiple of 4 bytes
|
||
dwByteWidth = WIDTHBYTES(dwByteWidth);
|
||
TRACE_MSG(("Rounded up to %ld",dwByteWidth));
|
||
|
||
dwLength = (dwByteWidth * ((DWORD) lpbi->biHeight));
|
||
}
|
||
else
|
||
{
|
||
// Image is compressed, the length should be correct in the header
|
||
dwLength = lpbi->biSizeImage;
|
||
}
|
||
|
||
TRACE_MSG(("Total data length is %d",dwLength));
|
||
|
||
return(dwLength);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_TotalLength
|
||
//
|
||
// Purpose: Return the total length of the DIB (header + colors + data).
|
||
//
|
||
//
|
||
UINT DIB_TotalLength(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_TotalLength");
|
||
|
||
ASSERT(lpbi);
|
||
|
||
// Header + Palette + Bits
|
||
return(lpbi->biSize + DIB_PaletteLength(lpbi) + DIB_DataLength(lpbi));
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_CreatePalette
|
||
//
|
||
// Purpose: Create a palette object from the bitmap info color table
|
||
//
|
||
//
|
||
HPALETTE DIB_CreatePalette(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
LOGPALETTE *pPal;
|
||
HPALETTE hpal = NULL;
|
||
WORD nNumColors;
|
||
BYTE red;
|
||
BYTE green;
|
||
BYTE blue;
|
||
WORD i;
|
||
RGBQUAD FAR * pRgb;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_CreatePalette");
|
||
|
||
if (!lpbi)
|
||
return NULL;
|
||
|
||
if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
|
||
return NULL;
|
||
|
||
// Get a pointer to the color table and the number of colors in it
|
||
pRgb = (RGBQUAD FAR *)((LPSTR)lpbi + (WORD)lpbi->biSize);
|
||
nNumColors = (WORD)DIB_NumberOfColors(lpbi);
|
||
|
||
if (nNumColors)
|
||
{
|
||
TRACE_MSG(("There are %d colors in the palette",nNumColors));
|
||
|
||
// Allocate for the logical palette structure
|
||
pPal = (LOGPALETTE*) ::GlobalAlloc(GPTR, sizeof(LOGPALETTE)
|
||
+ (nNumColors * sizeof(PALETTEENTRY)));
|
||
if (!pPal)
|
||
{
|
||
ERROR_OUT(("Couldn't allocate palette memory"));
|
||
return(NULL);
|
||
}
|
||
|
||
pPal->palNumEntries = nNumColors;
|
||
pPal->palVersion = PALVERSION;
|
||
|
||
// Fill in the palette entries from the DIB color table and
|
||
// create a logical color palette.
|
||
for (i = 0; i < nNumColors; i++)
|
||
{
|
||
pPal->palPalEntry[i].peRed = pRgb[i].rgbRed;
|
||
pPal->palPalEntry[i].peGreen = pRgb[i].rgbGreen;
|
||
pPal->palPalEntry[i].peBlue = pRgb[i].rgbBlue;
|
||
pPal->palPalEntry[i].peFlags = (BYTE)0;
|
||
}
|
||
|
||
hpal = ::CreatePalette(pPal);
|
||
|
||
::GlobalFree((HGLOBAL)pPal);
|
||
}
|
||
else
|
||
{
|
||
if (lpbi->biBitCount == 24)
|
||
{
|
||
// A 24 bitcount DIB has no color table entries so, set the number
|
||
// of to the maximum value (256).
|
||
nNumColors = MAXPALETTE;
|
||
|
||
pPal = (LOGPALETTE*) ::GlobalAlloc(GPTR, sizeof(LOGPALETTE)
|
||
+ (nNumColors * sizeof(PALETTEENTRY)));
|
||
if (!pPal)
|
||
{
|
||
ERROR_OUT(("Couldn't allocate palette memory"));
|
||
return NULL;
|
||
}
|
||
|
||
pPal->palNumEntries = nNumColors;
|
||
pPal->palVersion = PALVERSION;
|
||
|
||
red = green = blue = 0;
|
||
|
||
// Generate 256 (= 8*8*4) RGB combinations to fill the palette
|
||
// entries.
|
||
|
||
for (i = 0; i < pPal->palNumEntries; i++)
|
||
{
|
||
pPal->palPalEntry[i].peRed = red;
|
||
pPal->palPalEntry[i].peGreen = green;
|
||
pPal->palPalEntry[i].peBlue = blue;
|
||
pPal->palPalEntry[i].peFlags = (BYTE) 0;
|
||
|
||
if (!(red += 32))
|
||
if (!(green += 32))
|
||
blue += 64;
|
||
}
|
||
|
||
hpal = ::CreatePalette(pPal);
|
||
::GlobalFree((HGLOBAL)pPal);
|
||
}
|
||
}
|
||
|
||
return hpal;
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_Bits
|
||
//
|
||
// Purpose: Return a pointer to the bitmap bits data (from a pointer
|
||
// to the bitmap info header).
|
||
//
|
||
//
|
||
LPSTR DIB_Bits(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_Bits");
|
||
ASSERT(lpbi);
|
||
|
||
return ((LPSTR) (((char *) lpbi)
|
||
+ lpbi->biSize
|
||
+ DIB_PaletteLength(lpbi)));
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_FromScreenArea
|
||
//
|
||
// Purpose: Create a DIB from an area of the screen
|
||
//
|
||
//
|
||
LPBITMAPINFOHEADER DIB_FromScreenArea(LPCRECT lprect)
|
||
{
|
||
HBITMAP hBitmap = NULL;
|
||
HPALETTE hPalette = NULL;
|
||
LPBITMAPINFOHEADER lpbi = NULL;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_FromScreenArea");
|
||
|
||
// Get the device-dependent bitmap from the screen area
|
||
hBitmap = FromScreenAreaBmp(lprect);
|
||
if (hBitmap != NULL)
|
||
{
|
||
// Get the current system palette
|
||
hPalette = CreateSystemPalette();
|
||
lpbi = DIB_FromBitmap(hBitmap, hPalette, FALSE);
|
||
}
|
||
|
||
if (hPalette != NULL)
|
||
::DeletePalette(hPalette);
|
||
|
||
if (hBitmap != NULL)
|
||
::DeleteBitmap(hBitmap);
|
||
|
||
return(lpbi);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: DIB_Copy
|
||
//
|
||
// Purpose: Make a copy of the DIB memory
|
||
//
|
||
//
|
||
LPBITMAPINFOHEADER DIB_Copy(LPBITMAPINFOHEADER lpbi)
|
||
{
|
||
LPBITMAPINFOHEADER lpbiNew = NULL;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_Copy");
|
||
|
||
ASSERT(lpbi);
|
||
|
||
// Get the length of memory
|
||
DWORD dwLen = DIB_TotalLength(lpbi);
|
||
|
||
lpbiNew = (LPBITMAPINFOHEADER)::GlobalAlloc(GPTR, dwLen);
|
||
if (lpbiNew != NULL)
|
||
{
|
||
// Copy the data
|
||
memcpy(lpbiNew, lpbi, dwLen);
|
||
}
|
||
|
||
return(lpbiNew);
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: DIB_FromBitmap
|
||
//
|
||
// Purpose: Creates a DIB from a bitmap and palette
|
||
//
|
||
//
|
||
LPBITMAPINFOHEADER DIB_FromBitmap
|
||
(
|
||
HBITMAP hBitmap,
|
||
HPALETTE hPalette,
|
||
BOOL fGHandle
|
||
)
|
||
{
|
||
LPBITMAPINFOHEADER lpbi = NULL;
|
||
HGLOBAL hmem = NULL;
|
||
BITMAP bm;
|
||
BITMAPINFOHEADER bi;
|
||
DWORD dwLen;
|
||
WORD biBits;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DIB_FromBitmap");
|
||
|
||
// If the bitmap handle given is null, do nothing
|
||
if (hBitmap != NULL)
|
||
{
|
||
if (hPalette == NULL)
|
||
hPalette = (HPALETTE)::GetStockObject(DEFAULT_PALETTE);
|
||
|
||
// Get the bitmap information
|
||
::GetObject(hBitmap, sizeof(bm), (LPSTR) &bm);
|
||
|
||
biBits = (WORD) (bm.bmPlanes * bm.bmBitsPixel);
|
||
|
||
if (biBits > 8)
|
||
{
|
||
// If > 8, make life easy and use plain R-G-B 24-bits
|
||
biBits = 24;
|
||
}
|
||
|
||
bi.biSize = sizeof(BITMAPINFOHEADER);
|
||
bi.biWidth = bm.bmWidth;
|
||
bi.biHeight = bm.bmHeight;
|
||
bi.biPlanes = 1;
|
||
bi.biBitCount = biBits;
|
||
bi.biCompression = 0;
|
||
bi.biSizeImage = 0;
|
||
bi.biXPelsPerMeter = 0;
|
||
bi.biYPelsPerMeter = 0;
|
||
bi.biClrUsed = 0;
|
||
bi.biClrImportant = 0;
|
||
|
||
dwLen = bi.biSize + DIB_PaletteLength(&bi);
|
||
|
||
HDC hdc;
|
||
HPALETTE hPalOld;
|
||
|
||
hdc = ::CreateDC("DISPLAY", NULL, NULL, NULL);
|
||
hPalOld = ::SelectPalette(hdc, hPalette, FALSE);
|
||
::RealizePalette(hdc);
|
||
|
||
// Allocate memory for the DIB
|
||
if (fGHandle)
|
||
{
|
||
// For the clipboard, we MUST use GHND
|
||
hmem = ::GlobalAlloc(GHND, dwLen);
|
||
lpbi = (LPBITMAPINFOHEADER)::GlobalLock(hmem);
|
||
}
|
||
else
|
||
{
|
||
lpbi = (LPBITMAPINFOHEADER)::GlobalAlloc(GPTR, dwLen);
|
||
}
|
||
|
||
if (lpbi != NULL)
|
||
{
|
||
*lpbi = bi;
|
||
|
||
// Call GetDIBits with a NULL lpBits param, so it will calculate the
|
||
// biSizeImage field for us
|
||
::GetDIBits(hdc, hBitmap, 0, (WORD) bi.biHeight, NULL,
|
||
(LPBITMAPINFO)lpbi, DIB_RGB_COLORS);
|
||
|
||
bi = *lpbi;
|
||
|
||
// If the driver did not fill in the biSizeImage field, make one up
|
||
if (bi.biSizeImage == 0)
|
||
{
|
||
bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
|
||
}
|
||
|
||
// Realloc the buffer big enough to hold all the bits
|
||
dwLen = bi.biSize + DIB_PaletteLength(&bi) + bi.biSizeImage;
|
||
|
||
if (fGHandle)
|
||
{
|
||
HGLOBAL hT;
|
||
|
||
::GlobalUnlock(hmem);
|
||
hT = ::GlobalReAlloc(hmem, dwLen, GHND);
|
||
if (!hT)
|
||
{
|
||
ERROR_OUT(("Can't reallocate DIB handle"));
|
||
::GlobalFree(hmem);
|
||
hmem = NULL;
|
||
lpbi = NULL;
|
||
}
|
||
else
|
||
{
|
||
hmem = hT;
|
||
lpbi = (LPBITMAPINFOHEADER)::GlobalLock(hmem);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LPBITMAPINFOHEADER lpbiT;
|
||
|
||
lpbiT = (LPBITMAPINFOHEADER)::GlobalReAlloc((HGLOBAL)lpbi, dwLen, GMEM_MOVEABLE);
|
||
if (!lpbiT)
|
||
{
|
||
ERROR_OUT(("Can't reallocate DIB ptr"));
|
||
|
||
::GlobalFree((HGLOBAL)lpbi);
|
||
lpbi = NULL;
|
||
}
|
||
else
|
||
{
|
||
lpbi = lpbiT;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (lpbi != NULL)
|
||
{
|
||
::GetDIBits(hdc, hBitmap, 0,
|
||
(WORD)bi.biHeight,
|
||
DIB_Bits(lpbi),
|
||
(LPBITMAPINFO)lpbi,
|
||
DIB_RGB_COLORS);
|
||
|
||
if (fGHandle)
|
||
{
|
||
// We want to return the HANDLE, not the POINTER
|
||
::GlobalUnlock(hmem);
|
||
lpbi = (LPBITMAPINFOHEADER)hmem;
|
||
}
|
||
}
|
||
|
||
// Restore the old palette and give back the device context
|
||
::SelectPalette(hdc, hPalOld, FALSE);
|
||
::DeleteDC(hdc);
|
||
}
|
||
|
||
return(lpbi);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//
|
||
// AbortProc()
|
||
// Process messages during printing
|
||
//
|
||
//
|
||
BOOL CALLBACK AbortProc(HDC, int)
|
||
{
|
||
MSG msg;
|
||
|
||
ASSERT(g_pPrinter);
|
||
|
||
// Message pump in case user wants to cancel printing
|
||
while (!g_pPrinter->Aborted()
|
||
&& PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
|
||
{
|
||
if ( (g_pPrinter->m_hwndDialog == NULL) ||
|
||
!::IsDialogMessage(g_pPrinter->m_hwndDialog, &msg))
|
||
{
|
||
TranslateMessage(&msg);
|
||
DispatchMessage(&msg);
|
||
}
|
||
}
|
||
|
||
return !g_pPrinter->Aborted();
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: WbPrinter
|
||
//
|
||
// Purpose: Constructor for a printer object
|
||
//
|
||
//
|
||
WbPrinter::WbPrinter(LPCTSTR szDeviceName)
|
||
{
|
||
m_szDeviceName = szDeviceName;
|
||
m_szPrintPageText[0] = 0;
|
||
|
||
// Set up the global pointer for the abort procedure
|
||
g_pPrinter = this;
|
||
|
||
// Create the dialog window
|
||
m_hwndDialog = ::CreateDialogParam(g_hInstance, MAKEINTRESOURCE(PRINTCANCEL),
|
||
g_pMain->m_hwnd, CancelPrintDlgProc, 0);
|
||
|
||
// Save the original text for the page number area
|
||
::GetDlgItemText(m_hwndDialog, IDD_PRINT_PAGE, m_szPrintPageText, _MAX_PATH);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: ~WbPrinter
|
||
//
|
||
// Purpose: Destructor for a printer object
|
||
//
|
||
//
|
||
WbPrinter::~WbPrinter(void)
|
||
{
|
||
// Kill off the dialog etc. if still around
|
||
StopDialog();
|
||
|
||
ASSERT(m_hwndDialog == NULL);
|
||
|
||
g_pPrinter = NULL;
|
||
}
|
||
|
||
|
||
//
|
||
// StopDialog()
|
||
// If the dialog is up, ends it.
|
||
//
|
||
void WbPrinter::StopDialog(void)
|
||
{
|
||
::EnableWindow(g_pMain->m_hwnd, TRUE);
|
||
|
||
// Close and destroy the dialog
|
||
if (m_hwndDialog != NULL)
|
||
{
|
||
::DestroyWindow(m_hwndDialog);
|
||
m_hwndDialog = NULL;
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: StartDoc
|
||
//
|
||
// Purpose: Tell the printer we are starting a new document
|
||
//
|
||
//
|
||
int WbPrinter::StartDoc
|
||
(
|
||
HDC hdc,
|
||
LPCTSTR szJobName,
|
||
int nStartPage
|
||
)
|
||
{
|
||
// Initialize the result codes and page number
|
||
m_bAborted = FALSE; // Not aborted
|
||
m_nPrintResult = 1; // Greater than 0 implies all is well
|
||
|
||
// Disable the main window
|
||
::EnableWindow(g_pMain->m_hwnd, FALSE);
|
||
|
||
// Attach the printer DC
|
||
SetPrintPageNumber(nStartPage);
|
||
|
||
// Set up the abort routine for the print
|
||
if (SetAbortProc(hdc, AbortProc) >= 0)
|
||
{
|
||
// Abort routine successfully set
|
||
::ShowWindow(m_hwndDialog, SW_SHOW);
|
||
::UpdateWindow(m_hwndDialog);
|
||
|
||
DOCINFO docinfo;
|
||
|
||
docinfo.cbSize = sizeof(DOCINFO);
|
||
docinfo.lpszDocName = szJobName;
|
||
docinfo.lpszOutput = NULL;
|
||
docinfo.lpszDatatype = NULL; // Windows 95 only; ignored on Windows NT
|
||
docinfo.fwType = 0; // Windows 95 only; ignored on Windows NT
|
||
|
||
// Initialize the document.
|
||
m_nPrintResult = ::StartDoc(hdc, &docinfo);
|
||
}
|
||
|
||
return m_nPrintResult;
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: StartPage
|
||
//
|
||
// Purpose: Tell the printer we are starting a new page
|
||
//
|
||
//
|
||
int WbPrinter::StartPage(HDC hdc, int nPageNumber)
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "WbPrinter::StartPage");
|
||
|
||
m_nPrintResult = -1; // Initialise to error
|
||
|
||
// If the print has been aborted, return an error.
|
||
if (m_bAborted)
|
||
{
|
||
TRACE_DEBUG(("Print has been aborted"));
|
||
}
|
||
else
|
||
{
|
||
SetPrintPageNumber(nPageNumber);
|
||
|
||
// Tell the printer of the new page number
|
||
m_nPrintResult = ::StartPage(hdc);
|
||
}
|
||
|
||
return(m_nPrintResult);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: EndPage
|
||
//
|
||
// Purpose: Tell the printer we are finishing a page
|
||
//
|
||
//
|
||
int WbPrinter::EndPage(HDC hdc)
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "WbPrinter::EndPage");
|
||
|
||
m_nPrintResult = -1; // Initialise to error
|
||
|
||
// If the print has been aborted, return an error.
|
||
if (m_bAborted)
|
||
{
|
||
TRACE_DEBUG(("Print has been aborted"));
|
||
}
|
||
else
|
||
{
|
||
// Tell the printer of the new page number
|
||
m_nPrintResult = ::EndPage(hdc);
|
||
}
|
||
|
||
return(m_nPrintResult);
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: EndDoc
|
||
//
|
||
// Purpose: Tell the printer we have completed a document
|
||
//
|
||
//
|
||
int WbPrinter::EndDoc(HDC hdc)
|
||
{
|
||
// If an error has occurred the driver will already have aborted the print
|
||
if (m_nPrintResult > 0)
|
||
{
|
||
if (!m_bAborted)
|
||
{
|
||
// If we have not been aborted, and no error has occurred
|
||
// end the document
|
||
m_nPrintResult = ::EndDoc(hdc);
|
||
}
|
||
else
|
||
{
|
||
m_nPrintResult = ::AbortDoc(hdc);
|
||
}
|
||
}
|
||
|
||
StopDialog();
|
||
|
||
// Return an the error indicator
|
||
return m_nPrintResult;
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: AbortDoc
|
||
//
|
||
// Purpose: Abort the document currently in progress
|
||
//
|
||
//
|
||
int WbPrinter::AbortDoc()
|
||
{
|
||
// Show that we have been aborted, the actual abort is
|
||
// done by the EndDoc call.
|
||
m_bAborted = TRUE;
|
||
|
||
//
|
||
// Renable the application window.
|
||
//
|
||
StopDialog();
|
||
|
||
// Return a positive value indicating "aborted OK"
|
||
return 1;
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: SetPrintPageNumber
|
||
//
|
||
// Purpose: Set the number of the page currently being printed
|
||
//
|
||
//
|
||
void WbPrinter::SetPrintPageNumber(int nPageNumber)
|
||
{
|
||
// Display the number of the page currently being printed
|
||
TCHAR szPageNumber [10 + _MAX_PATH];
|
||
|
||
wsprintf(szPageNumber, m_szPrintPageText, nPageNumber);
|
||
::SetDlgItemText(m_hwndDialog, IDD_PRINT_PAGE, szPageNumber);
|
||
}
|
||
|
||
|
||
//
|
||
// CancelPrintDlgProc()
|
||
// Dialog message handler for the cancel printing dialog
|
||
//
|
||
INT_PTR CALLBACK CancelPrintDlgProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
BOOL fHandled = FALSE;
|
||
|
||
switch (uMessage)
|
||
{
|
||
case WM_INITDIALOG:
|
||
ASSERT(g_pPrinter != NULL);
|
||
::SetDlgItemText(hwnd, IDD_DEVICE_NAME, g_pPrinter->m_szDeviceName);
|
||
fHandled = TRUE;
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
||
{
|
||
case IDOK:
|
||
case IDCANCEL:
|
||
switch (GET_WM_COMMAND_CMD(wParam, lParam))
|
||
{
|
||
case BN_CLICKED:
|
||
ASSERT(g_pPrinter != NULL);
|
||
g_pPrinter->AbortDoc();
|
||
break;
|
||
}
|
||
}
|
||
|
||
fHandled = TRUE;
|
||
break;
|
||
}
|
||
|
||
return(fHandled);
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Bogus Bogus LAURABU
|
||
// STRING ARRAY (TEMP!)
|
||
//
|
||
|
||
StrArray::StrArray()
|
||
{
|
||
m_pData = NULL;
|
||
m_nSize = m_nMaxSize = 0;
|
||
}
|
||
|
||
StrArray::~StrArray()
|
||
{
|
||
ClearOut();
|
||
}
|
||
|
||
|
||
void StrArray::ClearOut(void)
|
||
{
|
||
int iItem;
|
||
|
||
for (iItem = 0; iItem < m_nSize; iItem++)
|
||
{
|
||
if (m_pData[iItem] != NULL)
|
||
{
|
||
delete (LPTSTR)m_pData[iItem];
|
||
m_pData[iItem] = NULL;
|
||
}
|
||
}
|
||
|
||
m_nSize = 0;
|
||
m_nMaxSize = 0;
|
||
|
||
if (m_pData != NULL)
|
||
{
|
||
delete[] m_pData;
|
||
m_pData = NULL;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void StrArray::SetSize(int nNewSize)
|
||
{
|
||
if (nNewSize == 0)
|
||
{
|
||
// shrink to nothing
|
||
ClearOut();
|
||
}
|
||
else if (nNewSize <= m_nMaxSize)
|
||
{
|
||
// No shrinking allowed.
|
||
ASSERT(nNewSize >= m_nSize);
|
||
|
||
// We're still within the alloced block range
|
||
m_nSize = nNewSize;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Make a larger array (isn't this lovely if you already have an
|
||
// array, we alloc a new one and free the old one)
|
||
//
|
||
int nNewMax;
|
||
|
||
nNewMax = (nNewSize + (ALLOC_CHUNK -1)) & ~(ALLOC_CHUNK-1);
|
||
ASSERT(nNewMax >= m_nMaxSize); // no wrap around
|
||
|
||
LPCTSTR* pNewData = new LPCTSTR[nNewMax];
|
||
if (!pNewData)
|
||
{
|
||
ERROR_OUT(("StrArray::SetSize failed, couldn't allocate larger array"));
|
||
}
|
||
else
|
||
{
|
||
// Zero out the memory
|
||
ZeroMemory(pNewData, nNewMax * sizeof(LPCTSTR));
|
||
|
||
// If an old array exists, copy the existing string ptrs.
|
||
if (m_pData != NULL)
|
||
{
|
||
CopyMemory(pNewData, m_pData, m_nSize * sizeof(LPCTSTR));
|
||
|
||
//
|
||
// Delete the old array, but not the strings inside, we're
|
||
// keeping them around in the new array
|
||
//
|
||
delete[] m_pData;
|
||
}
|
||
|
||
m_pData = pNewData;
|
||
m_nSize = nNewSize;
|
||
m_nMaxSize = nNewMax;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void StrArray::SetAtGrow(int nIndex, LPCTSTR newElement)
|
||
{
|
||
ASSERT(nIndex >= 0);
|
||
|
||
if (nIndex >= m_nSize)
|
||
SetSize(nIndex+1);
|
||
|
||
SetAt(nIndex, newElement);
|
||
}
|
||
|
||
|
||
LPCTSTR StrArray::operator[](int nIndex) const
|
||
{
|
||
ASSERT(nIndex >= 0);
|
||
|
||
if (nIndex < m_nSize)
|
||
{
|
||
ASSERT(m_pData != NULL);
|
||
return(m_pData[nIndex]);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("StrArray[] got index outside of bounds"));
|
||
return(NULL);
|
||
}
|
||
}
|
||
|
||
|
||
void StrArray::SetAt(int nIndex, LPCTSTR newElement)
|
||
{
|
||
ASSERT(nIndex >= 0);
|
||
|
||
if (nIndex >= m_nSize)
|
||
{
|
||
WARNING_OUT(("StrArray::SetAt got index outside of bounds"));
|
||
return;
|
||
}
|
||
|
||
ASSERT(m_pData != NULL);
|
||
|
||
m_pData[nIndex] = new TCHAR[lstrlen(newElement) + 1];
|
||
if (!m_pData[nIndex])
|
||
{
|
||
ERROR_OUT(("StrArray::SetAt failed to allocate string %s at pos %d",
|
||
newElement, nIndex));
|
||
}
|
||
else
|
||
{
|
||
lstrcpy((LPTSTR)m_pData[nIndex], newElement);
|
||
}
|
||
}
|
||
|
||
|
||
void StrArray::Add(LPCTSTR newElement)
|
||
{
|
||
SetAtGrow(m_nSize, newElement);
|
||
}
|
||
|
||
|
||
//
|
||
//char *StrTok(string, control) - tokenize string with delimiter in control
|
||
//
|
||
char * StrTok (char * string, char * control)
|
||
{
|
||
char *str;
|
||
char *ctrl = control;
|
||
|
||
unsigned char map[32];
|
||
int count;
|
||
|
||
static char *nextoken;
|
||
|
||
/* Clear control map */
|
||
for (count = 0; count < 32; count++)
|
||
map[count] = 0;
|
||
|
||
/* Set bits in delimiter table */
|
||
do {
|
||
map[*ctrl >> 3] |= (1 << (*ctrl & 7));
|
||
} while (*ctrl++);
|
||
|
||
/* Initialize str. If string is NULL, set str to the saved
|
||
* pointer (i.e., continue breaking tokens out of the string
|
||
* from the last StrTok call) */
|
||
if (string)
|
||
str = string;
|
||
else
|
||
str = nextoken;
|
||
|
||
/* Find beginning of token (skip over leading delimiters). Note that
|
||
* there is no token iff this loop sets str to point to the terminal
|
||
* null (*str == '\0') */
|
||
while ( (map[*str >> 3] & (1 << (*str & 7))) && *str )
|
||
str++;
|
||
|
||
string = str;
|
||
|
||
/* Find the end of the token. If it is not the end of the string,
|
||
* put a null there. */
|
||
for ( ; *str ; str++ )
|
||
if ( map[*str >> 3] & (1 << (*str & 7)) ) {
|
||
*str++ = '\0';
|
||
break;
|
||
}
|
||
|
||
/* Update nextoken (or the corresponding field in the per-thread data
|
||
* structure */
|
||
nextoken = str;
|
||
|
||
/* Determine if a token has been found. */
|
||
if ( string == str )
|
||
return NULL;
|
||
else
|
||
return string;
|
||
}
|
||
|