You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1600 lines
62 KiB
1600 lines
62 KiB
//****************************************************************************
|
|
// WOW32 fax support.
|
|
//
|
|
// History:
|
|
// 02-jan-95 nandurir created.
|
|
// 01-feb-95 reedb Clean-up, support printer install and bug fixes.
|
|
//
|
|
//****************************************************************************
|
|
|
|
|
|
//****************************************************************************
|
|
// This expalins how all this works (sort of) using WinFax as example.
|
|
// Install:
|
|
// 1. Setup app calls WriteProfileString("devices","WINFAX","WINFAX,Com1:")
|
|
// to register a "printer" in Win.ini a-la Win3.1
|
|
// 2. Our thunks of WritexxxProfileString() look for the "devices" string
|
|
// and pass the call to IsFaxPrinterWriteProfileString(lpszSection,lpszKey,
|
|
// lpszString).
|
|
// 3. If lpszKey ("WINFAX" in this case) is in our supported fax drivers list
|
|
// (See Reg\SW\MS\WinNT\CurrentVersion\WOW\WOWFax\SupportedFaxDrivers)
|
|
// (by call to IsFaxPrinterSupportedDevice()), we call InstallWowFaxPrinter
|
|
// to add the printer the NT way -- via AddPrinter().
|
|
// 4. To set up the call to AddPrinter, we copy WOWFAX.DLL and WOWFAXUI.DLL to
|
|
// the print spooler driver directory (\NT\system32\spool\drivers\w32x86\2)
|
|
// 5. We next call AddPrinterDriver to register the wowfax driver.
|
|
// 6. We then call wow32!DoAddPrinterStuff which launches a new thread,
|
|
// wow32!AddPrinterThread, which calls winspool.drv!AddPrinter() for us. The
|
|
// PrinterInfo.pPrinterName = the 16-bit fax driver name,"WINFAX" in this
|
|
// case. WinSpool.drv then does a RPC call into the spooler.
|
|
// 7. During the AddPrinter() call, the spooler calls back into the driver to
|
|
// get driver specific info. These callbacks are handled by our WOWFAX
|
|
// driver in the spooler's process. They essentially callback into WOW
|
|
// via wow32!WOWFaxWndProc().
|
|
// 8. WOWFaxWndProc() passes the callback onto WOW32FaxHandler, which calls
|
|
// back to wowexec!FaxWndProc().
|
|
// 9. FaxWndProc then calls the 16-bit LoadLibrary() to open the 16-bit fax
|
|
// driver (WinFax.drv in this case).
|
|
// 10. The messages sent to FaxWndProc tell it which exported function it needs
|
|
// call in the 16-bit driver on behalf of the spooler.
|
|
// 11. Any info the spooler wants to pass to the 16-bit driver or get from it
|
|
// essentially goes through the mechanism in steps 7 - 10.
|
|
// Now you know (sort of).
|
|
//****************************************************************************
|
|
//
|
|
// Notes on what allows us to support a 16-bit fax driver:
|
|
// Essentially we have to know in advance which API's an app will call in the
|
|
// driver so we can handle the thunks. It turns out that fax drivers only
|
|
// need to export a small essential list of API's:
|
|
// Control, Disable, Enable, BitBlt, ExtDeviceMode, DeviceCapabilities
|
|
// (see mvdm\inc\wowfax.h\_WOWFAXINFO16 struct (all the PASCAL declarations)
|
|
// and mvdm\wow16\test\shell\wowexfax.c\FaxWndProc() )
|
|
// The list is way too big to support 16-bit printer & display drivers.
|
|
// If a 16-bit fax driver exports these API's there's a pretty good chance
|
|
// we can support it in WOW. Other issues to look into: the dlgproc's the
|
|
// driver export's, any obsolete Win 3.0 API's that the NT spooler won't know
|
|
// how to call.
|
|
//
|
|
//****************************************************************************
|
|
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#define WOWFAX_INC_COMMON_CODE
|
|
#include "wowgdip.h"
|
|
#define DEFINE_DDRV_DEBUG_STRINGS
|
|
#include "wowfax.h"
|
|
#include "winddi.h"
|
|
#include "winspool.h"
|
|
|
|
MODNAME(wowfax.c);
|
|
|
|
typedef struct _WOWADDPRINTER {
|
|
LPVOID pPrinterStuff;
|
|
INT iCode;
|
|
BOOL bRet;
|
|
} WOWADDPRINTER, *PWOWADDPRINTER;
|
|
|
|
//****************************************************************************
|
|
// globals -
|
|
//
|
|
//****************************************************************************
|
|
|
|
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo);
|
|
DWORD ExtDevModeHandler(LPWOWFAXINFO lpfaxinfo);
|
|
BOOL ConvertDevMode(PDEVMODE16 lpdm16, LPDEVMODEW lpdmW, BOOL fTo16);
|
|
BOOL ConvertGdiInfo(LPGDIINFO16 lpginfo16, PGDIINFO lpginfo, BOOL fTo16);
|
|
|
|
extern HANDLE hmodWOW32;
|
|
|
|
LPWOWFAXINFO glpfaxinfoCur = 0;
|
|
WOWFAXINFO gfaxinfo;
|
|
|
|
UINT uNumSupFaxDrv;
|
|
LPSTR *SupFaxDrv;
|
|
|
|
//****************************************************************************
|
|
// SortedInsert - Alpha sort.
|
|
//****************************************************************************
|
|
|
|
VOID SortedInsert(LPSTR lpElement, LPSTR *alpList)
|
|
{
|
|
LPSTR lpTmp, lpSwap;
|
|
|
|
while (*alpList) {
|
|
if (WOW32_stricmp(lpElement, *alpList) < 0) {
|
|
break;
|
|
}
|
|
alpList++;
|
|
}
|
|
lpTmp = *alpList;
|
|
*alpList++ = lpElement;
|
|
while (lpTmp) {
|
|
// SWAP(*alpList, lpTmp);
|
|
lpSwap = *alpList; *alpList = lpTmp; lpTmp = lpSwap;
|
|
alpList++;
|
|
}
|
|
}
|
|
|
|
//****************************************************************************
|
|
// BuildStrList - Find the starting point of strings in a list (lpList) of
|
|
// NULL terminated strings which is double NULL terminated.
|
|
// If a non-NULL alpList parameter is passed, it will be
|
|
// filled with an array of pointers to the starting point
|
|
// of each string in the list. The number of strings in the
|
|
// list is always returned.
|
|
//****************************************************************************
|
|
|
|
UINT BuildStrList(LPSTR lpList, LPSTR *alpList)
|
|
{
|
|
LPSTR lp;
|
|
TCHAR cLastChar = 1;
|
|
UINT uCount = 0;
|
|
|
|
lp = lpList;
|
|
while ((cLastChar) || (*lp)) {
|
|
if ((*lp == 0) && (lp != lpList)) {
|
|
uCount++;
|
|
}
|
|
|
|
if ((lpList == lp) || (cLastChar == 0)) {
|
|
if ((*lp) && (alpList)) {
|
|
SortedInsert(lp, alpList);
|
|
}
|
|
}
|
|
cLastChar = *lp++;
|
|
}
|
|
return uCount;
|
|
}
|
|
|
|
//****************************************************************************
|
|
// GetSupportedFaxDrivers - Read in the SupFaxDrv name list from the
|
|
// registry. This list is used to determine if we will
|
|
// install a 16-bit fax printer driver during
|
|
// WriteProfileString and WritePrivateProfileString.
|
|
//****************************************************************************
|
|
|
|
LPSTR *GetSupportedFaxDrivers(UINT *uCount)
|
|
{
|
|
HKEY hKey = 0;
|
|
DWORD dwType;
|
|
DWORD cbBufSize=0;
|
|
LPSTR lpSupFaxDrvBuf;
|
|
LPSTR *alpSupFaxDrvList = NULL;
|
|
|
|
*uCount = 0;
|
|
|
|
// Open the registry key.
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
"Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\\SupportedFaxDrivers",
|
|
0, KEY_READ, &hKey ) != ERROR_SUCCESS) {
|
|
goto GSFD_error;
|
|
}
|
|
|
|
// Query value for size of buffer and allocate.
|
|
if (RegQueryValueEx(hKey, "DriverNames", 0, &dwType, NULL, &cbBufSize) != ERROR_SUCCESS) {
|
|
goto GSFD_error;
|
|
}
|
|
if ((dwType != REG_MULTI_SZ) ||
|
|
((lpSupFaxDrvBuf = (LPSTR) malloc_w(cbBufSize)) == NULL)) {
|
|
goto GSFD_error;
|
|
}
|
|
|
|
if (RegQueryValueEx(hKey, "DriverNames", 0, &dwType, lpSupFaxDrvBuf, &cbBufSize) != ERROR_SUCCESS) {
|
|
goto GSFD_error;
|
|
}
|
|
|
|
// Get the number of elements in the list
|
|
if (*uCount = BuildStrList(lpSupFaxDrvBuf, NULL)) {
|
|
// Build an array of pointers to the start of the strings in the list.
|
|
alpSupFaxDrvList = (LPSTR *) malloc_w(*uCount * sizeof(LPSTR));
|
|
if (alpSupFaxDrvList) {
|
|
// Fill the array with string starting points.
|
|
RtlZeroMemory(alpSupFaxDrvList, *uCount * sizeof(LPSTR));
|
|
BuildStrList(lpSupFaxDrvBuf, alpSupFaxDrvList);
|
|
}
|
|
else {
|
|
goto GSFD_error;
|
|
}
|
|
}
|
|
goto GSFD_exit;
|
|
|
|
GSFD_error:
|
|
LOGDEBUG(0,("WOW32!GetSupportedFaxDrivers failed!\n"));
|
|
|
|
GSFD_exit:
|
|
if (hKey) {
|
|
RegCloseKey(hKey);
|
|
}
|
|
return alpSupFaxDrvList;
|
|
}
|
|
|
|
|
|
//****************************************************************************
|
|
// WowFaxWndProc - This is the 32-bit WndProc which will SubClass the 16-bit
|
|
// FaxWndProc in WOWEXEC.EXE. It's main function is to
|
|
// convert 32-bit data passed from the WOW 32-bit generic
|
|
// fax driver to 16-bit data to be used by the various 16-bit
|
|
// fax printer drivers.
|
|
//****************************************************************************
|
|
|
|
LONG WowFaxWndProc(HWND hwnd, UINT uMsg, UINT uParam, LONG lParam)
|
|
{
|
|
TCHAR lpPath[MAX_PATH];
|
|
HANDLE hMap;
|
|
|
|
if ((uMsg >= WM_DDRV_FIRST) && (uMsg <= WM_DDRV_LAST)) {
|
|
//
|
|
// WM_DDRV_* message: uParam = idMap
|
|
// lParam = unused.
|
|
//
|
|
// The corresponding data is obtained from the shared memory.
|
|
//
|
|
|
|
GetFaxDataMapName(uParam, lpPath);
|
|
hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, lpPath);
|
|
if (hMap) {
|
|
LPWOWFAXINFO lpT;
|
|
if (lpT = (LPWOWFAXINFO)MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0)) {
|
|
WOW32FaxHandler(lpT->msg, (LPSTR)lpT);
|
|
|
|
// Set the status to TRUE indicating that the message
|
|
// has been 'processed' by WOW. This doesnot indicate
|
|
// the success or the failure of the actual processing
|
|
// of the message.
|
|
|
|
lpT->status = TRUE;
|
|
UnmapViewOfFile(lpT);
|
|
CloseHandle(hMap);
|
|
return(TRUE);
|
|
}
|
|
CloseHandle(hMap);
|
|
}
|
|
LOGDEBUG(0,("WowFaxWndProc failed to setup shared data mapping!\n"));
|
|
// WOW32ASSERT(FALSE); // turn this off - Procomm tries to install
|
|
// this many times.
|
|
}
|
|
else {
|
|
|
|
// Not a WM_DDRV_* message. Pass it on to the original proc.
|
|
|
|
return CallWindowProc(gfaxinfo.proc16, hwnd, uMsg, uParam, lParam);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
//**************************************************************************
|
|
// WOW32FaxHandler -
|
|
//
|
|
// Handles various WowFax related operations.
|
|
//
|
|
//**************************************************************************
|
|
|
|
ULONG WOW32FaxHandler(UINT iFun, LPSTR lpIn)
|
|
{
|
|
LPWOWFAXINFO lpT = (LPWOWFAXINFO)lpIn;
|
|
LPWOWFAXINFO16 lpT16;
|
|
HWND hwnd = gfaxinfo.hwnd;
|
|
LPBYTE lpData;
|
|
VPVOID vp;
|
|
|
|
#ifdef DEBUG
|
|
int DebugStringIndex = iFun - (WM_USER+0x100+1);
|
|
|
|
if ((DebugStringIndex >= WM_DDRV_FIRST) && (DebugStringIndex <= WM_DDRV_LAST) ) {
|
|
LOGDEBUG(0,("WOW32FaxHandler, %s, 0x%lX\n", (LPSTR)szWmDdrvDebugStrings[DebugStringIndex], (LPSTR) lpIn));
|
|
}
|
|
#endif
|
|
|
|
switch (iFun) {
|
|
case WM_DDRV_SUBCLASS:
|
|
//
|
|
// Subclass the window - This is so that we get a chance to
|
|
// transform the 32bit data to 16bit data and vice versa. A
|
|
// NULL HWND, passed in lpIn, indicates don't subclass.
|
|
//
|
|
|
|
if (gfaxinfo.hwnd = (HWND)lpIn) {
|
|
gfaxinfo.proc16 = (WNDPROC)SetWindowLong((HWND)lpIn,
|
|
GWL_WNDPROC, (DWORD)WowFaxWndProc);
|
|
gfaxinfo.tid = GetWindowThreadProcessId((HWND)lpIn, NULL);
|
|
}
|
|
|
|
WOW32ASSERT(sizeof(DEVMODE16) + 4 == sizeof(DEVMODE31));
|
|
|
|
//
|
|
// Read in the SupFaxDrv name list from the registry.
|
|
//
|
|
|
|
SupFaxDrv = GetSupportedFaxDrivers(&uNumSupFaxDrv);
|
|
|
|
break;
|
|
|
|
case WM_DDRV_ENABLE:
|
|
|
|
// Enable the driver:
|
|
// . first intialize the 16bit faxinfo datastruct
|
|
// . then inform the driver (dll name) to be loaded
|
|
//
|
|
// format of ddrv_message:
|
|
// wParam = hdc (just a unique id)
|
|
// lparam = 16bit faxinfo struct with relevant data
|
|
// Must call 'callwindowproc' not 'sendmessage' because
|
|
// WowFaxWndProc is a subclass of the 16-bit FaxWndProc.
|
|
//
|
|
|
|
WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL);
|
|
lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0);
|
|
if (lpT->lpinfo16) {
|
|
vp = malloc16(lpT->cData);
|
|
GETVDMPTR(vp, lpT->cData, lpData);
|
|
if (lpData == 0) {
|
|
break;
|
|
}
|
|
|
|
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
|
|
if (lpT16) {
|
|
if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) {
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
lpT->szDeviceName,
|
|
lstrlenW(lpT->szDeviceName) + 1,
|
|
lpT16->szDeviceName,
|
|
sizeof(lpT16->szDeviceName),
|
|
NULL, NULL);
|
|
|
|
lpT16->lpDriverName = lpT->lpDriverName;
|
|
if (lpT->lpDriverName) {
|
|
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName;
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName),
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
|
|
lpData + (DWORD)lpT->lpDriverName,
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
|
|
NULL, NULL);
|
|
}
|
|
|
|
lpT16->lpPortName = lpT->lpPortName;
|
|
if (lpT->lpPortName) {
|
|
lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpT->lpPortName;
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName),
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1,
|
|
lpData + (DWORD)lpT->lpPortName,
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1,
|
|
NULL, NULL);
|
|
}
|
|
|
|
|
|
lpT16->lpIn = lpT->lpIn;
|
|
|
|
if (lpT->lpIn) {
|
|
lpT16->lpIn = (LPBYTE)vp + (DWORD)lpT->lpIn;
|
|
ConvertDevMode((PDEVMODE16)(lpData + (DWORD)lpT->lpIn),
|
|
(LPDEVMODEW)((LPSTR)lpT + (DWORD)lpT->lpIn), TRUE);
|
|
}
|
|
WOW32ASSERT((sizeof(GDIINFO16) + sizeof(POINT16)) <= sizeof(GDIINFO));
|
|
lpT16->lpOut = (LPBYTE)vp + (DWORD)lpT->lpOut;
|
|
FREEVDMPTR(lpData);
|
|
FREEVDMPTR(lpT16);
|
|
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
if (lpT->retvalue) {
|
|
GETVDMPTR(vp, lpT->cData, lpData);
|
|
ConvertGdiInfo((LPGDIINFO16)(lpData + (DWORD)lpT->lpOut),
|
|
(PGDIINFO)((LPSTR)lpT + (DWORD)lpT->lpOut), FALSE);
|
|
|
|
}
|
|
}
|
|
}
|
|
free16(vp);
|
|
}
|
|
break;
|
|
|
|
case WM_DDRV_ESCAPE:
|
|
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
|
|
if (lpT16) {
|
|
lpT16->wCmd = lpT->wCmd;
|
|
}
|
|
FREEVDMPTR(lpT16);
|
|
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
break;
|
|
|
|
case WM_DDRV_PRINTPAGE:
|
|
//
|
|
// set the global variable. When the 16bit driver calls DMBitBlt we
|
|
// get the bitmap info from here. Since WOW is single threaded we
|
|
// won't receive another printpage msg before we return from here.
|
|
//
|
|
// All pointers in the faxinfo structure are actually
|
|
// 'offsets from the start of the mapfile' to relevant data.
|
|
//
|
|
|
|
|
|
glpfaxinfoCur = lpT;
|
|
lpT->lpbits = (LPBYTE)lpT + (DWORD)lpT->lpbits;
|
|
|
|
// fall through;
|
|
|
|
case WM_DDRV_STARTDOC:
|
|
// WowFax (EasyFax Ver2.0) support...
|
|
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
|
|
if (lpT16) {
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
lpT->szDocName,
|
|
lstrlenW(lpT->szDocName) + 1,
|
|
lpT16->szDocName,
|
|
sizeof(lpT16->szDocName),
|
|
NULL, NULL);
|
|
}
|
|
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
break;
|
|
|
|
case WM_DDRV_ENDDOC:
|
|
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
break;
|
|
|
|
case WM_DDRV_DISABLE:
|
|
CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
lpT->retvalue = TRUE;
|
|
break;
|
|
|
|
|
|
case WM_DDRV_EXTDMODE:
|
|
case WM_DDRV_DEVCAPS:
|
|
WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL);
|
|
lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0);
|
|
if (lpT->lpinfo16) {
|
|
vp = malloc16(lpT->cData);
|
|
GETVDMPTR(vp, lpT->cData, lpData);
|
|
if (lpData == 0) {
|
|
break;
|
|
}
|
|
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
|
|
if (lpT16) {
|
|
if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) {
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
lpT->szDeviceName,
|
|
lstrlenW(lpT->szDeviceName) + 1,
|
|
lpT16->szDeviceName,
|
|
sizeof(lpT16->szDeviceName),
|
|
NULL, NULL);
|
|
|
|
lpT16->lpDriverName = lpT->lpDriverName;
|
|
if (lpT->lpDriverName) {
|
|
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName;
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName),
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
|
|
lpData + (DWORD)lpT->lpDriverName,
|
|
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
|
|
NULL, NULL);
|
|
}
|
|
|
|
FREEVDMPTR(lpData);
|
|
FREEVDMPTR(lpT16);
|
|
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, WM_DDRV_LOAD, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
if (lpT->retvalue) {
|
|
lpT->retvalue = (iFun == WM_DDRV_DEVCAPS) ? DeviceCapsHandler(lpT) :
|
|
ExtDevModeHandler(lpT) ;
|
|
}
|
|
CallWindowProc( gfaxinfo.proc16,
|
|
hwnd, WM_DDRV_UNLOAD, lpT->hdc, (LPARAM)lpT->lpinfo16);
|
|
}
|
|
}
|
|
free16(vp);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// gDC_CopySize -
|
|
//
|
|
// Indicates the size of a list item in bytes for use during
|
|
// the DeviceCapsHandler thunk. A zero entry indicates that an
|
|
// allocate and copy is not needed for the query.
|
|
//
|
|
//**************************************************************************
|
|
|
|
BYTE gDC_ListItemSize[DC_COPIES + 1] = {
|
|
0,
|
|
0, // DC_FIELDS 1
|
|
sizeof(WORD), // DC_PAPERS 2
|
|
sizeof(POINT), // DC_PAPERSIZE 3
|
|
sizeof(POINT), // DC_MINEXTENT 4
|
|
sizeof(POINT), // DC_MAXEXTENT 5
|
|
sizeof(WORD), // DC_BINS 6
|
|
0, // DC_DUPLEX 7
|
|
0, // DC_SIZE 8
|
|
0, // DC_EXTRA 9
|
|
0, // DC_VERSION 10
|
|
0, // DC_DRIVER 11
|
|
24, // DC_BINNAMES 12 //ANSI
|
|
sizeof(LONG) * 2, // DC_ENUMRESOLUTIONS 13
|
|
64, // DC_FILEDEPENDENCIES 14 //ANSI
|
|
0, // DC_TRUETYPE 15
|
|
64, // DC_PAPERNAMES 16 //ANSI
|
|
0, // DC_ORIENTATION 17
|
|
0 // DC_COPIES 18
|
|
};
|
|
|
|
//**************************************************************************
|
|
// DeviceCapsHandler -
|
|
//
|
|
// Makes a single call down to the 16-bit printer driver for queries
|
|
// which don't need to allocate and copy. For queries which do, two
|
|
// calls to the 16-bit printer driver are made. One to get the number
|
|
// of items, and a second to get the actual data.
|
|
//
|
|
//**************************************************************************
|
|
|
|
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo)
|
|
{
|
|
LPWOWFAXINFO16 lpWFI16;
|
|
LPSTR lpSrc;
|
|
LPBYTE lpDest;
|
|
INT i;
|
|
DWORD cbData16; // Size of data items.
|
|
UINT cbUni;
|
|
|
|
LOGDEBUG(0,("DeviceCapsHandler, lpfaxinfo: %X, wCmd: %X\n", lpfaxinfo, lpfaxinfo->wCmd));
|
|
|
|
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpWFI16);
|
|
|
|
// Get the number of data items with a call to the 16-bit printer driver.
|
|
|
|
lpWFI16->lpDriverName = 0;
|
|
lpWFI16->lpPortName = 0;
|
|
lpWFI16->wCmd = lpfaxinfo->wCmd;
|
|
lpWFI16->cData = 0;
|
|
lpWFI16->lpOut = 0;
|
|
lpfaxinfo->cData = 0;
|
|
|
|
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
|
|
lpfaxinfo->msg, lpfaxinfo->hdc,
|
|
(LPARAM)lpfaxinfo->lpinfo16);
|
|
|
|
cbData16 = gDC_ListItemSize[lpfaxinfo->wCmd];
|
|
if (lpfaxinfo->lpOut && cbData16 && lpfaxinfo->retvalue) {
|
|
|
|
// We need to allocate and copy for this query
|
|
lpWFI16->cData = cbData16 * lpfaxinfo->retvalue;
|
|
|
|
// assert the size of output buffer - and set it the actual data size
|
|
switch (lpfaxinfo->wCmd) {
|
|
case DC_BINNAMES:
|
|
case DC_PAPERNAMES:
|
|
// These fields need extra room for ANSI to UNICODE conversion.
|
|
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData * sizeof(WCHAR));
|
|
lpfaxinfo->cData = lpWFI16->cData * sizeof(WCHAR);
|
|
break;
|
|
default:
|
|
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData);
|
|
lpfaxinfo->cData = lpWFI16->cData;
|
|
break;
|
|
}
|
|
|
|
if ((lpWFI16->lpOut = (LPSTR)malloc16(lpWFI16->cData)) == NULL) {
|
|
lpfaxinfo->retvalue = 0;
|
|
goto LeaveDeviceCapsHandler;
|
|
}
|
|
|
|
// Get the list data with a call to the 16-bit printer driver.
|
|
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
|
|
lpfaxinfo->msg, lpfaxinfo->hdc,
|
|
(LPARAM)lpfaxinfo->lpinfo16);
|
|
|
|
GETVDMPTR(lpWFI16->lpOut, 0, lpSrc);
|
|
lpDest = (LPBYTE)lpfaxinfo + (DWORD)lpfaxinfo->lpOut;
|
|
|
|
switch (lpfaxinfo->wCmd) {
|
|
case DC_BINNAMES:
|
|
case DC_PAPERNAMES:
|
|
for (i = 0; i < (INT)lpfaxinfo->retvalue; i++) {
|
|
RtlMultiByteToUnicodeN((LPWSTR)lpDest,
|
|
cbData16 * sizeof(WCHAR),
|
|
(PULONG)&cbUni,
|
|
(LPBYTE)lpSrc, cbData16);
|
|
lpDest += cbData16 * sizeof(WCHAR);
|
|
lpSrc += cbData16;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
#ifdef FE_SB // for buggy fax driver such as CB-FAX Pro (Bother Corp.)
|
|
try {
|
|
RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
// What can I do for the exception... ????
|
|
// Anyway, we don't want to die.....
|
|
#if DBG
|
|
LOGDEBUG(0,("Exception during copying some data\n"));
|
|
#endif
|
|
}
|
|
#else // !FE_SB
|
|
RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData);
|
|
#endif // !FE_SB
|
|
break;
|
|
}
|
|
free16((VPVOID)lpWFI16->lpOut);
|
|
FREEVDMPTR(lpSrc);
|
|
}
|
|
|
|
LeaveDeviceCapsHandler:
|
|
FREEVDMPTR(lpWFI16);
|
|
return lpfaxinfo->retvalue;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// ExtDevModeHandler
|
|
//
|
|
//**************************************************************************
|
|
|
|
DWORD ExtDevModeHandler(LPWOWFAXINFO lpfaxinfo)
|
|
{
|
|
LPWOWFAXINFO16 lpT16;
|
|
LPSTR lpT;
|
|
VPVOID vp;
|
|
|
|
LOGDEBUG(0,("ExtDevModeHandler\n"));
|
|
|
|
(LONG)lpfaxinfo->retvalue = -1;
|
|
|
|
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
|
|
|
|
if (lpT16) {
|
|
|
|
// assumption that 16bit data won't be larger than 32bit data.
|
|
// this makes life easy in two ways; first we don't need to calculate
|
|
// the exact size and secondly the 16bit pointers can be set to same
|
|
// relative offsets as input(32 bit) pointers
|
|
|
|
vp = malloc16(lpfaxinfo->cData);
|
|
if (vp) {
|
|
GETVDMPTR(vp, lpfaxinfo->cData, lpT);
|
|
if (lpT) {
|
|
lpT16->wCmd = lpfaxinfo->wCmd;
|
|
lpT16->lpOut = (LPSTR)lpfaxinfo->lpOut;
|
|
lpT16->lpIn = (LPSTR)lpfaxinfo->lpIn;
|
|
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpDriverName;
|
|
lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpPortName;
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
(PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName),
|
|
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1,
|
|
lpT + (DWORD)lpfaxinfo->lpDriverName,
|
|
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1,
|
|
NULL, NULL);
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
(PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName),
|
|
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1,
|
|
lpT + (DWORD)lpfaxinfo->lpPortName,
|
|
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1,
|
|
NULL, NULL);
|
|
if (lpfaxinfo->lpIn) {
|
|
lpT16->lpIn = (LPBYTE)vp + (DWORD)lpfaxinfo->lpIn;
|
|
ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpIn),
|
|
(LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpIn), TRUE);
|
|
}
|
|
|
|
if (lpfaxinfo->lpOut) {
|
|
lpT16->lpOut = (LPBYTE)vp + (DWORD)lpfaxinfo->lpOut;
|
|
}
|
|
|
|
lpT16->hwndui = GETHWND16(lpfaxinfo->hwndui);
|
|
|
|
FREEVDMPTR(lpT);
|
|
lpfaxinfo->retvalue = CallWindowProc( gfaxinfo.proc16, gfaxinfo.hwnd,
|
|
lpfaxinfo->msg, lpfaxinfo->hdc, (LPARAM)lpfaxinfo->lpinfo16);
|
|
|
|
if ((lpfaxinfo->wCmd == 0) && (lpfaxinfo->retvalue > 0)) {
|
|
// the 16bit driver has returned 16bit struct size. change
|
|
// the return value to correspond to the devmodew struct.
|
|
//
|
|
// since devmode16 (the 3.0 version) is smaller than devmode31
|
|
// the retvalue will take careof both win30/win31 devmode
|
|
|
|
WOW32ASSERT(sizeof(DEVMODE16) < sizeof(DEVMODE31));
|
|
lpfaxinfo->retvalue += (sizeof(DEVMODEW) - sizeof(DEVMODE16));
|
|
}
|
|
|
|
GETVDMPTR(vp, lpfaxinfo->cData, lpT);
|
|
|
|
if ((lpfaxinfo->wCmd & DM_COPY) &&
|
|
lpfaxinfo->lpOut && (lpfaxinfo->retvalue == IDOK)) {
|
|
ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpOut),
|
|
(LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpOut), FALSE);
|
|
}
|
|
|
|
}
|
|
free16(vp);
|
|
}
|
|
|
|
}
|
|
|
|
FREEVDMPTR(lpT16);
|
|
|
|
return lpfaxinfo->retvalue;
|
|
}
|
|
|
|
//***************************************************************************
|
|
// ConvertDevMode
|
|
//***************************************************************************
|
|
|
|
BOOL ConvertDevMode(PDEVMODE16 lpdm16, LPDEVMODEW lpdmW, BOOL fTo16)
|
|
{
|
|
LOGDEBUG(0,("ConvertDevMode\n"));
|
|
|
|
if (!lpdm16 || !lpdmW)
|
|
return TRUE;
|
|
|
|
if (fTo16) {
|
|
RtlZeroMemory(lpdm16, sizeof(DEVMODE16));
|
|
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
lpdmW->dmDeviceName,
|
|
sizeof(lpdmW->dmDeviceName) / sizeof(lpdmW->dmDeviceName[0]),
|
|
lpdm16->dmDeviceName,
|
|
sizeof(lpdm16->dmDeviceName) / sizeof(lpdm16->dmDeviceName[0]),
|
|
NULL, NULL);
|
|
|
|
lpdm16->dmSpecVersion = lpdmW->dmSpecVersion;
|
|
lpdm16->dmDriverVersion = lpdmW->dmDriverVersion;
|
|
lpdm16->dmSize = lpdmW->dmSize;
|
|
lpdm16->dmDriverExtra = lpdmW->dmDriverExtra;
|
|
lpdm16->dmFields = lpdmW->dmFields;
|
|
lpdm16->dmOrientation = lpdmW->dmOrientation;
|
|
lpdm16->dmPaperSize = lpdmW->dmPaperSize;
|
|
lpdm16->dmPaperLength = lpdmW->dmPaperLength;
|
|
lpdm16->dmPaperWidth = lpdmW->dmPaperWidth;
|
|
lpdm16->dmScale = lpdmW->dmScale;
|
|
lpdm16->dmCopies = lpdmW->dmCopies;
|
|
lpdm16->dmDefaultSource = lpdmW->dmDefaultSource;
|
|
lpdm16->dmPrintQuality = lpdmW->dmPrintQuality;
|
|
lpdm16->dmColor = lpdmW->dmColor;
|
|
lpdm16->dmDuplex = lpdmW->dmDuplex;
|
|
|
|
// adjust lpdm16->dmSize (between win30 and win31 version)
|
|
|
|
lpdm16->dmSize = (lpdm16->dmSpecVersion > 0x300) ? sizeof(DEVMODE31) :
|
|
sizeof(DEVMODE16);
|
|
if (lpdm16->dmSize >= sizeof(DEVMODE31)) {
|
|
((PDEVMODE31)lpdm16)->dmYResolution = lpdmW->dmYResolution;
|
|
((PDEVMODE31)lpdm16)->dmTTOption = lpdmW->dmTTOption;
|
|
}
|
|
|
|
RtlCopyMemory((LPBYTE)lpdm16 + (DWORD)lpdm16->dmSize, (lpdmW + 1),
|
|
lpdmW->dmDriverExtra);
|
|
}
|
|
else {
|
|
|
|
// LATER: should specversion be NT version rather than win30 driver version?
|
|
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
lpdm16->dmDeviceName,
|
|
sizeof(lpdm16->dmDeviceName) / sizeof(lpdm16->dmDeviceName[0]),
|
|
lpdmW->dmDeviceName,
|
|
sizeof(lpdmW->dmDeviceName) / sizeof(lpdmW->dmDeviceName[0]));
|
|
|
|
lpdmW->dmSpecVersion = lpdm16->dmSpecVersion;
|
|
lpdmW->dmDriverVersion = lpdm16->dmDriverVersion;
|
|
lpdmW->dmSize = lpdm16->dmSize;
|
|
lpdmW->dmDriverExtra = lpdm16->dmDriverExtra;
|
|
lpdmW->dmFields = lpdm16->dmFields;
|
|
lpdmW->dmOrientation = lpdm16->dmOrientation;
|
|
lpdmW->dmPaperSize = lpdm16->dmPaperSize;
|
|
lpdmW->dmPaperLength = lpdm16->dmPaperLength;
|
|
lpdmW->dmPaperWidth = lpdm16->dmPaperWidth;
|
|
lpdmW->dmScale = lpdm16->dmScale;
|
|
lpdmW->dmCopies = lpdm16->dmCopies;
|
|
lpdmW->dmDefaultSource = lpdm16->dmDefaultSource;
|
|
lpdmW->dmPrintQuality = lpdm16->dmPrintQuality;
|
|
lpdmW->dmColor = lpdm16->dmColor;
|
|
lpdmW->dmDuplex = lpdm16->dmDuplex;
|
|
|
|
if (lpdm16->dmSize >= sizeof(DEVMODE31)) {
|
|
lpdmW->dmYResolution = ((PDEVMODE31)lpdm16)->dmYResolution;
|
|
lpdmW->dmTTOption = ((PDEVMODE31)lpdm16)->dmTTOption;
|
|
}
|
|
|
|
// 16bit world doesnot know anything about the fields like
|
|
// formname etc.
|
|
|
|
RtlCopyMemory(lpdmW + 1, (LPBYTE)lpdm16 + lpdm16->dmSize, lpdm16->dmDriverExtra);
|
|
|
|
// adjust size for 32bit world
|
|
|
|
lpdmW->dmSize = sizeof(*lpdmW);
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// ConvertGdiInfo
|
|
//
|
|
//**************************************************************************
|
|
|
|
|
|
BOOL ConvertGdiInfo(LPGDIINFO16 lpginfo16, PGDIINFO lpginfo, BOOL fTo16)
|
|
{
|
|
LOGDEBUG(0,("ConvertGdiInfo\n"));
|
|
|
|
if (!lpginfo16 || !lpginfo)
|
|
return FALSE;
|
|
|
|
if (!fTo16) {
|
|
lpginfo->ulTechnology = lpginfo16->dpTechnology;
|
|
lpginfo->ulLogPixelsX = lpginfo16->dpLogPixelsX;
|
|
lpginfo->ulLogPixelsY = lpginfo16->dpLogPixelsY;
|
|
lpginfo->ulDevicePelsDPI = lpginfo->ulLogPixelsX;
|
|
lpginfo->ulHorzSize = lpginfo16->dpHorzSize;
|
|
lpginfo->ulVertSize = lpginfo16->dpVertSize;
|
|
lpginfo->ulHorzRes = lpginfo16->dpHorzRes;
|
|
lpginfo->ulVertRes = lpginfo16->dpVertRes;
|
|
lpginfo->cBitsPixel = lpginfo16->dpBitsPixel;
|
|
lpginfo->cPlanes = lpginfo16->dpPlanes;
|
|
lpginfo->ulNumColors = lpginfo16->dpNumColors;
|
|
lpginfo->ptlPhysOffset.x = ((PPOINT16)(lpginfo16+1))->x;
|
|
lpginfo->ptlPhysOffset.y = ((PPOINT16)(lpginfo16+1))->y;
|
|
lpginfo->szlPhysSize.cx = lpginfo->ulHorzRes;
|
|
lpginfo->szlPhysSize.cy = lpginfo->ulVertRes;
|
|
lpginfo->ulPanningHorzRes = lpginfo->ulHorzRes;
|
|
lpginfo->ulPanningVertRes = lpginfo->ulVertRes;
|
|
lpginfo->ulAspectX = lpginfo16->dpAspectX;
|
|
lpginfo->ulAspectY = lpginfo16->dpAspectY;
|
|
lpginfo->ulAspectXY = lpginfo16->dpAspectXY;
|
|
|
|
//
|
|
// RASDD tries to be smart as to whether the x and y DPI are equal or
|
|
// not. In the case of 200dpi in the x direction and 100dpi in the
|
|
// y direction, you may want to adjust this to 2 for xStyleStep, 1 for
|
|
// yStyleStep and dpi/50 for denStyleStep. This basicaly determines
|
|
// how long dashes/dots will be when drawing with styled pens.
|
|
// Since we just hard code denStyleStep to 3, we get different lines
|
|
// at 100dpi vs 200dpi
|
|
//
|
|
|
|
lpginfo->xStyleStep = 1;
|
|
lpginfo->yStyleStep = 1;
|
|
lpginfo->denStyleStep = 3;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//**************************************************************************
|
|
// DMBitBlt -
|
|
// The 16bit winfax.drv calls this , in response to a device driver
|
|
// 'bitblt' call.
|
|
//
|
|
//**************************************************************************
|
|
|
|
ULONG FASTCALL WG32DMBitBlt( PVDMFRAME pFrame)
|
|
{
|
|
register PDMBITBLT16 parg16;
|
|
#ifdef DBCS /* wowfax support */
|
|
register PDEV_BITMAP16 pbm16;
|
|
#else // !DBCS
|
|
register PBITMAP16 pbm16;
|
|
#endif /* !DBCS */
|
|
LPBYTE lpDest, lpSrc;
|
|
UINT cBytes;
|
|
LPBYTE lpbits, lpbitsEnd;
|
|
|
|
LOGDEBUG(0,("WG32DMBitBlt\n"));
|
|
|
|
GETARGPTR(pFrame, sizeof(DMBITBLT16), parg16);
|
|
#ifdef DBCS /* wowfax support */
|
|
GETVDMPTR(parg16->pbitmapdest, sizeof(DEV_BITMAP16), pbm16);
|
|
#else // !DBCS
|
|
GETVDMPTR(parg16->pbitmapdest, sizeof(BITMAP16), pbm16);
|
|
#endif /* !DBCS */
|
|
GETVDMPTR(pbm16->bmBits, 0, lpDest);
|
|
|
|
WOW32ASSERT(glpfaxinfoCur != NULL);
|
|
lpbits = glpfaxinfoCur->lpbits;
|
|
lpbitsEnd = (LPBYTE)lpbits + glpfaxinfoCur->bmHeight *
|
|
glpfaxinfoCur->bmWidthBytes;
|
|
|
|
#ifdef DBCS /* wowfax support */
|
|
lpSrc = (LPBYTE)lpbits + (parg16->srcx / glpfaxinfoCur->bmPixPerByte) +
|
|
(parg16->srcy * glpfaxinfoCur->bmWidthBytes);
|
|
|
|
if (lpSrc >= lpbits) {
|
|
|
|
WORD extx,exty,srcx,srcy,desty,destx;
|
|
|
|
extx = FETCHWORD(parg16->extx);
|
|
exty = FETCHWORD(parg16->exty);
|
|
srcx = FETCHWORD(parg16->srcx);
|
|
srcy = FETCHWORD(parg16->srcy);
|
|
destx = FETCHWORD(parg16->destx);
|
|
desty = FETCHWORD(parg16->desty);
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("\n"));
|
|
LOGDEBUG(10,("bmType = %d\n",pbm16->bmType));
|
|
LOGDEBUG(10,("bmWidth = %d\n",pbm16->bmWidth));
|
|
LOGDEBUG(10,("bmHeight = %d\n",pbm16->bmHeight));
|
|
LOGDEBUG(10,("bmWidthBytes = %d\n",pbm16->bmWidthBytes));
|
|
LOGDEBUG(10,("bmPlanes = %d\n",pbm16->bmPlanes));
|
|
LOGDEBUG(10,("bmBitsPixel = %d\n",pbm16->bmBitsPixel));
|
|
LOGDEBUG(10,("bmBits = %x\n",pbm16->bmBits));
|
|
LOGDEBUG(10,("bmWidthPlances = %d\n",pbm16->bmWidthPlanes));
|
|
LOGDEBUG(10,("bmlpPDevice = %x\n",pbm16->bmlpPDevice));
|
|
LOGDEBUG(10,("bmSegmentIndex = %d\n",pbm16->bmSegmentIndex));
|
|
LOGDEBUG(10,("bmScanSegment = %d\n",pbm16->bmScanSegment));
|
|
LOGDEBUG(10,("bmFillBytes = %d\n",pbm16->bmFillBytes));
|
|
LOGDEBUG(10,("\n"));
|
|
LOGDEBUG(10,("bmWidthBytesSrc= %d\n",glpfaxinfoCur->bmWidthBytes));
|
|
LOGDEBUG(10,("\n"));
|
|
LOGDEBUG(10,("extx = %d\n",extx));
|
|
LOGDEBUG(10,("exty = %d\n",exty));
|
|
LOGDEBUG(10,("srcx = %d\n",srcx));
|
|
LOGDEBUG(10,("srcy = %d\n",srcy));
|
|
LOGDEBUG(10,("destx = %d\n",destx));
|
|
LOGDEBUG(10,("desty = %d\n",desty));
|
|
LOGDEBUG(10,("\n"));
|
|
#endif
|
|
|
|
if (pbm16->bmSegmentIndex) {
|
|
|
|
SHORT WriteSegment;
|
|
SHORT WriteOffset;
|
|
SHORT Segment=0,SegmentMax=0;
|
|
LPBYTE DstScan0,SrcScan0;
|
|
UINT cBytesInLastSegment;
|
|
INT RestLine = (INT) exty;
|
|
|
|
WriteSegment = desty / pbm16->bmScanSegment;
|
|
WriteOffset = desty % pbm16->bmScanSegment;
|
|
|
|
if (WriteOffset) {
|
|
WriteSegment += 1;
|
|
}
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("WriteSegment = %d\n",WriteSegment));
|
|
LOGDEBUG(10,("WriteOffset = %d\n",WriteOffset));
|
|
LOGDEBUG(10,("\n"));
|
|
LOGDEBUG(10,("lpDest = %x\n",lpDest));
|
|
LOGDEBUG(10,("\n"));
|
|
#endif
|
|
|
|
SegmentMax = exty / pbm16->bmScanSegment;
|
|
if ( exty % pbm16->bmScanSegment) {
|
|
SegmentMax += 1;
|
|
}
|
|
|
|
cBytes = glpfaxinfoCur->bmWidthBytes * pbm16->bmScanSegment;
|
|
lpDest = lpDest + destx + (WriteSegment * 0x10000L) +
|
|
(WriteOffset * pbm16->bmWidthBytes);
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("SourceBitmap = %x\n",lpSrc));
|
|
LOGDEBUG(10,("DestinationBitmap = %x\n",lpDest));
|
|
LOGDEBUG(10,("SegmentMax = %d\n",SegmentMax));
|
|
LOGDEBUG(10,("\n"));
|
|
LOGDEBUG(10,("cBytes = %d\n",cBytes));
|
|
LOGDEBUG(10,("\n"));
|
|
#endif
|
|
|
|
if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) {
|
|
|
|
try {
|
|
for( Segment = 1,DstScan0 = lpDest,SrcScan0 = lpSrc;
|
|
Segment < SegmentMax;
|
|
Segment++,DstScan0 += 0x10000L,
|
|
SrcScan0 += cBytes,RestLine -= pbm16->bmScanSegment ) {
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("%d ",Segment-1));
|
|
#endif
|
|
|
|
RtlCopyMemory(DstScan0,SrcScan0,cBytes);
|
|
RtlZeroMemory(DstScan0+cBytes,pbm16->bmFillBytes);
|
|
}
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("%d\n",Segment-1));
|
|
#endif
|
|
|
|
if( RestLine > 0 ) {
|
|
cBytesInLastSegment = RestLine * pbm16->bmWidthBytes;
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("RestLine = %d\n",RestLine));
|
|
LOGDEBUG(10,("cBytesInLastSegment = %d\n",cBytes));
|
|
#endif
|
|
|
|
// do for last segment..
|
|
RtlCopyMemory(DstScan0,SrcScan0,cBytesInLastSegment);
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
#if DBG
|
|
LOGDEBUG(10,("Exception during copying image\n"));
|
|
#endif
|
|
}
|
|
|
|
} else if ((DWORD)glpfaxinfoCur->bmWidthBytes > (DWORD)pbm16->bmWidthBytes) {
|
|
|
|
SHORT Line;
|
|
UINT cSrcAdvance = glpfaxinfoCur->bmWidthBytes;
|
|
UINT cDstAdvance = pbm16->bmWidthBytes;
|
|
|
|
try {
|
|
for( Segment = 1,DstScan0 = lpDest,SrcScan0 = lpSrc;
|
|
Segment < SegmentMax;
|
|
Segment++,DstScan0 += 0x10000L,
|
|
SrcScan0 += cBytes,RestLine -= pbm16->bmScanSegment ) {
|
|
|
|
LPBYTE DstScanl = DstScan0;
|
|
LPBYTE SrcScanl = SrcScan0;
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("%d ",Segment-1));
|
|
#endif
|
|
|
|
for( Line = 0;
|
|
Line < pbm16->bmScanSegment;
|
|
Line++,DstScanl += cDstAdvance,SrcScanl += cSrcAdvance ) {
|
|
|
|
RtlCopyMemory(DstScanl,SrcScanl,cDstAdvance);
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
LOGDEBUG(10,("%d\n",Segment-1));
|
|
#endif
|
|
|
|
if( RestLine > 0 ) {
|
|
|
|
LPBYTE DstScanl = DstScan0;
|
|
LPBYTE SrcScanl = SrcScan0;
|
|
|
|
for( Line = 0;
|
|
Line < RestLine;
|
|
Line++,DstScanl += cDstAdvance,SrcScanl += cSrcAdvance ) {
|
|
|
|
RtlCopyMemory(DstScanl,SrcScanl,cDstAdvance);
|
|
}
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
#if DBG
|
|
LOGDEBUG(10,("Exception during copying image\n"));
|
|
#endif
|
|
}
|
|
} else {
|
|
WOW32ASSERT(FALSE);
|
|
}
|
|
|
|
} else {
|
|
|
|
lpDest = lpDest + destx + desty * pbm16->bmWidthBytes;
|
|
|
|
if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) {
|
|
cBytes = parg16->exty * glpfaxinfoCur->bmWidthBytes;
|
|
if (cBytes > (UINT)(pbm16->bmHeight * pbm16->bmWidthBytes)) {
|
|
cBytes = pbm16->bmHeight * pbm16->bmWidthBytes;
|
|
WOW32ASSERT(FALSE);
|
|
}
|
|
if ((lpSrc + cBytes) <= lpbitsEnd) {
|
|
RtlCopyMemory(lpDest, lpSrc, cBytes);
|
|
}
|
|
} else {
|
|
int i;
|
|
|
|
// we need to transfer bits one partial scanline at a time
|
|
WOW32ASSERT((DWORD)pbm16->bmHeight <= (DWORD)glpfaxinfoCur->bmHeight);
|
|
WOW32ASSERT((DWORD)parg16->exty <= (DWORD)pbm16->bmHeight);
|
|
|
|
cBytes = ((DWORD)pbm16->bmWidthBytes < (DWORD)glpfaxinfoCur->bmWidthBytes) ?
|
|
pbm16->bmWidthBytes : glpfaxinfoCur->bmWidthBytes;
|
|
|
|
for (i = 0; i < parg16->exty; i++) {
|
|
if ((lpSrc + cBytes) <= lpbitsEnd) {
|
|
RtlCopyMemory(lpDest, lpSrc, cBytes);
|
|
}
|
|
lpDest += pbm16->bmWidthBytes;
|
|
lpSrc += glpfaxinfoCur->bmWidthBytes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#else // !DBCS
|
|
lpDest = lpDest + parg16->destx + parg16->desty * pbm16->bmWidthBytes;
|
|
lpSrc = (LPBYTE)lpbits + (parg16->srcx / glpfaxinfoCur->bmPixPerByte) +
|
|
parg16->srcy * glpfaxinfoCur->bmWidthBytes;
|
|
if (lpSrc >= lpbits) {
|
|
if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) {
|
|
cBytes = parg16->exty * glpfaxinfoCur->bmWidthBytes;
|
|
if (cBytes > (UINT)(pbm16->bmHeight * pbm16->bmWidthBytes)) {
|
|
cBytes = pbm16->bmHeight * pbm16->bmWidthBytes;
|
|
WOW32ASSERT(FALSE);
|
|
}
|
|
if ((lpSrc + cBytes) <= lpbitsEnd) {
|
|
RtlCopyMemory(lpDest, lpSrc, cBytes);
|
|
}
|
|
}
|
|
else if ((DWORD)glpfaxinfoCur->bmWidthBytes > (DWORD)pbm16->bmWidthBytes) {
|
|
int i;
|
|
|
|
// we need to transfer bits one partial scanline at a time
|
|
WOW32ASSERT((DWORD)pbm16->bmHeight <= (DWORD)glpfaxinfoCur->bmHeight);
|
|
WOW32ASSERT((DWORD)parg16->exty <= (DWORD)pbm16->bmHeight);
|
|
|
|
for (i = 0; i < parg16->exty; i++) {
|
|
if ((lpSrc + pbm16->bmWidthBytes) <= lpbitsEnd) {
|
|
RtlCopyMemory(lpDest, lpSrc, pbm16->bmWidthBytes);
|
|
}
|
|
lpDest += pbm16->bmWidthBytes;
|
|
lpSrc += glpfaxinfoCur->bmWidthBytes;
|
|
}
|
|
|
|
}
|
|
else {
|
|
WOW32ASSERT(FALSE);
|
|
}
|
|
|
|
|
|
}
|
|
#endif /* !DBCS */
|
|
return (ULONG)TRUE;
|
|
}
|
|
|
|
PSZ StrDup(PSZ szStr)
|
|
{
|
|
int len;
|
|
PSZ pszTmp;
|
|
|
|
if(szStr) {
|
|
len = strlen(szStr)+1;
|
|
pszTmp = malloc_w(len);
|
|
if(pszTmp) {
|
|
strcpy(pszTmp, szStr);
|
|
return(pszTmp);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
PSZ BuildPath(PSZ szPath, PSZ szFileName)
|
|
{
|
|
int len;
|
|
char szTmp[MAX_PATH];
|
|
|
|
len = strlen(szPath);
|
|
len += strlen(szFileName);
|
|
len += 2; // add in the '\' char and the terminating '\0';
|
|
szTmp[0] = '\0';
|
|
if(len < sizeof(szTmp)) {
|
|
strcpy(szTmp, szPath);
|
|
strcat(szTmp, "\\");
|
|
strcat(szTmp, szFileName);
|
|
}
|
|
WOW32ASSERT((szTmp[0] != '\0'));
|
|
// Note: StrDup uses HeapAlloc() to allocate a buffer.
|
|
return(StrDup(szTmp));
|
|
}
|
|
|
|
//**************************************************************************
|
|
// AddPrinterThread -
|
|
//
|
|
// Worker thread to make the AddPrinter call into the spooler.
|
|
//
|
|
//**************************************************************************
|
|
|
|
VOID AddPrinterThread(PWOWADDPRINTER pWowAddPrinter)
|
|
{
|
|
|
|
if ((*spoolerapis[pWowAddPrinter->iCode].lpfn)(NULL, 2,
|
|
pWowAddPrinter->pPrinterStuff)) {
|
|
pWowAddPrinter->bRet = TRUE;
|
|
}
|
|
else {
|
|
if (GetLastError() == ERROR_PRINTER_ALREADY_EXISTS) {
|
|
pWowAddPrinter->bRet = TRUE;
|
|
}
|
|
else {
|
|
#ifdef DBG
|
|
LOGDEBUG(0,("AddPrinterThread, AddPrinterxxx call failed: 0x%X\n", GetLastError()));
|
|
#endif
|
|
pWowAddPrinter->bRet = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//**************************************************************************
|
|
// DoAddPrinterStuff -
|
|
//
|
|
// Spin a worker thread to make the AddPrinterxxx calls into
|
|
// spooler. This is needed to prevent a deadlock when spooler
|
|
// RPC's to spoolss.
|
|
//
|
|
// This thread added for bug #107426.
|
|
//**************************************************************************
|
|
|
|
BOOL DoAddPrinterStuff(LPVOID pPrinterStuff, INT iCode)
|
|
{
|
|
WOWADDPRINTER WowAddPrinter;
|
|
HANDLE hWaitObjects;
|
|
DWORD dwEvent, dwUnused;
|
|
MSG msg;
|
|
|
|
// Spin the worker thread.
|
|
WowAddPrinter.pPrinterStuff = pPrinterStuff;
|
|
WowAddPrinter.iCode = iCode;
|
|
WowAddPrinter.bRet = FALSE;
|
|
if (hWaitObjects = CreateThread(NULL, 0,
|
|
(LPTHREAD_START_ROUTINE)AddPrinterThread,
|
|
&WowAddPrinter, 0, &dwUnused)) {
|
|
|
|
// Pump messages while we wait for AddPrinterThread to finish.
|
|
for (;;) {
|
|
dwEvent = MsgWaitForMultipleObjects(1,
|
|
&hWaitObjects,
|
|
FALSE,
|
|
INFINITE,
|
|
QS_ALLEVENTS | QS_SENDMESSAGE);
|
|
|
|
if (dwEvent == WAIT_OBJECT_0 + 0) {
|
|
|
|
// Worker thread done.
|
|
break;
|
|
|
|
}
|
|
else {
|
|
// pump messages so the callback into wowexec!FaxWndProc doesn't
|
|
// get hung
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
CloseHandle(hWaitObjects);
|
|
}
|
|
else {
|
|
LOGDEBUG(0,
|
|
("DoAddPrinterStuff, CreateThread on AddPrinterThread failed\n"));
|
|
}
|
|
|
|
return WowAddPrinter.bRet;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// InstallWowFaxPrinter -
|
|
//
|
|
// Installs the WowFax 32-bit print driver when a 16-bit fax printer
|
|
// installation is detected.
|
|
//
|
|
//**************************************************************************
|
|
|
|
BOOL InstallWowFaxPrinter(PSZ szSection, PSZ szKey, PSZ szString)
|
|
{
|
|
CHAR szTmp[MAX_PATH];
|
|
PSZ szSrcPath;
|
|
DWORD dwNeeded;
|
|
DRIVER_INFO_2 DriverInfo;
|
|
PRINTER_INFO_2 PrinterInfo;
|
|
PORT_INFO_1 PortInfo;
|
|
HKEY hKey = 0, hSubKey = 0;
|
|
BOOL bRetVal=FALSE;
|
|
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, Section = %s, Key = %s, String = %s\n", szSection, szKey, szString));
|
|
|
|
// Write the entry to the registry. We'll keep shadow entries
|
|
// in the registry for the WOW fax applications and drivers to
|
|
// read, since the entries that the spooler writes pertain
|
|
// to winspool, not the 16-bit fax driver.
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
"Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax",
|
|
0, KEY_WRITE, &hKey ) == ERROR_SUCCESS) {
|
|
if (RegCreateKey(hKey, szSection, &hSubKey) == ERROR_SUCCESS) {
|
|
RegSetValueEx(hSubKey, szKey, 0, REG_SZ, szString, strlen(szString)+1);
|
|
RegCloseKey(hKey);
|
|
RegCloseKey(hSubKey);
|
|
|
|
// Dynamically link to spooler API's
|
|
if (!(spoolerapis[WOW_GetPrinterDriverDirectory].lpfn)) {
|
|
if (!LoadLibraryAndGetProcAddresses(L"WINSPOOL.DRV", spoolerapis, WOW_SPOOLERAPI_COUNT)) {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, Unable to load WINSPOOL API's\n"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
// Copy the printer driver files.
|
|
RtlZeroMemory(&DriverInfo, sizeof(DRIVER_INFO_2));
|
|
RtlZeroMemory(&PrinterInfo, sizeof(PRINTER_INFO_2));
|
|
if (!(*spoolerapis[WOW_GetPrinterDriverDirectory].lpfn)(NULL, NULL, 1, szTmp, MAX_PATH, &dwNeeded)) {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, GetPrinterDriverDirectory failed: 0x%X\n", GetLastError()));
|
|
return(FALSE);
|
|
}
|
|
|
|
// This is a dummy. We've no data file, but spooler won't take NULL.
|
|
DriverInfo.pDataFile = BuildPath(szTmp, WOWFAX_DLL_NAME_A);
|
|
|
|
if ( !DriverInfo.pDataFile ) {
|
|
goto IWFP_error;
|
|
}
|
|
|
|
DriverInfo.pDriverPath = BuildPath(szTmp, WOWFAX_DLL_NAME_A);
|
|
|
|
if ( !DriverInfo.pDriverPath ) {
|
|
goto IWFP_error;
|
|
}
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, pDriverPath = %s\n", DriverInfo.pDataFile));
|
|
szSrcPath = BuildPath(pszSystemDirectory, WOWFAX_DLL_NAME_A);
|
|
|
|
if ( !szSrcPath ) {
|
|
goto IWFP_error;
|
|
}
|
|
|
|
CopyFile(szSrcPath, DriverInfo.pDriverPath, FALSE);
|
|
free_w(szSrcPath);
|
|
|
|
DriverInfo.pConfigFile = BuildPath(szTmp, WOWFAXUI_DLL_NAME_A);
|
|
szSrcPath = BuildPath(pszSystemDirectory, WOWFAXUI_DLL_NAME_A);
|
|
|
|
if ( !szSrcPath ) {
|
|
goto IWFP_error;
|
|
}
|
|
|
|
CopyFile(szSrcPath, DriverInfo.pConfigFile, FALSE);
|
|
free_w(szSrcPath);
|
|
|
|
// Install the printer driver.
|
|
DriverInfo.cVersion = 1;
|
|
DriverInfo.pName = "Windows 3.1 Compatible Fax Driver";
|
|
if ((bRetVal = DoAddPrinterStuff((LPVOID)&DriverInfo,
|
|
WOW_AddPrinterDriver)) == FALSE) {
|
|
|
|
// if the driver is already installed, it won't hurt to install
|
|
// it a second time. This might be necessary if the user is
|
|
// upgrading from WinFax Lite to WinFax Pro.
|
|
bRetVal = (GetLastError() == ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
|
|
}
|
|
|
|
if (bRetVal) {
|
|
// Parse out the printer name.
|
|
RtlZeroMemory(&PrinterInfo, sizeof(PRINTER_INFO_2));
|
|
PrinterInfo.pPrinterName = szKey;
|
|
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, pPrinterName = %s\n", PrinterInfo.pPrinterName));
|
|
|
|
// Use private API to add a NULL port. Printer guys need to fix
|
|
// redirection to NULL bug.
|
|
RtlZeroMemory(&PortInfo, sizeof(PORT_INFO_1));
|
|
PrinterInfo.pPortName = "NULL";
|
|
PortInfo.pName = PrinterInfo.pPortName;
|
|
|
|
// Get "Local Port" string.
|
|
LoadString(hmodWOW32, iszWowFaxLocalPort, szTmp, sizeof szTmp);
|
|
|
|
(*spoolerapis[WOW_AddPortEx].lpfn)(NULL, 1, &PortInfo, szTmp);
|
|
|
|
// Set the other defaults and install the printer.
|
|
PrinterInfo.pDriverName = "Windows 3.1 Compatible Fax Driver";
|
|
PrinterInfo.pPrintProcessor = "WINPRINT";
|
|
PrinterInfo.pDatatype = "RAW";
|
|
bRetVal = DoAddPrinterStuff((LPVOID)&PrinterInfo,
|
|
WOW_AddPrinter);
|
|
#ifdef DBG
|
|
if (!bRetVal) {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, AddPrinter failed: 0x%X\n", GetLastError()));
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, AddPrinterDriver failed: 0x%X\n", GetLastError()));
|
|
}
|
|
IWFP_error:
|
|
if ( DriverInfo.pDataFile ) {
|
|
free_w(DriverInfo.pDataFile);
|
|
}
|
|
|
|
if ( DriverInfo.pDriverPath ) {
|
|
free_w(DriverInfo.pDriverPath);
|
|
}
|
|
|
|
if ( DriverInfo.pConfigFile) {
|
|
free_w(DriverInfo.pConfigFile);
|
|
}
|
|
|
|
return(bRetVal);
|
|
}
|
|
else {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, Unable to create Key: %s\n", szSection));
|
|
}
|
|
}
|
|
else {
|
|
LOGDEBUG(0,("InstallWowFaxPrinter, Unable to open key: HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\n"));
|
|
}
|
|
|
|
if (hKey) {
|
|
RegCloseKey(hKey);
|
|
if (hSubKey) {
|
|
RegCloseKey(hSubKey);
|
|
}
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
// Come here if szSection=="devices" or if gbWinFaxHack==TRUE
|
|
BOOL IsFaxPrinterWriteProfileString(PSZ szSection, PSZ szKey, PSZ szString)
|
|
{
|
|
BOOL Result = FALSE;
|
|
|
|
// Don't install if trying to clear an entry.
|
|
if (!szString || *szString == '\0') {
|
|
goto Done;
|
|
}
|
|
|
|
// Trying to install a fax printer?
|
|
LOGDEBUG(0,("IsFaxPrinterWriteProfileString, Section = devices, Key = %s\n", szKey));
|
|
|
|
// Is the WinFax Lite hack enabled?
|
|
if(gbWinFaxHack) {
|
|
|
|
// if ("WINFAX", "modem", "xxx") we know the WinFax install program
|
|
// has had a chance to copy "WinFax.drv" to the hard drive. So
|
|
// now we can call AddPrinter which can callback into WinFax.drv to
|
|
// its hearts content.
|
|
if(!WOW32_strcmp(szSection, szWINFAX) && !WOW32_stricmp(szKey, szModem)) {
|
|
|
|
// Our hack has run its course. We set this before making the call
|
|
// to AddPrinter because it calls back into WinFax.drv which calls
|
|
// WriteProfileString()!
|
|
gbWinFaxHack = FALSE;
|
|
|
|
// Call into the spooler to add our driver to the registry.
|
|
if (!InstallWowFaxPrinter(szDevices, szWINFAX, szWINFAXCOMx)) {
|
|
WOW32ASSERTMSG(FALSE,
|
|
"Install of generic fax printer failed.\n");
|
|
}
|
|
}
|
|
Result = TRUE;
|
|
goto Done;
|
|
}
|
|
|
|
// Is it one of the fax drivers we recognize?
|
|
if (IsFaxPrinterSupportedDevice(szKey)) {
|
|
|
|
// Time to enable the WinFax Lite hack?
|
|
// if("devices", "WINFAX", "WINFAX,COMx:") we need to avoid the call to
|
|
// InstallWOWFaxPrinter() at this time -- the install program hasn't
|
|
// copied the driver to the hard drive yet!! This causes loadLibrary
|
|
// of WinFax.drv to fail when the spooler tries to callback into it.
|
|
// We also don't want this particular call to WriteProfileString to
|
|
// really be written to the registry -- we let the later call to
|
|
// AddPrinter take care of all the registration stuff.
|
|
if(!WOW32_strcmp(szKey, szWINFAX) &&
|
|
!WOW32_strncmp(szString, szWINFAX, 6) &&
|
|
(szString[6] == ',')) {
|
|
|
|
VPVOID vpPathName;
|
|
PSZ pszPathName;
|
|
char szFileName[32];
|
|
|
|
// get the install program file name
|
|
// be sure allocation size matches stackfree16() size below
|
|
if(vpPathName = stackalloc16(MAX_PATH)) {
|
|
GetModuleFileName16(CURRENTPTD()->hMod16, vpPathName, MAX_PATH);
|
|
GETVDMPTR(vpPathName, MAX_PATH, pszPathName);
|
|
_splitpath(pszPathName,NULL,NULL,szFileName,NULL);
|
|
|
|
// WinFax Lite is "INSTALL", WinFax Pro 4.0 is "SETUP"
|
|
if(!WOW32_stricmp(szINSTALL, szFileName)) {
|
|
|
|
strcpy(szWINFAXCOMx, szString); // save the port string
|
|
gbWinFaxHack = TRUE; // enable the hack
|
|
Result = TRUE;
|
|
stackfree16(vpPathName, MAX_PATH);
|
|
goto Done; // skip the call to InstallWowFaxPrinter
|
|
}
|
|
// No hack needed for WinFax Pro 4.0, the driver is copied
|
|
// to the hard disk long before they update win.ini
|
|
else {
|
|
stackfree16(vpPathName, MAX_PATH);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!InstallWowFaxPrinter(szSection, szKey, szString)) {
|
|
WOW32ASSERTMSG(FALSE, "Install of generic fax printer failed.\n");
|
|
}
|
|
Result = TRUE;
|
|
}
|
|
|
|
Done:
|
|
return Result;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL IsFaxPrinterSupportedDevice(PSZ pszDevice)
|
|
{
|
|
UINT i, iNotFound;
|
|
|
|
// Trying to read from a fax printer entry?
|
|
LOGDEBUG(0,("IsFaxPrinterSupportedDevice, Device = %s\n", pszDevice));
|
|
|
|
//If initialization of SupFaxDrv failed with memory exhaust
|
|
//which isn't very likely to happen
|
|
|
|
if (!SupFaxDrv ) {
|
|
return FALSE;
|
|
}
|
|
|
|
// Is it one of the fax drivers we recognize?
|
|
for (i = 0; i < uNumSupFaxDrv; i++) {
|
|
iNotFound = WOW32_stricmp(pszDevice, SupFaxDrv[i]);
|
|
if (iNotFound > 0) continue;
|
|
if (iNotFound == 0) {
|
|
LOGDEBUG(0,("IsFaxPrinterSupportedDevice returns TRUE\n"));
|
|
return(TRUE);
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
DWORD GetFaxPrinterProfileString(PSZ szSection, PSZ szKey, PSZ szDefault, PSZ szRetBuf, DWORD cbBufSize)
|
|
{
|
|
DWORD len;
|
|
char szTmp[MAX_PATH];
|
|
HKEY hKey = 0;
|
|
DWORD dwType;
|
|
|
|
// Read the entry from the shadow entries in registry.
|
|
strcpy(szTmp, "Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\\");
|
|
WOW32ASSERT(strlen(szTmp) < MAX_PATH);
|
|
|
|
len = strlen(szTmp);
|
|
len += strlen(szSection);
|
|
len ++; // account for '\0'
|
|
|
|
if(len <= sizeof(szTmp)) {
|
|
strcat(szTmp, szSection);
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szTmp, 0, KEY_READ, &hKey ) == ERROR_SUCCESS) {
|
|
if (RegQueryValueEx(hKey, szKey, 0, &dwType, szRetBuf, &cbBufSize) == ERROR_SUCCESS) {
|
|
RegCloseKey(hKey);
|
|
return(cbBufSize);
|
|
}
|
|
}
|
|
|
|
if (hKey) {
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
WOW32WARNMSG(FALSE, ("GetFaxPrinterProfileString Failed. Section = %s, Key = %s\n", szSection, szKey));
|
|
if(szDefault && szRetBuf) {
|
|
|
|
len = strlen(szDefault);
|
|
if(len < cbBufSize) {
|
|
strncpy(szRetBuf, szDefault, cbBufSize);
|
|
szRetBuf[cbBufSize-1] = '\0';
|
|
return(len);
|
|
}
|
|
}
|
|
WOW32ASSERT(FALSE);
|
|
return(0);
|
|
}
|
|
|