able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/fax/print/faxprint/faxui/wizard.c

4454 lines
116 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
wizard.c
Abstract:
Send fax wizard dialogs
Environment:
Fax driver user interface
Revision History:
01/19/96 -davidx-
Created it.
mm/dd/yy -author-
description
--*/
#include "faxui.h"
#include "tapiutil.h"
#include "prtcovpg.h"
#include "tiff.h"
#include "cwabutil.h"
#include <shellapi.h>
#include <imm.h>
#ifdef FAX_SCAN_ENABLED
#define TWRESMIN 0
#define TWRESMAX 1
#define TWRESSCAL 2
#define TWRESCUR 3
#define TWRESDEFAULT 4
#define TWRESCLOSEST 5
#define AUTOSCANPREV 0
#define AUTOSCANFINAL 1
#define CUSTOMSCAN 2
#define CANCELLED 3
#define FINALCANCELLED 4
#define AUTOSCANSHEETFED 5
#define CUSTOMDIGITALCAMERA 6
#define DCCANCELLED 7
#define Align(p, x) (((x) & ((p)-1)) ? (((x) & ~((p)-1)) + p) : (x))
#define WM_PAGE_COMPLETE (WM_USER+1000)
#define NUM_IFD_ENTRIES 18
#define IFD_SUBFILETYPE 0 // 254
#define IFD_IMAGEWIDTH 1 // 256
#define IFD_IMAGELENGTH 2 // 257
#define IFD_BITSPERSAMPLE 3 // 258
#define IFD_COMPRESSION 4 // 259
#define IFD_PHOTOMETRIC 5 // 262
#define IFD_FILLORDER 6 // 266
#define IFD_STRIPOFFSETS 7 // 273
#define IFD_SAMPLESPERPIXEL 8 // 277
#define IFD_ROWSPERSTRIP 9 // 278
#define IFD_STRIPBYTECOUNTS 10 // 279
#define IFD_XRESOLUTION 11 // 281
#define IFD_YRESOLUTION 12 // 282
#define IFD_GROUP3OPTIONS 13 // 292
#define IFD_RESOLUTIONUNIT 14 // 296
#define IFD_PAGENUMBER 15 // 297
#define IFD_SOFTWARE 16 // 305
#define IFD_CLEANFAXDATA 17 // 327
typedef struct {
WORD wIFDEntries;
TIFF_TAG ifd[NUM_IFD_ENTRIES];
DWORD nextIFDOffset;
DWORD filler;
DWORD xresNum;
DWORD xresDenom;
DWORD yresNum;
DWORD yresDenom;
CHAR software[32];
} FAXIFD, *PFAXIFD;
#define SoftwareStr "Windows NT Fax Driver"
#define DRIVER_SIGNATURE 'xafD'
FAXIFD FaxIFDTemplate = {
NUM_IFD_ENTRIES,
{
{ TIFFTAG_SUBFILETYPE, TIFF_LONG, 1, 0 },
{ TIFFTAG_IMAGEWIDTH, TIFF_LONG, 1, 0 },
{ TIFFTAG_IMAGELENGTH, TIFF_LONG, 1, 0 },
{ TIFFTAG_BITSPERSAMPLE, TIFF_SHORT, 1, 1 },
{ TIFFTAG_COMPRESSION, TIFF_SHORT, 1, COMPRESSION_NONE },
{ TIFFTAG_PHOTOMETRIC, TIFF_SHORT, 1, PHOTOMETRIC_MINISWHITE },
{ TIFFTAG_FILLORDER, TIFF_SHORT, 1, FILLORDER_MSB2LSB },
{ TIFFTAG_STRIPOFFSETS, TIFF_LONG, 1, 0 },
{ TIFFTAG_SAMPLESPERPIXEL, TIFF_SHORT, 1, 1 },
{ TIFFTAG_ROWSPERSTRIP, TIFF_LONG, 1, 0 },
{ TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG, 1, 0 },
{ TIFFTAG_XRESOLUTION, TIFF_RATIONAL, 1, 0 },
{ TIFFTAG_YRESOLUTION, TIFF_RATIONAL, 1, 0 },
{ TIFFTAG_GROUP3OPTIONS, TIFF_LONG, 1, 0 },
{ TIFFTAG_RESOLUTIONUNIT, TIFF_SHORT, 1, RESUNIT_INCH },
{ TIFFTAG_PAGENUMBER, TIFF_SHORT, 2, 0 },
{ TIFFTAG_SOFTWARE, TIFF_ASCII, sizeof(SoftwareStr)+1, 0 },
{ TIFFTAG_CLEANFAXDATA, TIFF_SHORT, 1, 0 },
},
0,
DRIVER_SIGNATURE,
0,
1,
0,
1,
SoftwareStr
};
#endif
VOID
FillInPropertyPage(
PROPSHEETPAGE *psp,
INT dlgId,
DLGPROC dlgProc,
PUSERMEM pUserMem,
INT TitleId,
INT SubTitleId
)
/*++
Routine Description:
Fill out a PROPSHEETPAGE structure with the supplied parameters
Arguments:
psp - Points to the PROPSHEETPAGE structure to be filled out
dlgId - Dialog template resource ID
dlgProc - Dialog procedure
pUserMem - Pointer to the user mode memory structure
TitleId - resource id for wizard subtitle
SubTitleId - resource id for wizard subtitle
Return Value:
NONE
--*/
{
LPTSTR WizardTitle;
LPTSTR WizardSubTitle;
psp->dwSize = sizeof(PROPSHEETPAGE);
//
// Don't show titles if it's the first or last page
//
if (TitleId==0 && SubTitleId ==0) {
psp->dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;;
} else {
psp->dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
}
psp->hInstance = ghInstance;
psp->pszTemplate = MAKEINTRESOURCE(dlgId);
psp->pfnDlgProc = dlgProc;
psp->lParam = (LPARAM) pUserMem;
WizardTitle = MemAlloc(200* sizeof(TCHAR) );
WizardSubTitle = MemAlloc(200* sizeof(TCHAR) );
LoadString(ghInstance,TitleId,WizardTitle,200);
LoadString(ghInstance,SubTitleId,WizardSubTitle,200);
psp->pszHeaderTitle = WizardTitle;
psp->pszHeaderSubTitle = WizardSubTitle;
}
LPTSTR
GetTextStringValue(
HWND hwnd
)
/*++
Routine Description:
Retrieve the string value in a text field
Arguments:
hwnd - Handle to a text window
Return Value:
Pointer to a string representing the current content of the text field
NULL if the text field is empty or if there is an error
--*/
{
INT length;
LPTSTR pString;
//
// Find out how many characters are in the text field
// and allocate enough memory to hold the string value
//
if ((length = GetWindowTextLength(hwnd)) == 0 ||
(pString = MemAlloc(sizeof(TCHAR) * (length + 1))) == NULL)
{
return NULL;
}
//
// Actually retrieve the string value
//
if (GetWindowText(hwnd, pString, length + 1) == 0) {
MemFree(pString);
return NULL;
}
return pString;
}
VOID
LimitTextFields(
HWND hDlg,
INT *pLimitInfo
)
/*++
Routine Description:
Limit the maximum length for a number of text fields
Arguments:
hDlg - Specifies the handle to the dialog window
pLimitInfo - Array of text field control IDs and their maximum length
ID for the 1st text field, maximum length for the 1st text field
ID for the 2nd text field, maximum length for the 2nd text field
...
0
Note: The maximum length counts the NUL-terminator.
Return Value:
NONE
--*/
{
while (*pLimitInfo != 0) {
SendDlgItemMessage(hDlg, pLimitInfo[0], EM_SETLIMITTEXT, pLimitInfo[1]-1, 0);
pLimitInfo += 2;
}
}
VOID
SaveLastRecipientInfo(
LPTSTR pName,
LPTSTR pAreaCode,
LPTSTR pPhoneNumber,
DWORD countryId,
BOOL useDialingRules
)
/*++
Routine Description:
Save the information about the last recipient in the registry
Arguments:
pName - Specifies the recipient name
pAreaCode - Specifies the recipient area code
pPhoneNumber - Specifies the recipient phone number
countryId - Specifies the recipient country ID
useDialingRules - Whether use dialing rules is checked
Return Value:
NONE
--*/
{
HKEY hRegKey;
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE)) {
SetRegistryString(hRegKey, REGVAL_LAST_RECNAME, pName);
SetRegistryString(hRegKey, REGVAL_LAST_RECNUMBER, pPhoneNumber);
SetRegistryDword(hRegKey, REGVAL_USE_DIALING_RULES, useDialingRules);
if (useDialingRules) {
SetRegistryString(hRegKey, REGVAL_LAST_RECAREACODE, pAreaCode);
SetRegistryDword(hRegKey, REGVAL_LAST_COUNTRYID, countryId);
}
RegCloseKey(hRegKey);
}
}
VOID
RestoreLastRecipientInfo(
HWND hDlg,
PDWORD pCountryId
)
/*++
Routine Description:
Restore the information about the last recipient from the registry
Arguments:
hDlg - Specifies a handle to the fax recipient wizard page
pCountryId - Returns the last selected country ID
Return Value:
NONE
--*/
{
HKEY hRegKey;
LPTSTR buffer;
//TCHAR buffer[MAX_STRING_LEN];
*pCountryId = GetDefaultCountryID();
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READONLY)) {
buffer = GetRegistryString(hRegKey, REGVAL_LAST_RECNAME, TEXT(""));
if (buffer) {
SetDlgItemText(hDlg, IDC_CHOOSE_NAME_EDIT, buffer);
MemFree(buffer);
}
buffer = GetRegistryString(hRegKey, REGVAL_LAST_RECAREACODE, TEXT(""));
if (buffer) {
SetDlgItemText(hDlg, IDC_CHOOSE_AREA_CODE_EDIT, buffer);
MemFree(buffer);
}
buffer = GetRegistryString(hRegKey, REGVAL_LAST_RECNUMBER, TEXT(""));
if (buffer) {
SetDlgItemText(hDlg, IDC_CHOOSE_NUMBER_EDIT, buffer);
MemFree(buffer);
}
CheckDlgButton(hDlg,
IDC_USE_DIALING_RULES,
GetRegistryDword(hRegKey, REGVAL_USE_DIALING_RULES));
*pCountryId = GetRegistryDword(hRegKey, REGVAL_LAST_COUNTRYID);
RegCloseKey(hRegKey);
}
}
PUSERMEM
CommonWizardProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam,
DWORD buttonFlags
)
/*++
Routine Description:
Common procedure for handling wizard pages:
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
buttonFlags - Indicate which buttons should be enabled
Return Value:
NULL - Message is processed and the dialog procedure should return FALSE
Otherwise - Message is not completely processed and
The return value is a pointer to the user mode memory structure
--*/
{
PUSERMEM pUserMem;
switch (message) {
case WM_INITDIALOG:
//
// Store the pointer to user mode memory structure
//
lParam = ((PROPSHEETPAGE *) lParam)->lParam;
pUserMem = (PUSERMEM) lParam;
Assert(ValidPDEVUserMem(pUserMem));
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
break;
case WM_NOTIFY:
pUserMem = (PUSERMEM) GetWindowLongPtr(hDlg, DWLP_USER);
Assert(ValidPDEVUserMem(pUserMem));
switch (((NMHDR *) lParam)->code) {
case PSN_WIZFINISH:
pUserMem->finishPressed = TRUE;
break;
case PSN_SETACTIVE:
PropSheet_SetWizButtons(GetParent(hDlg), buttonFlags);
break;
case PSN_RESET:
case PSN_WIZBACK:
case PSN_WIZNEXT:
case PSN_KILLACTIVE:
case LVN_KEYDOWN:
break;
default:
return NULL;
}
break;
case WM_COMMAND:
pUserMem = (PUSERMEM) GetWindowLongPtr(hDlg, DWLP_USER);
Assert(ValidPDEVUserMem(pUserMem));
break;
default:
return NULL;
}
return pUserMem;
}
/*
* IsStringACSII
*
* Purpose:
* This function determines whether a string contains ONLY ASCII characters.
*
* Arguments:
* ptszString - points to the string to test.
*
* Returns:
* TRUE - indicates that the string contains only ASCII characters.
*
*/
BOOL IsStringASCII( LPTSTR ptszString )
{
BOOL fReturnValue = (BOOL) TRUE;
// Determine whether the contents of the edit control are legal.
while ( (*ptszString != (TCHAR) TEXT('\0')) &&
( fReturnValue == (BOOL) TRUE) )
{
if ( (*ptszString < (TCHAR) 0x0020) || (*ptszString > (TCHAR) MAXCHAR) )
{
// The string contains at least one non-ASCII character.
fReturnValue = (BOOL) FALSE;
}
ptszString = _tcsinc( ptszString );
} // end of while loop
return ( fReturnValue );
}
INT
GetCurrentRecipient(
HWND hDlg,
PRECIPIENT *ppRecipient
)
/*++
Routine Description:
Extract the current recipient information in the dialog
Arguments:
hDlg - Handle to the fax recipient wizard page
ppRecipient - Buffer to receive a pointer to a newly created RECIPIENT structure
NULL if caller is only interested in the validity of recipient info
Return Value:
= 0 if successful
> 0 error message string resource ID otherwise
< 0 other error conditions
--*/
{
LPLINECOUNTRYENTRY pLineCountryEntry;
DWORD countryId, countryCode;
PRECIPIENT pRecipient;
TCHAR areaCode[MAX_RECIPIENT_NUMBER];
TCHAR phoneNumber[MAX_RECIPIENT_NUMBER];
INT nameLen, areaCodeLen, numberLen;
LPTSTR pName, pAddress;
INT useDialingRules;
//
// Default value in case of error
//
if (ppRecipient)
*ppRecipient = NULL;
//
// Find the current country code
//
countryCode = 0;
pLineCountryEntry = NULL;
countryId = GetCountryListBoxSel(GetDlgItem(hDlg, IDC_CHOOSE_COUNTRY_COMBO));
useDialingRules = IsDlgButtonChecked(hDlg, IDC_USE_DIALING_RULES);
if ((useDialingRules == BST_CHECKED) &&
(pLineCountryEntry = FindCountry(countryId)))
{
countryCode = pLineCountryEntry->dwCountryCode;
}
nameLen = GetWindowTextLength(GetDlgItem(hDlg, IDC_CHOOSE_NAME_EDIT));
areaCodeLen = GetWindowTextLength(GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT));
numberLen = GetWindowTextLength(GetDlgItem(hDlg, IDC_CHOOSE_NUMBER_EDIT));
//
// Validate the edit text fields
//
if (nameLen <= 0)
return IDS_BAD_RECIPIENT_NAME;
if (numberLen <= 0 || numberLen >= MAX_RECIPIENT_NUMBER)
return IDS_BAD_RECIPIENT_NUMBER;
if ((areaCodeLen <= 0 && AreaCodeRules(pLineCountryEntry) == AREACODE_REQUIRED) ||
(areaCodeLen >= MAX_RECIPIENT_NUMBER))
{
return IDS_BAD_RECIPIENT_AREACODE;
}
if (ppRecipient == NULL)
return 0;
//
// Calculate the amount of memory space we need and allocate it
//
pRecipient = MemAllocZ(sizeof(RECIPIENT));
pName = MemAllocZ((nameLen + 1) * sizeof(TCHAR));
pAddress = MemAllocZ((areaCodeLen + numberLen + 20) * sizeof(TCHAR));
if (!pRecipient || !pName || !pAddress) {
MemFree(pRecipient);
MemFree(pName);
MemFree(pAddress);
return -1;
}
*ppRecipient = pRecipient;
pRecipient->pName = pName;
pRecipient->pAddress = pAddress;
//
// Get the recipient's name
//
GetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_NAME_EDIT), pName, nameLen+1);
//
// Get the recipient's number
// AddressType
// [+ CountryCode Space]
// [( AreaCode ) Space]
// SubscriberNumber
//
GetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT), areaCode, MAX_RECIPIENT_NUMBER);
if ( IsStringASCII( areaCode ) == (BOOL) FALSE )
{
return ( (INT) IDS_ERROR_AREA_CODE );
}
GetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_NUMBER_EDIT), phoneNumber, MAX_RECIPIENT_NUMBER);
if ( IsStringASCII( phoneNumber ) == (BOOL) FALSE )
{
return ( (INT) IDS_ERROR_FAX_NUMBER );
}
AssemblePhoneNumber(pAddress,
countryCode,
areaCode,
phoneNumber);
//
// Save the information about the last recipient as a convenience
//
SaveLastRecipientInfo(pName,
areaCode,
phoneNumber,
countryId,
useDialingRules == BST_CHECKED);
return 0;
}
VOID
InitRecipientListView(
HWND hwndLV
)
/*++
Routine Description:
Initialize the recipient list view on the first page of Send Fax wizard
Arguments:
hwndLV - Window handle to the list view control
Return Value:
NONE
--*/
{
LV_COLUMN lvc;
RECT rect;
TCHAR buffer[MAX_TITLE_LEN];
if (hwndLV == NULL)
return;
GetClientRect(hwndLV, &rect);
ZeroMemory(&lvc, sizeof(lvc));
lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
lvc.fmt = LVCFMT_LEFT;
lvc.pszText = buffer;
lvc.cx = (rect.right - rect.left) / 2;
lvc.iSubItem = 0;
LoadString(ghInstance, IDS_COLUMN_RECIPIENT_NAME, buffer, MAX_TITLE_LEN);
if (ListView_InsertColumn(hwndLV, 0, &lvc) == -1)
Error(("ListView_InsertColumn failed\n"));
lvc.cx -= GetSystemMetrics(SM_CXVSCROLL);
lvc.iSubItem = 1;
LoadString(ghInstance, IDS_COLUMN_RECIPIENT_NUMBER, buffer, MAX_TITLE_LEN);
if (ListView_InsertColumn(hwndLV, 1, &lvc) == -1)
Error(("ListView_InsertColumn failed\n"));
}
BOOL
InsertRecipientListItem(
HWND hwndLV,
PRECIPIENT pRecipient
)
/*++
Routine Description:
Insert an item into the recipient list view
Arguments:
hwndLV - Window handle to the recipient list view
pRecipient - Specifies the recipient to be inserted
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
LV_ITEM lvi;
INT index;
ZeroMemory(&lvi, sizeof(lvi));
lvi.mask = LVIF_PARAM | LVIF_TEXT | LVIF_STATE;
lvi.lParam = (LPARAM) pRecipient;
lvi.pszText = pRecipient->pName;
lvi.state = lvi.stateMask = LVIS_SELECTED;
if ((index = ListView_InsertItem(hwndLV, &lvi)) == -1) {
Error(("ListView_InsertItem failed\n"));
return FALSE;
}
lvi.mask = LVIF_TEXT;
lvi.iItem = index;
lvi.iSubItem = 1;
lvi.pszText = pRecipient->pAddress;
if (! ListView_SetItem(hwndLV, &lvi))
Error(("ListView_SetItem failed\n"));
return TRUE;
}
PRECIPIENT
GetRecipientListItem(
HWND hwndLV,
INT index
)
/*++
Routine Description:
Retrieve the recipient associated with an item in the list view
Arguments:
hwndLV - Window handle to the recipient list view
index - Specifies the index of the interested item
Return Value:
Pointer to the requested recipient information
NULL if there is an error
--*/
{
LV_ITEM lvi;
ZeroMemory(&lvi, sizeof(lvi));
lvi.mask = LVIF_PARAM;
lvi.iItem = index;
if (ListView_GetItem(hwndLV, &lvi))
return (PRECIPIENT) lvi.lParam;
Error(("ListView_GetItem failed\n"));
return NULL;
}
INT
AddRecipient(
HWND hDlg,
PUSERMEM pUserMem
)
/*++
Routine Description:
Add the current recipient information entered by the user
into the recipient list
Arguments:
hDlg - Handle to the fax recipient wizard page
pUserMem - Points to user mode memory structure
Return Value:
Same meaning as return value from GetCurrentRecipient, i.e.
= 0 if successful
> 0 error message string resource ID otherwise
< 0 other error conditions
--*/
{
PRECIPIENT pRecipient;
INT errId;
HWND hwndLV;
//
// Collect information about the current recipient
//
if ((errId = GetCurrentRecipient(hDlg, &pRecipient)) != 0)
return errId;
//
// Insert the current recipient to the recipient list
//
if ((hwndLV = GetDlgItem(hDlg, IDC_CHOOSE_RECIPIENT_LIST)) &&
InsertRecipientListItem(hwndLV, pRecipient))
{
errId = 0;
pRecipient->pNext = pUserMem->pRecipients;
pUserMem->pRecipients = pRecipient;
//
// Clear the name and number fields after successfully
// adding the recipient to the internal list
//
SetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_NAME_EDIT), TEXT(""));
SetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT), TEXT(""));
SetWindowText(GetDlgItem(hDlg, IDC_CHOOSE_NUMBER_EDIT), TEXT(""));
//CheckDlgButton(hDlg, IDC_USE_DIALING_RULES, FALSE);
} else {
FreeRecipient(pRecipient);
errId = -1;
}
return errId;
}
BOOL
DoAddressBook(
HWND hDlg,
PUSERMEM pUserMem
)
/*++
Routine Description:
Display the MAPI address book dialog
Arguments:
hDlg - Handle to the fax recipient wizard page
pUserMem - Points to user mode memory structure
Return Value:
TRUE if successful, FALSE otherwise
--*/
{
HWND hwndLV;
BOOL result;
PRECIPIENT pNewRecip = NULL;
PRECIPIENT tmpRecip;
if (! pUserMem->lpWabInit &&
! (pUserMem->lpWabInit = InitializeWAB(ghInstance)))
{
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_ADDRBOOK), FALSE);
return FALSE;
}
//
// Get a handle to the recipient list window
//
if (! (hwndLV = GetDlgItem(hDlg, IDC_CHOOSE_RECIPIENT_LIST)))
return FALSE;
//
// Add current recipient to the list if necessary
//
AddRecipient(hDlg, pUserMem);
result = CallWabAddress(
hDlg,
pUserMem,
&pNewRecip
);
FreeRecipientList(pUserMem);
pUserMem->pRecipients = pNewRecip;
ListView_DeleteAllItems(hwndLV);
for (tmpRecip = pNewRecip; tmpRecip; tmpRecip = tmpRecip->pNext) {
InsertRecipientListItem(hwndLV, tmpRecip);
}
if (!result) {
DisplayMessageDialog( hDlg, MB_OK, 0, IDS_BAD_ADDRESS_TYPE );
}
return result;
}
BOOL
ValidateRecipients(
HWND hDlg,
PUSERMEM pUserMem
)
/*++
Routine Description:
Validate the list of fax recipients entered by the user
Arguments:
hDlg - Handle to the fax recipient wizard page
pUserMem - Points to user mode memory structure
Return Value:
TRUE if successful, FALSE otherwise
--*/
{
INT errId;
//
// Add current recipient to the list if necessary
//
errId = AddRecipient(hDlg, pUserMem);
//
// There must be at least one recipient
//
if (pUserMem->pRecipients)
return TRUE;
//
// Display an error message
//
if (errId > 0)
DisplayMessageDialog(hDlg, 0, 0, errId);
else
MessageBeep(MB_OK);
//
// Set current focus to the appropriate text field as a convenience
//
switch (errId) {
case IDS_ERROR_FAX_NUMBER:
SetDlgItemText(hDlg, IDC_CHOOSE_NUMBER_EDIT, L"");
case IDS_BAD_RECIPIENT_NUMBER:
errId = IDC_CHOOSE_NUMBER_EDIT;
break;
case IDS_ERROR_AREA_CODE:
SetDlgItemText(hDlg, IDC_CHOOSE_AREA_CODE_EDIT, L"");
case IDS_BAD_RECIPIENT_AREACODE:
errId = IDC_CHOOSE_AREA_CODE_EDIT;
break;
case IDS_BAD_RECIPIENT_NAME:
default:
errId = IDC_CHOOSE_NAME_EDIT;
break;
}
SetFocus(GetDlgItem(hDlg, errId));
return FALSE;
}
PRECIPIENT *
FindRecipient(
PUSERMEM pUserMem,
PRECIPIENT pRecipient
)
/*++
Routine Description:
Check if the specified recipient is in the list of recipients
Arguments:
pUserMem - Points to user mode memory structure
pRecipient - Specifies the recipient to be found
Return Value:
Address of the link pointer to the specified recipient
NULL if the specified recipient is not found
--*/
{
PRECIPIENT pCurrent, *ppPrevNext;
//
// Search for the specified recipient in the list
//
ppPrevNext = (PRECIPIENT *) &pUserMem->pRecipients;
pCurrent = pUserMem->pRecipients;
while (pCurrent && pCurrent != pRecipient) {
ppPrevNext = (PRECIPIENT *) &pCurrent->pNext;
pCurrent = pCurrent->pNext;
}
//
// Return the address of the link pointer to the specified recipient
// or NULL if the specified recipient is not found
//
return pCurrent ? ppPrevNext : NULL;
}
BOOL
RemoveRecipient(
HWND hDlg,
PUSERMEM pUserMem
)
/*++
Routine Description:
Remove the currently selected recipient from the recipient list
Arguments:
hDlg - Handle to the fax recipient wizard page
pUserMem - Points to user mode memory structure
Return Value:
TRUE if successful, FALSE otherwise
--*/
{
PRECIPIENT pRecipient, *ppPrevNext;
INT selIndex;
HWND hwndLV;
//
// Get the currently selected recipient, and
// Find the current recipient in the list, then
// Delete the current recipient and select the next one below it
//
if ((hwndLV = GetDlgItem(hDlg, IDC_CHOOSE_RECIPIENT_LIST)) &&
(selIndex = ListView_GetNextItem(hwndLV, -1, LVNI_ALL|LVNI_SELECTED)) != -1 &&
(pRecipient = GetRecipientListItem(hwndLV, selIndex)) &&
(ppPrevNext = FindRecipient(pUserMem, pRecipient)) &&
ListView_DeleteItem(hwndLV, selIndex))
{
ListView_SetItemState(hwndLV,
selIndex,
LVIS_SELECTED|LVIS_FOCUSED,
LVIS_SELECTED|LVIS_FOCUSED);
//
// Delete the recipient from the internal list
//
*ppPrevNext = pRecipient->pNext;
FreeRecipient(pRecipient);
return TRUE;
}
MessageBeep(MB_ICONHAND);
return FALSE;
}
VOID
LocationListInit(
HWND hDlg,
PUSERMEM pUserMem
)
/*++
Routine Description:
Initialize the list of TAPI locations
Arguments:
hDlg - Handle to "Compose New Fax" wizard window
pUserMem - Pointer to user mode memory structure
Return Value:
NONE
--*/
{
HWND hwndList;
DWORD index;
LRESULT listIdx;
LPTSTR pLocationName, pSelectedName = NULL;
LPLINETRANSLATECAPS pTranslateCaps = NULL;
LPLINELOCATIONENTRY pLocationEntry;
//
// For remote printers, hide the location combo-box
//
if (! pUserMem->isLocalPrinter) {
ShowWindow(GetDlgItem(hDlg, IDC_LOCATION_PROMPT), SW_HIDE);
ShowWindow(GetDlgItem(hDlg, IDC_LOCATION_LIST), SW_HIDE);
ShowWindow(GetDlgItem(hDlg, IDC_TAPI_PROPS), SW_HIDE);
return;
}
//
// Get the list of locations from TAPI and use it
// to initialize the location combo-box.
//
if ((hwndList = GetDlgItem(hDlg, IDC_LOCATION_LIST)) &&
(pTranslateCaps = GetTapiLocationInfo(hDlg)))
{
SendMessage(hwndList, CB_RESETCONTENT, 0, 0);
pLocationEntry = (LPLINELOCATIONENTRY)
((PBYTE) pTranslateCaps + pTranslateCaps->dwLocationListOffset);
for (index=0; index < pTranslateCaps->dwNumLocations; index++) {
pLocationName = (LPTSTR)
((PBYTE) pTranslateCaps + pLocationEntry->dwLocationNameOffset);
if (pLocationEntry->dwPermanentLocationID == pTranslateCaps->dwCurrentLocationID)
pSelectedName = pLocationName;
listIdx = SendMessage(hwndList, CB_INSERTSTRING, 0, (LPARAM) pLocationName);
if (listIdx != CB_ERR) {
SendMessage(hwndList,
CB_SETITEMDATA,
listIdx,
pLocationEntry->dwPermanentLocationID);
}
pLocationEntry++;
}
if (pSelectedName != NULL)
SendMessage(hwndList, CB_SELECTSTRING, (WPARAM) -1, (LPARAM) pSelectedName);
}
MemFree(pTranslateCaps);
}
VOID
LocationListSelChange(
HWND hDlg
)
/*++
Routine Description:
Change the default TAPI location
Arguments:
hDlg - Handle to "Compose New Fax" wizard window
Return Value:
NONE
--*/
{
HWND hwndList;
LRESULT selIndex;
DWORD locationID;
if ((hwndList = GetDlgItem(hDlg, IDC_LOCATION_LIST)) &&
(selIndex = SendMessage(hwndList, CB_GETCURSEL, 0, 0)) != CB_ERR &&
(locationID = (DWORD)SendMessage(hwndList, CB_GETITEMDATA, selIndex, 0)) != CB_ERR)
{
SetCurrentLocation(locationID);
}
}
VOID
UpdateCountryCombobox(
HWND hDlg,
DWORD countryId
)
/*++
Routine Description:
Update the country/region combobox
Arguments:
hDlg - Handle to recipient wizard page
countryId - country id
Return Value:
NONE
--*/
{
HWND hwndUseDialingRultes = GetDlgItem(hDlg, IDC_USE_DIALING_RULES);
HWND hwndDialingLocation = GetDlgItem(hDlg, IDC_LOCATION_LIST);
HWND hwndDialingLocationStatic = GetDlgItem(hDlg, IDC_LOCATION_PROMPT);
HWND hwndLocation = GetDlgItem(hDlg, IDC_CHOOSE_COUNTRY_COMBO);
HWND hwndLocationStatic = GetDlgItem(hDlg, IDC_STATIC_CHOOSE_COUNTRY_COMBO);
HWND hwndProp = GetDlgItem(hDlg, IDC_TAPI_PROPS);
static int OldCountryCode = 0;
if (IsDlgButtonChecked(hDlg, IDC_USE_DIALING_RULES) != BST_CHECKED) {
//
// user unchecked use dialing rules
// remember the old country code and area code and clear out the UI
//
OldCountryCode = GetCountryListBoxSel(hwndLocation);
if (OldCountryCode == -1) {
OldCountryCode = countryId != -1 ? countryId : 0;
}
SendMessage(hwndLocation, CB_RESETCONTENT, FALSE, 0);
EnableWindow(hwndLocation, FALSE);
EnableWindow(hwndLocationStatic, FALSE);
EnableWindow(hwndDialingLocation, FALSE);
EnableWindow(hwndDialingLocationStatic, FALSE);
EnableWindow(hwndProp, FALSE);
}
else {
//
// user checked use dialing rules
// enable country combo, restore settings
//
EnableWindow(hwndLocation, TRUE);
EnableWindow(hwndLocationStatic, TRUE);
InitCountryListBox(GetDlgItem(hDlg, IDC_CHOOSE_COUNTRY_COMBO),
GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT),
countryId != -1 ? countryId : OldCountryCode);
EnableWindow(hwndDialingLocation, TRUE);
EnableWindow(hwndDialingLocationStatic, TRUE);
EnableWindow(hwndProp, TRUE);
}
SelChangeCountryListBox(GetDlgItem(hDlg, IDC_CHOOSE_COUNTRY_COMBO),
GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT));
}
INT_PTR
CALLBACK
firstdlgproc(
HWND hDlg,
UINT iMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch(iMsg) {
case WM_INITDIALOG:
CheckDlgButton(hDlg, IDC_EDIT_USERINFO_NOW, TRUE);
return TRUE;
case WM_COMMAND:
switch(LOWORD( wParam )) {
case IDOK:
if (IsDlgButtonChecked(hDlg, IDC_EDIT_USERINFO_NOW) == BST_CHECKED) {
EndDialog( hDlg, IDYES );
}
else {
EndDialog( hDlg, IDNO );
}
return TRUE;
}
break;
}
return FALSE;
}
INT_PTR
CALLBACK
firstprintdlgproc(
HWND hDlg,
UINT iMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch(iMsg) {
case WM_COMMAND:
EndDialog( hDlg, LOWORD( wParam ));
break;
}
return FALSE;
}
BOOL
DoFirstTimeInitStuff(
HWND hDlg,
BOOL bWelcomePage
)
{
BOOL bInitialized = TRUE;
HKEY hRegKey;
// TCHAR MessageBuffer[1024],TitleBuffer[100];
SHELLEXECUTEINFO shellExeInfo = {
sizeof(SHELLEXECUTEINFO),
SEE_MASK_NOCLOSEPROCESS,
hDlg,
L"Open",
L"rundll32",
L"shell32.dll,Control_RunDLL fax.cpl",
NULL,
SW_SHOWNORMAL,
};
TCHAR ScratchCmdLine[MAX_PATH];
PCTSTR PrinterCmdLine = TEXT("rundll32.exe printui.dll,PrintUIEntry /il");
STARTUPINFO si;
PROCESS_INFORMATION pi;
//
// print or fax first time?
//
if (bWelcomePage && !GetEnvironmentVariable(TEXT("NTFaxSendNote"), NULL, 0)) {
DWORD PrinterCount = 1;
PRINTER_INFO_4 *pPrinterInfo4;
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READONLY)) {
bInitialized = GetRegistryDword(hRegKey, REGVAL_PRINTER_INITIALIZED);
RegCloseKey(hRegKey);
}
if (bInitialized) {
return TRUE;
}
//
// if there is more than one printer don't confuse the user by asking
// to add a printer since one is already installed.
//
pPrinterInfo4 = MyEnumPrinters(
NULL,
4,
&PrinterCount,
PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS);
if (pPrinterInfo4) {
MemFree(pPrinterInfo4);
if (PrinterCount > 1) {
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE)) {
SetRegistryDword(hRegKey, REGVAL_PRINTER_INITIALIZED , 1);
RegCloseKey(hRegKey);
}
return(TRUE);
}
}
if (DialogBoxParam(ghInstance,
MAKEINTRESOURCE( IDD_WIZFIRSTTIMEPRINT ),
hDlg,
firstprintdlgproc,
(LPARAM)NULL) != IDOK) {
//
// if they said "print", then launch the add/remove printer wizard
//
ZeroMemory(&si,sizeof(si));
GetStartupInfo(&si);
lstrcpy(ScratchCmdLine,PrinterCmdLine);
if (CreateProcess(
NULL,
ScratchCmdLine,
NULL,
NULL,
FALSE,
DETACHED_PROCESS,
NULL,
NULL,
&si,
&pi
)) {
CloseHandle( pi.hThread );
CloseHandle( pi.hProcess );
}
return(FALSE);
} else {
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE)) {
SetRegistryDword(hRegKey, REGVAL_PRINTER_INITIALIZED , 1);
RegCloseKey(hRegKey);
}
return(TRUE);
}
} else if (!bWelcomePage) {
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READONLY)) {
bInitialized = GetRegistryDword(hRegKey, REGVAL_WIZARD_INITIALIZED);
RegCloseKey(hRegKey);
}
if (bInitialized) {
return TRUE;
}
//
// show the user a dialog
//
if (DialogBoxParam(ghInstance,
MAKEINTRESOURCE( IDD_WIZFIRSTTIME ),
hDlg,
firstdlgproc,
(LPARAM)NULL) == IDYES) {
//
// if they said yes, then launch the control panel applet
//
if (!ShellExecuteEx(&shellExeInfo)) {
DisplayMessageDialog(hDlg, 0, 0, IDS_ERR_CPL_LAUNCH);
return FALSE;
}
WaitForSingleObject( shellExeInfo.hProcess, INFINITE );
CloseHandle( shellExeInfo.hProcess ) ;
}
//
// set the reg key so this doesn't come up again
//
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE)) {
SetRegistryDword(hRegKey, REGVAL_WIZARD_INITIALIZED , 1 );
RegCloseKey(hRegKey);
}
}
return(TRUE);
}
INT_PTR
RecipientWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the first wizard page: selecting the fax recipient
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
#define UpdateAddToListButton() \
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_ADD), GetCurrentRecipient(hDlg, NULL) == 0)
#define UpdateRemoveFromListButton(__BoolFlag) \
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_REMOVE),__BoolFlag)
{
PUSERMEM pUserMem;
DWORD countryId;
INT cmd;
NMHDR *pNMHdr;
DWORD dwErrorCode;
HANDLE hEditControl;
TCHAR tszBuffer[MAX_STRING_LEN];
//
// Maximum length for various text fields
//
static INT textLimits[] = {
IDC_CHOOSE_NAME_EDIT, 64,
IDC_CHOOSE_AREA_CODE_EDIT, 11,
IDC_CHOOSE_NUMBER_EDIT, 51,
0
};
//
// Handle common messages shared by all wizard pages
//
if (! (pUserMem = CommonWizardProc(hDlg, message, wParam, lParam, PSWIZB_BACK | PSWIZB_NEXT)))
return FALSE;
switch (message) {
case WM_INITDIALOG:
//
// check if the user has run the wizard before so they can fill in the coverpage info.
//
DoFirstTimeInitStuff(hDlg, FALSE);
//
// tapi is asynchronously initialized, wait for it to finish spinning up.
//
WaitForSingleObject( pUserMem->hTapiEvent, INFINITE );
//
// Restore the last recipient information as a convenience
//
RestoreLastRecipientInfo(hDlg, &countryId);
//
// Initialize the list of countries
//
UpdateCountryCombobox(hDlg, countryId);
//
// Check if MAPI is installed - we need it for address book features
//
// if (! IsMapiAvailable())
// EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_ADDRBOOK), FALSE);
LimitTextFields(hDlg, textLimits);
//
// Initialize the recipient list view
//
InitRecipientListView(GetDlgItem(hDlg, IDC_CHOOSE_RECIPIENT_LIST));
//
// Initialize the location combo-box
//
LocationListInit(hDlg, pUserMem);
// Disable the IME for the area code edit control.
hEditControl = GetDlgItem( hDlg, IDC_CHOOSE_AREA_CODE_EDIT );
if ( hEditControl != (HWND) INVALID_HANDLE_VALUE )
{
ImmAssociateContext( hEditControl, (HIMC) NULL );
}
// Disable the IME for the fax phone number edit control.
hEditControl = GetDlgItem( hDlg, IDC_CHOOSE_NUMBER_EDIT );
if ( hEditControl != (HWND) INVALID_HANDLE_VALUE )
{
ImmAssociateContext( hEditControl, (HIMC) NULL );
}
break;
case WM_NOTIFY:
pNMHdr = (NMHDR *) lParam;
switch (pNMHdr->code) {
case LVN_KEYDOWN:
if (pNMHdr->hwndFrom == GetDlgItem(hDlg, IDC_CHOOSE_RECIPIENT_LIST) &&
((LV_KEYDOWN *) pNMHdr)->wVKey == VK_DELETE)
{
RemoveRecipient(hDlg, pUserMem);
}
break;
case PSN_WIZNEXT:
if (! ValidateRecipients(hDlg, pUserMem)) {
//
// Validate the list of recipients and prevent the user
// from advancing to the next page if there is a problem
//
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
return TRUE;
}
break;
case PSN_SETACTIVE:
//
// make sure the remove button has the correct state
//
UpdateRemoveFromListButton(pUserMem->pRecipients ? TRUE : FALSE);
break;
}
return FALSE;
case WM_COMMAND:
cmd = GET_WM_COMMAND_CMD(wParam, lParam);
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
case IDC_CHOOSE_COUNTRY_COMBO:
if (cmd == CBN_SELCHANGE) {
//
// Update the area code edit box if necessary
//
SelChangeCountryListBox(GetDlgItem(hDlg, IDC_CHOOSE_COUNTRY_COMBO),
GetDlgItem(hDlg, IDC_CHOOSE_AREA_CODE_EDIT));
UpdateAddToListButton();
}
break;
case IDC_CHOOSE_NAME_EDIT:
if (cmd == EN_CHANGE)
{
UpdateAddToListButton();
}
break;
case IDC_CHOOSE_AREA_CODE_EDIT:
if (cmd == EN_CHANGE)
{
UpdateAddToListButton();
// Look for DBCS in the edit control.
// Read the text from the edit control.
if ( GetDlgItemText( hDlg, IDC_CHOOSE_AREA_CODE_EDIT, tszBuffer,
MAX_STRING_LEN ) != 0 )
{
// Determine whether the contents of the edit control are legal.
if ( IsStringASCII( tszBuffer ) != (BOOL) TRUE )
{
LoadString(ghInstance, IDS_ERROR_AREA_CODE,
tszBuffer, MAX_STRING_LEN);
MessageBox( hDlg, tszBuffer, NULL,
(UINT) (MB_ICONSTOP | MB_OK) );
SetDlgItemText(hDlg, IDC_CHOOSE_AREA_CODE_EDIT, L"");
}
}
else
{
dwErrorCode = GetLastError();
if ( dwErrorCode != (DWORD) ERROR_SUCCESS )
{
// Error reading the edit control.
}
}
}
break;
case IDC_CHOOSE_NUMBER_EDIT:
if (cmd == EN_CHANGE)
{
UpdateAddToListButton();
// Look for DBCS in the edit control.
// Read the text from the edit control.
if ( GetDlgItemText( hDlg, IDC_CHOOSE_NUMBER_EDIT, tszBuffer,
MAX_STRING_LEN ) != 0 )
{
// Determine whether the contents of the edit control are legal.
if ( IsStringASCII( tszBuffer ) != (BOOL) TRUE )
{
LoadString(ghInstance, IDS_ERROR_FAX_NUMBER,
tszBuffer, MAX_STRING_LEN);
MessageBox( hDlg, tszBuffer, NULL,
(UINT) (MB_ICONSTOP | MB_OK) );
SetDlgItemText(hDlg, IDC_CHOOSE_NUMBER_EDIT, L"");
}
}
else
{
dwErrorCode = GetLastError();
if ( dwErrorCode != (DWORD) ERROR_SUCCESS )
{
// Error reading the edit control.
}
}
}
break;
case IDC_USE_DIALING_RULES:
UpdateCountryCombobox(hDlg, -1);
UpdateAddToListButton();
break;
case IDC_CHOOSE_ADDRBOOK:
DoAddressBook(hDlg, pUserMem);
UpdateRemoveFromListButton(pUserMem->pRecipients ? TRUE : FALSE);
break;
case IDC_TAPI_PROPS:
DoTapiProps(hDlg);
LocationListInit(hDlg, pUserMem);
break;
case IDC_LOCATION_LIST:
if (cmd == CBN_SELCHANGE)
LocationListSelChange(hDlg);
break;
case IDC_CHOOSE_ADD:
if ((cmd = AddRecipient(hDlg, pUserMem)) != 0) {
if (cmd > 0)
DisplayMessageDialog(hDlg, 0, 0, cmd);
else
MessageBeep(MB_OK);
} else {
SetFocus(GetDlgItem(hDlg, IDC_CHOOSE_NAME_EDIT));
//
// enable the remove button
//
UpdateRemoveFromListButton(TRUE);
}
break;
case IDC_CHOOSE_REMOVE:
RemoveRecipient(hDlg, pUserMem);
//
// disable the remove button if there are no more recipients
//
if (!pUserMem->pRecipients) {
UpdateRemoveFromListButton(FALSE);
}
}
break;
}
return TRUE;
}
VOID
ValidateSelectedCoverPage(
PUSERMEM pUserMem
)
/*++
Routine Description:
If a cover page is selected, then do the following:
if the cover page file is a link resolve it
check if the cover page file contains note/subject fields
Arguments:
pUserMem - Points to user mode memory structure
Return Value:
NONE
--*/
{
TCHAR filename[MAX_PATH];
COVDOCINFO covDocInfo;
DWORD ec;
if (ResolveShortcut(pUserMem->coverPage, filename))
_tcscpy(pUserMem->coverPage, filename);
Verbose(("Cover page selected: %ws\n", pUserMem->coverPage));
ec = PrintCoverPage(NULL, NULL, pUserMem->coverPage, &covDocInfo);
if (!ec) {
pUserMem->noteSubjectFlag = covDocInfo.Flags;
pUserMem->cpPaperSize = covDocInfo.PaperSize;
pUserMem->cpOrientation = covDocInfo.Orientation;
} else {
Error(("Cannot examine cover page file '%ws': %d\n",
pUserMem->coverPage,
ec));
}
}
INT_PTR
CoverPageWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the second wizard page:
selecting cover page and setting other fax options
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
{
static INT textLimits[] = {
IDC_CHOOSE_CP_SUBJECT, 256,
IDC_CHOOSE_CP_NOTE, 8192,
0
};
PUSERMEM pUserMem;
PDMPRIVATE pdmPrivate;
WORD cmdId;
HKEY hRegKey;
//
// Handle common messages shared by all wizard pages
//
if (! (pUserMem = CommonWizardProc(hDlg, message, wParam, lParam, PSWIZB_BACK|PSWIZB_NEXT)))
return FALSE;
//
// Handle anything specific to the current wizard page
//
pdmPrivate = &pUserMem->devmode.dmPrivate;
switch (message) {
case WM_INITDIALOG:
//
// Retrieve the most recently used cover page settings
//
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READONLY)) {
LPTSTR tmp;
pdmPrivate->sendCoverPage =
GetRegistryDword(hRegKey, REGVAL_SEND_COVERPG);
tmp = GetRegistryString(hRegKey, REGVAL_COVERPG, TEXT("") );
if (tmp) {
lstrcpy(pUserMem->coverPage, tmp );
MemFree(tmp);
}
RegCloseKey(hRegKey);
}
//
// Initialize the list of cover pages
//
WaitForSingleObject( pUserMem->hFaxSvcEvent, INFINITE );
if (pUserMem->pCPInfo = AllocCoverPageInfo(pUserMem->hPrinter, pUserMem->ServerCPOnly)) {
InitCoverPageList(pUserMem->pCPInfo,
GetDlgItem(hDlg, IDC_CHOOSE_CP_LIST),
pUserMem->coverPage);
}
//
// Indicate whether cover page should be sent
//
if (SendDlgItemMessage(hDlg, IDC_CHOOSE_CP_LIST, CB_GETCOUNT, 0, 0) <= 0) {
pdmPrivate->sendCoverPage = FALSE;
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_CHECK), FALSE);
}
CheckDlgButton(hDlg, IDC_CHOOSE_CP_CHECK, pdmPrivate->sendCoverPage);
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_LIST), pdmPrivate->sendCoverPage);
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_SUBJECT), pdmPrivate->sendCoverPage);
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_SUBJECT), pdmPrivate->sendCoverPage);
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_NOTE), pdmPrivate->sendCoverPage);
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_NOTE), pdmPrivate->sendCoverPage);
//
// make sure the user selects a coverpage if this is the fax send utility
//
if (GetEnvironmentVariable(TEXT("NTFaxSendNote"), NULL, 0)) {
pdmPrivate->sendCoverPage = TRUE;
CheckDlgButton(hDlg, IDC_CHOOSE_CP_CHECK, TRUE);
// hide the checkbox
MyHideWindow(GetDlgItem(hDlg,IDC_CHOOSE_CP_CHECK) );
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_LIST), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_SUBJECT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_SUBJECT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_NOTE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_NOTE), TRUE);
} else {
MyHideWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_NOCHECK) );
}
LimitTextFields(hDlg, textLimits);
break;
case WM_COMMAND:
switch (cmdId = GET_WM_COMMAND_ID(wParam, lParam)) {
case IDC_CHOOSE_CP_CHECK:
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP), IsDlgButtonChecked(hDlg, cmdId) );
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_LIST), IsDlgButtonChecked(hDlg, cmdId) );
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_SUBJECT), IsDlgButtonChecked(hDlg, cmdId) );
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_SUBJECT), IsDlgButtonChecked(hDlg, cmdId) );
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_CHOOSE_CP_NOTE), IsDlgButtonChecked(hDlg, cmdId) );
EnableWindow(GetDlgItem(hDlg, IDC_CHOOSE_CP_NOTE), IsDlgButtonChecked(hDlg, cmdId) );
break;
};
break;
case WM_NOTIFY:
if (((NMHDR *) lParam)->code == PSN_WIZNEXT) {
//
// Remember the cover page settings selected
//
pUserMem->noteSubjectFlag = 0;
pUserMem->cpPaperSize = 0;
pUserMem->cpOrientation = 0;
pdmPrivate->sendCoverPage = IsDlgButtonChecked(hDlg, IDC_CHOOSE_CP_CHECK);
GetSelectedCoverPage(pUserMem->pCPInfo,
GetDlgItem(hDlg, IDC_CHOOSE_CP_LIST),
pUserMem->coverPage);
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE)) {
SetRegistryDword(hRegKey, REGVAL_SEND_COVERPG, pdmPrivate->sendCoverPage);
SetRegistryString(hRegKey, REGVAL_COVERPG, pUserMem->coverPage);
RegCloseKey(hRegKey);
}
//
// If a cover page is selected, then do the following:
// if the cover page file is a link resolve it
// check if the cover page file contains note/subject fields
//
if (pdmPrivate->sendCoverPage)
ValidateSelectedCoverPage(pUserMem);
//
// Collect the current values of other dialog controls
//
if (pUserMem->pSubject) MemFree(pUserMem->pSubject);
if (pUserMem->pNoteMessage) MemFree(pUserMem->pNoteMessage);
pUserMem->pSubject = GetTextStringValue(GetDlgItem(hDlg, IDC_CHOOSE_CP_SUBJECT));
pUserMem->pNoteMessage = GetTextStringValue(GetDlgItem(hDlg, IDC_CHOOSE_CP_NOTE));
//
// If the current application is "Send Note" utility, then
// the note field must not be empty.
//
if (pUserMem->pSubject == NULL &&
pUserMem->pNoteMessage == NULL &&
GetEnvironmentVariable(TEXT("NTFaxSendNote"), NULL, 0))
{
DisplayMessageDialog(hDlg, 0, 0, IDS_NOTE_SUBJECT_EMPTY);
SetFocus(GetDlgItem(hDlg, IDC_CHOOSE_CP_SUBJECT));
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
return TRUE;
}
}
return FALSE;
}
return TRUE;
}
INT_PTR
FaxOptsWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the first wizard page: entering subject and note information
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
{
//
// Maximum length for various text fields
//
static INT textLimits[] = {
IDC_WIZ_FAXOPTS_BILLING, 16,
0
};
PUSERMEM pUserMem;
PDMPRIVATE pdmPrivate;
WORD cmdId;
// TCHAR TimeFormat[32];
TCHAR Is24H[2], IsRTL[2], *pszTimeFormat = TEXT("h : mm tt");
static HWND hTimeControl;
SYSTEMTIME st;
if (! (pUserMem = CommonWizardProc(hDlg, message, wParam, lParam, PSWIZB_BACK|PSWIZB_NEXT)))
return FALSE;
pdmPrivate = &pUserMem->devmode.dmPrivate;
switch (message) {
case WM_INITDIALOG:
//LoadString(ghInstance,IDS_WIZ_TIME_FORMAT,TimeFormat,sizeof(TimeFormat));
hTimeControl = GetDlgItem(hDlg, IDC_WIZ_FAXOPTS_SENDTIME);
if (GetLocaleInfo( LOCALE_USER_DEFAULT,LOCALE_ITIME, Is24H,sizeof(Is24H) ) && Is24H[0] == TEXT('1')) {
pszTimeFormat = TEXT("H : mm");
}
else if (GetLocaleInfo( LOCALE_USER_DEFAULT,LOCALE_ITIMEMARKPOSN, IsRTL,sizeof(IsRTL) ) && IsRTL[0] == TEXT('1')) {
pszTimeFormat = TEXT("tt h : mm");
}
LimitTextFields(hDlg, textLimits);
DateTime_SetFormat( hTimeControl,pszTimeFormat );
//
// restore time to send controls
//
cmdId = (pdmPrivate->whenToSend == SENDFAX_AT_CHEAP) ? IDC_WIZ_FAXOPTS_DISCOUNT :
(pdmPrivate->whenToSend == SENDFAX_AT_TIME) ? IDC_WIZ_FAXOPTS_SPECIFIC :
IDC_WIZ_FAXOPTS_ASAP;
CheckDlgButton(hDlg, cmdId, TRUE);
EnableWindow(hTimeControl, (cmdId == IDC_WIZ_FAXOPTS_SPECIFIC) );
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FAXOPTS_DATE), (cmdId == IDC_WIZ_FAXOPTS_SPECIFIC) );
GetLocalTime(&st);
st.wHour = pdmPrivate->sendAtTime.Hour;
st.wMinute = pdmPrivate->sendAtTime.Minute;
DateTime_SetSystemtime( hTimeControl, GDT_VALID, &st );
SetDlgItemText(hDlg, IDC_WIZ_FAXOPTS_BILLING, pdmPrivate->billingCode);
return TRUE;
case WM_NOTIFY:
if (((NMHDR *) lParam)->code == PSN_WIZNEXT) {
//
// retrieve the billing code
//
if (! GetDlgItemText(hDlg, IDC_WIZ_FAXOPTS_BILLING, pdmPrivate->billingCode, MAX_BILLING_CODE)) {
pdmPrivate->billingCode[0] = NUL;
}
//
// retrieve the sending time
//
pdmPrivate->whenToSend = IsDlgButtonChecked(hDlg,IDC_WIZ_FAXOPTS_DISCOUNT) ? SENDFAX_AT_CHEAP :
IsDlgButtonChecked(hDlg,IDC_WIZ_FAXOPTS_SPECIFIC) ? SENDFAX_AT_TIME :
SENDFAX_ASAP;
if (pdmPrivate->whenToSend == SENDFAX_AT_TIME) {
DWORD rVal;
SYSTEMTIME SendTime;
TCHAR TimeBuffer[128];
//
// get specific time
//
rVal = DateTime_GetSystemtime(hTimeControl, &SendTime);
pdmPrivate->sendAtTime.Hour = SendTime.wHour;
pdmPrivate->sendAtTime.Minute = SendTime.wMinute;
rVal = GetDateFormat(
LOCALE_SYSTEM_DEFAULT,
0,
&SendTime,
NULL,
TimeBuffer,
sizeof(TimeBuffer)
);
TimeBuffer[rVal - 1] = TEXT(' ');
GetTimeFormat(
LOCALE_SYSTEM_DEFAULT,
0,
&SendTime,
NULL,
&TimeBuffer[rVal],
sizeof(TimeBuffer)
);
Verbose(("faxui - Fax Send time %ws", TimeBuffer));
}
}
break;
case WM_COMMAND:
switch (cmdId = GET_WM_COMMAND_ID(wParam, lParam)) {
case IDC_WIZ_FAXOPTS_SPECIFIC:
case IDC_WIZ_FAXOPTS_DISCOUNT:
case IDC_WIZ_FAXOPTS_ASAP:
EnableWindow(hTimeControl, (cmdId == IDC_WIZ_FAXOPTS_SPECIFIC) );
EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FAXOPTS_DATE), (cmdId == IDC_WIZ_FAXOPTS_SPECIFIC) );
break;
};
break;
default:
return FALSE;
} ;
return TRUE;
}
#ifdef FAX_SCAN_ENABLED
BOOL
CloseDataSource(
PUSERMEM pUserMem,
TW_IDENTITY * TwIdentity
);
BOOL
OpenDataSource(
PUSERMEM pUserMem,
TW_IDENTITY * TwIdentity
);
BOOL
DisableDataSource(
PUSERMEM pUserMem,
TW_USERINTERFACE * TwUserInterface
);
BOOL
EnableDataSource(
PUSERMEM pUserMem,
TW_USERINTERFACE * TwUserInterface
);
BOOL
SetCapability(
PUSERMEM pUserMem,
USHORT Capability,
USHORT Type,
LPVOID Value
);
BOOL
Scan_SetCapabilities(
PUSERMEM pUserMem
);
#define WM_SCAN_INIT WM_APP
#define WM_SCAN_OPENDSM WM_APP+1
#define WM_SCAN_CLOSEDSM WM_APP+2
#define WM_SCAN_GETDEFAULT WM_APP+3
#define WM_SCAN_GETFIRST WM_APP+4
#define WM_SCAN_GETNEXT WM_APP+5
#define WM_SCAN_OPENDS WM_APP+10
#define WM_SCAN_CLOSEDS WM_APP+11
#define WM_SCAN_ENABLEDS WM_APP+12
#define WM_SCAN_DISABLEDS WM_APP+13
#define WM_SCAN_CONTROLGET WM_APP+20
#define WM_SCAN_CONTROLGETDEF WM_APP+21
#define WM_SCAN_CONTROLRESET WM_APP+22
#define WM_SCAN_CONTROLSET WM_APP+23
#define WM_SCAN_CONTROLENDXFER WM_APP+24
#define WM_SCAN_IMAGEGET WM_APP+30
#define Scan_Init(_pUserMem) (SendMessage(_pUserMem->hWndTwain, WM_SCAN_INIT,0,(LPARAM)_pUserMem))
#define Scan_OpenDSM(_pUserMem) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_OPENDSM,0,(LPARAM)&_pUserMem->hWndTwain))
#define Scan_CloseDSM(_pUserMem) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CLOSEDSM,0,(LPARAM)&_pUserMem->hWndTwain))
#define Scan_GetDefault(_pUserMem,_TwIdentity) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_GETDEFAULT,0,(LPARAM)_TwIdentity))
#define Scan_GetFirst(_pUserMem,_TwIdentity) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_GETFIRST,0,(LPARAM)_TwIdentity))
#define Scan_GetNext(_pUserMem,_TwIdentity) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_GETNEXT,0,(LPARAM)_TwIdentity))
#define Scan_OpenDS(_pUserMem,_TwIdentity) (SendMessage(_pUserMem->hWndTwain, WM_SCAN_OPENDS,0,(LPARAM)_TwIdentity))
#define Scan_CloseDS(_pUserMem,_TwIdentity) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CLOSEDS,0,(LPARAM)_TwIdentity))
#define Scan_EnableDS(_pUserMem,_TwUi) (SendMessage(_pUserMem->hWndTwain, WM_SCAN_ENABLEDS,0,(LPARAM)_TwUi))
#define Scan_DisableDS(_pUserMem,_TwUi) (SendMessage(_pUserMem->hWndTwain, WM_SCAN_DISABLEDS,0,(LPARAM)_TwUi))
#define Scan_ControlGet(_pUserMem,_What,_Data) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CONTROLGET,(WPARAM)_What,(LPARAM)_Data))
#define Scan_ControlGetDef(_pUserMem,_What,_Data) (SendMessage(_pUserMem->hWndTwain, WM_SCAN_CONTROLGETDEF,(WPARAM)_What,(LPARAM)_Data))
#define Scan_ControlReset(_pUserMem,_What,_Data) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CONTROLRESET,(WPARAM)_What,(LPARAM)_Data))
#define Scan_ControlSet(_pUserMem,_What,_Data) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CONTROLSET,(WPARAM)_What,(LPARAM)_Data))
#define Scan_ControlEndXfer(_pUserMem,_What,_Data) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_CONTROLENDXFER,(WPARAM)_What,(LPARAM)_Data))
#define Scan_ImageGet(_pUserMem,_What,_Data) ((DWORD)SendMessage(_pUserMem->hWndTwain, WM_SCAN_IMAGEGET,(WPARAM)_What,(LPARAM)_Data))
//#define WM_SCAN_GETEVENT WM_APP+7
DWORD
CallTwain(
PUSERMEM pUserMem,
TW_UINT32 DG,
TW_UINT16 DAT,
TW_UINT16 MSG,
TW_MEMREF pData
)
{
DWORD TwResult = 0;
TW_STATUS TwStatus = {0};
__try {
TwResult = pUserMem->pDsmEntry(
&pUserMem->AppId,
NULL,
DG,
DAT,
MSG,
pData
);
if (TwResult) {
pUserMem->pDsmEntry(
&pUserMem->AppId,
NULL,
DG_CONTROL,
DAT_STATUS,
MSG_GET,
(TW_MEMREF) &TwStatus
);
if (TwStatus.ConditionCode) {
TwResult = TwStatus.ConditionCode;
}
Verbose(( "CallTwain failed, ec=%d\n", TwResult ));
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
//
// for some reason we crashed, so return the exception code
//
TwResult = GetExceptionCode();
Verbose(( "CallTwain crashed, ec=0x%08x\n", TwResult ));
}
return TwResult;
}
DWORD
CallTwainDataSource(
PUSERMEM pUserMem,
TW_UINT32 DG,
TW_UINT16 DAT,
TW_UINT16 MSG,
TW_MEMREF pData
)
{
DWORD TwResult = 0;
TW_STATUS TwStatus = {0};
__try {
TwResult = pUserMem->pDsmEntry(
&pUserMem->AppId,
&pUserMem->DataSource,
DG,
DAT,
MSG,
pData
);
if (TwResult) {
pUserMem->pDsmEntry(
&pUserMem->AppId,
&pUserMem->DataSource,
DG_CONTROL,
DAT_STATUS,
MSG_GET,
(TW_MEMREF) &TwStatus
);
if (TwStatus.ConditionCode) {
TwResult = TwStatus.ConditionCode;
}
//Verbose(( "CallTwainDataSource failed, ec=%d\n", TwResult ));
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
//
// for some reason we crashed, so return the exception code
//
TwResult = GetExceptionCode();
Verbose(( "CallTwainDataSource crashed, ec=0x%08x\n", TwResult ));
}
return TwResult;
}
LRESULT
WINAPI
TwainWndProc(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
DWORD TwResult = 0;
static PUSERMEM pUserMem = NULL;
switch (uMsg) {
case WM_SCAN_INIT:
pUserMem = (PUSERMEM)lParam;
return(TRUE);
break;
case WM_SCAN_OPENDSM :
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_PARENT,
MSG_OPENDSM,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_OPENDSM (DAT_PARENT) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
case WM_SCAN_CLOSEDSM:
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_PARENT,
MSG_CLOSEDSM,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_CLOSEDSM (DAT_PARENT) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
case WM_SCAN_GETDEFAULT:
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_IDENTITY,
MSG_GETDEFAULT,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GETDEFAULT (DAT_IDENTITY) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
case WM_SCAN_GETFIRST:
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_IDENTITY,
MSG_GETFIRST,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GETFIRST (DAT_IDENTITY) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
case WM_SCAN_GETNEXT:
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_IDENTITY,
MSG_GETNEXT,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS && TwResult != TWRC_ENDOFLIST) {
Verbose(( "MSG_GETNEXT (DAT_IDENTITY) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
case WM_SCAN_OPENDS:
if (OpenDataSource( pUserMem, (TW_IDENTITY *)lParam ) &&
Scan_SetCapabilities( pUserMem )) {
return TRUE;
}
return(FALSE);
case WM_SCAN_CLOSEDS:
return (CloseDataSource( pUserMem, (TW_IDENTITY *)lParam ));
case WM_SCAN_ENABLEDS:
return (EnableDataSource( pUserMem, (TW_USERINTERFACE *)lParam ));
case WM_SCAN_DISABLEDS:
return (DisableDataSource( pUserMem, (TW_USERINTERFACE *)lParam ));
case WM_SCAN_CONTROLGET:
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
(TW_UINT16)wParam,
MSG_GET,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GET (%d)failed, ec = %d\n", wParam, TwResult ));
}
return(TwResult);
break;
case WM_SCAN_CONTROLGETDEF:
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
(TW_UINT16)wParam,
MSG_GETDEFAULT,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GETDEFAULT (%d)failed, ec = %d\n", wParam, TwResult ));
}
return(TwResult);
break;
case WM_SCAN_CONTROLRESET:
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
(TW_UINT16)wParam,
MSG_RESET,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_RESET (%d)failed, ec = %d\n", wParam, TwResult ));
}
return(TwResult);
break;
case WM_SCAN_CONTROLSET:
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
(TW_UINT16)wParam,
MSG_SET,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_SET (%d)failed, ec = %d\n", wParam, TwResult ));
}
return(TwResult);
break;
case WM_SCAN_CONTROLENDXFER:
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
(TW_UINT16)wParam,
MSG_ENDXFER,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_ENDXFER (%d)failed, ec = %d\n", wParam, TwResult ));
}
return(TwResult);
break;
case WM_SCAN_IMAGEGET:
TwResult = CallTwainDataSource(
pUserMem,
DG_IMAGE,
(TW_UINT16)wParam,
MSG_GET,
(TW_MEMREF) lParam
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GET (DAT_IMAGEINFO) failed, ec = %d\n", TwResult ));
}
return(TwResult);
break;
default:
return DefWindowProc( hwnd, uMsg, wParam, lParam );
};
Assert(FALSE);
return FALSE;
}
DWORD
TwainMessagePumpThread(
PUSERMEM pUserMem
)
{
WNDCLASS wc;
MSG msg;
HWND hWnd;
DWORD WaitObj;
TW_EVENT TwEvent;
DWORD TwResult;
wc.style = CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)TwainWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = ghInstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = L"FaxWizTwainWindow";
if (RegisterClass( &wc ) == 0) {
SetEvent( pUserMem->hEvent );
return 0;
}
hWnd = CreateWindow(
L"FaxWizTwainWindow",
L"FaxWizTwainWindow",
WS_DISABLED,
0,
0,
0,
0,
NULL,
NULL,
ghInstance,
NULL
);
if (hWnd == NULL) {
SetEvent( pUserMem->hEvent );
return 0;
}
pUserMem->hWndTwain = hWnd;
Scan_Init(pUserMem);
SetEvent( pUserMem->hEvent );
while (TRUE) {
WaitObj = MsgWaitForMultipleObjectsEx( 1, &pUserMem->hEventQuit, INFINITE, QS_ALLINPUT, 0 );
if (WaitObj == WAIT_OBJECT_0) {
return 0;
}
// PeekMessage instead of GetMessage so we drain the message queue
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE )) {
if (msg.message == WM_QUIT) {
return 0;
}
if (pUserMem->TwainAvail) {
TwEvent.pEvent = (TW_MEMREF) &msg;
TwEvent.TWMessage = MSG_NULL;
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
DAT_EVENT,
MSG_PROCESSEVENT,
(TW_MEMREF) &TwEvent
);
//if (TwResult != TWRC_SUCCESS && TwResult != TWRC_NOTDSEVENT) {
// Verbose(( "MSG_PROCESSEVENT (DAT_EVENT) failed, ec=%d\n", TwResult ));
//}
switch (TwEvent.TWMessage) {
case MSG_XFERREADY:
//
// transition from state 5 to state 6
//
Verbose(( "received MSG_XFERREADY, setting hEventXfer\n" ));
SetEvent( pUserMem->hEventXfer );
break;
case MSG_CLOSEDSREQ:
//
// transition from state 5 to 4 to 3
//
pUserMem->TwainCancelled = TRUE;
Verbose(( "received MSG_CLOSEDSREQ, setting hEventXfer\n" ));
SetEvent( pUserMem->hEventXfer );
break;
case MSG_NULL:
break;
}
if (TwResult == TWRC_NOTDSEVENT) {
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
}
}
return 0;
}
VOID
TerminateTwain(
PUSERMEM pUserMem
)
{
DWORD TwResult;
Verbose(( "entering TerminateTwain, state = %d\n", pUserMem->State ));
//Scan_CloseDS( pUserMem, &pUserMem->DataSource );
CloseDataSource( pUserMem, &pUserMem->DataSource );
if (pUserMem->State == 3) {
TwResult = Scan_CloseDSM( pUserMem );
if (TwResult == TWRC_SUCCESS) {
pUserMem->State = 2;
Verbose(( "entering state 2\n" ));
}
}
if (pUserMem->hWndTwain) {
DestroyWindow( pUserMem->hWndTwain );
}
SetEvent( pUserMem->hEventQuit );
WaitForSingleObject( pUserMem->hThread, INFINITE );
if (pUserMem->hTwain) {
FreeLibrary( pUserMem->hTwain );
}
CloseHandle( pUserMem->hThread );
}
#if 0
BOOL
SetCapability(
PUSERMEM pUserMem,
USHORT Capability,
USHORT Type,
LPVOID Value
)
{
DWORD TwResult;
TW_CAPABILITY TwCapability;
TW_ONEVALUE *TwOneValue;
TW_FIX32 *TwFix32;
TwCapability.Cap = Capability;
TwCapability.ConType = TWON_ONEVALUE;
TwCapability.hContainer = GlobalAlloc( GHND, sizeof(TW_ONEVALUE) );
TwOneValue = (TW_ONEVALUE*) GlobalLock( TwCapability.hContainer );
TwOneValue->ItemType = Type;
if (Type == TWTY_FIX32) {
TwFix32 = (TW_FIX32*)Value;
CopyMemory( &TwOneValue->Item, TwFix32, sizeof(TW_FIX32) );
} else {
TwOneValue->Item = (DWORD)Value;
}
GlobalUnlock( TwCapability.hContainer );
//
// bugbug called in opendatasource
//
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
DAT_CAPABILITY,
MSG_SET,
(TW_MEMREF) &TwCapability
);
GlobalFree( TwCapability.hContainer );
if (TwResult != TWRC_SUCCESS) {
Verbose(( "Could not set capability 0x%04x\n", Capability ));
return FALSE;
}
return TRUE;
}
#else
BOOL
SetCapability(
PUSERMEM pUserMem,
USHORT Capability,
USHORT Type,
LPVOID Value
)
{
DWORD TwResult;
TW_CAPABILITY TwCapability;
TW_ONEVALUE *TwOneValue;
TW_FIX32 *TwFix32;
TwCapability.Cap = Capability;
TwCapability.ConType = TWON_ONEVALUE;
TwCapability.hContainer = GlobalAlloc( GHND, sizeof(TW_ONEVALUE) );
TwOneValue = (TW_ONEVALUE*) GlobalLock( TwCapability.hContainer );
TwOneValue->ItemType = Type;
if (Type == TWTY_FIX32) {
TwFix32 = (TW_FIX32*)Value;
CopyMemory( &TwOneValue->Item, TwFix32, sizeof(TW_FIX32) );
} else {
TwOneValue->Item = PtrToUlong(Value);
}
GlobalUnlock( TwCapability.hContainer );
//
// bugbug called in opendatasource
//
TwResult = Scan_ControlSet(pUserMem, DAT_CAPABILITY, &TwCapability);
GlobalFree( TwCapability.hContainer );
if (TwResult != TWRC_SUCCESS) {
Verbose(( "Could not set capability 0x%04x\n", Capability ));
return FALSE;
}
return TRUE;
}
#endif
float
FIX32ToFloat(
TW_FIX32 fix32
)
{
float floater;
floater = (float) fix32.Whole + (float) fix32.Frac / (float) 65536.0;
return floater;
}
BOOL
OpenDataSource(
PUSERMEM pUserMem,
TW_IDENTITY * TwIdentity
)
{
DWORD TwResult;
Verbose(( "entering OpenDataSource, state = %d\n", pUserMem->State ));
if (pUserMem->State == 3) {
//
// open the data source
//
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_IDENTITY,
MSG_OPENDS,
(TW_MEMREF) TwIdentity
);
if (TwResult != TWRC_SUCCESS) {
return FALSE;
}
pUserMem->State = 4;
Verbose(( "entering state 4\n" ));
}
return TRUE;
}
BOOL
Scan_SetCapabilities(
PUSERMEM pUserMem
)
{
//
// set the capabilities
//
SetCapability( pUserMem, CAP_XFERCOUNT, TWTY_INT16, (LPVOID)1 );
SetCapability( pUserMem, ICAP_PIXELTYPE, TWTY_INT16, (LPVOID)TWPT_BW );
SetCapability( pUserMem, ICAP_BITDEPTH, TWTY_INT16, (LPVOID)1 );
SetCapability( pUserMem, ICAP_BITORDER, TWTY_INT16, (LPVOID)TWBO_MSBFIRST );
SetCapability( pUserMem, ICAP_PIXELFLAVOR, TWTY_INT16, (LPVOID)TWPF_VANILLA );
SetCapability( pUserMem, ICAP_XFERMECH, TWTY_INT16, (LPVOID)TWSX_MEMORY );
return TRUE;
}
BOOL
EnableDataSource(
PUSERMEM pUserMem,
TW_USERINTERFACE *TwUserInterface
)
{
DWORD TwResult;
if (pUserMem->State == 4) {
ResetEvent( pUserMem->hEventXfer );
//
// enable the data source's user interface
//
pUserMem->TwainCancelled = FALSE;
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
DAT_USERINTERFACE,
MSG_ENABLEDS,
(TW_MEMREF) TwUserInterface
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_ENABLEDS (DAT_USERINTERFACE) failed, ec=%d\n",TwResult ));
return FALSE;
}
pUserMem->State = 5;
Verbose(( "entering state 5\n" ));
}
return TRUE;
}
BOOL
DisableDataSource(
PUSERMEM pUserMem,
TW_USERINTERFACE * TwUserInterface
)
{
DWORD TwResult;
Verbose(( "entering DisableDataSource, state = %d\n",pUserMem->State ));
if (pUserMem->State == 5) {
//
// disable the data source
//
TwResult = CallTwainDataSource(
pUserMem,
DG_CONTROL,
DAT_USERINTERFACE,
MSG_DISABLEDS,
(TW_MEMREF) TwUserInterface
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_DISABLEDS (DAT_USERINTERFACE) failed, ec = %d\n", TwResult ));
return FALSE;
}
pUserMem->State = 4;
Verbose(( "entering state 4\n" ));
}
return TRUE;
}
BOOL
CloseDataSource(
PUSERMEM pUserMem,
TW_IDENTITY * TwIdentity
)
{
DWORD TwResult;
Verbose(( "entering CloseDataSource, state = %d\n",pUserMem->State ));
if (pUserMem->State == 4) {
//
// close the data source
//
TwResult = CallTwain(
pUserMem,
DG_CONTROL,
DAT_IDENTITY,
MSG_CLOSEDS,
(TW_MEMREF) TwIdentity
);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_CLOSEDS (DAT_IDENTIFY) failed, ec = %d\n", TwResult ));
return FALSE;
}
pUserMem->State = 3;
Verbose(( "entering state 3\n" ));
}
Verbose(( "leaving CloseDataSource, state = %d\n",pUserMem->State ));
return TRUE;
}
BOOL
InitializeTwain(
PUSERMEM pUserMem
)
{
BOOL Rval = FALSE;
DWORD TwResult;
DWORD ThreadId;
HKEY hKey;
hKey = OpenRegistryKey( HKEY_LOCAL_MACHINE, REGKEY_SOFTWARE, FALSE, REG_READONLY );
if (hKey) {
if (GetRegistryDword( hKey, REGVAL_SCANNER_SUPPORT ) != 0) {
RegCloseKey( hKey );
return FALSE;
}
RegCloseKey( hKey );
}
pUserMem->State = 1;
Verbose(( "entering state 1\n" ));
pUserMem->hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
pUserMem->hEventQuit = CreateEvent( NULL, TRUE, FALSE, NULL );
pUserMem->hEventXfer = CreateEvent( NULL, TRUE, FALSE, NULL );
pUserMem->hThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE)TwainMessagePumpThread,
pUserMem,
0,
&ThreadId
);
if (!pUserMem->hThread) {
goto exit;
}
WaitForSingleObject( pUserMem->hEvent, INFINITE );
if (pUserMem->hWndTwain == NULL) {
goto exit;
}
pUserMem->hTwain = LoadLibrary( L"twain_32.dll" );
if (pUserMem->hTwain) {
pUserMem->pDsmEntry = (DSMENTRYPROC) GetProcAddress( pUserMem->hTwain, "DSM_Entry" );
}
if (pUserMem->pDsmEntry == NULL) {
goto exit;
}
pUserMem->State = 2;
Verbose(( "entering state 2\n" ));
//
// open the data source manager
//
pUserMem->AppId.Id = 0;
pUserMem->AppId.Version.MajorNum = 1;
pUserMem->AppId.Version.MinorNum = 0;
pUserMem->AppId.Version.Language = TWLG_USA;
pUserMem->AppId.Version.Country = TWCY_USA;
strcpy( pUserMem->AppId.Version.Info, "Fax Print Wizard" );
pUserMem->AppId.ProtocolMajor = TWON_PROTOCOLMAJOR;
pUserMem->AppId.ProtocolMinor = TWON_PROTOCOLMINOR;
pUserMem->AppId.SupportedGroups = DG_IMAGE | DG_CONTROL;
strcpy( pUserMem->AppId.Manufacturer, "Microsoft" );
strcpy( pUserMem->AppId.ProductFamily, "Windows" );
strcpy( pUserMem->AppId.ProductName, "Windows" );
TwResult = Scan_OpenDSM( pUserMem );
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_OPENDSM (DAT_PARENT) failed, ec = %d\n", TwResult ));
goto exit;
}
pUserMem->State = 3;
Verbose(( "entering state 3\n" ));
//
// select the default data source
//
TwResult = Scan_GetDefault(pUserMem, &pUserMem->DataSource);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GETDEFAULT (DAT_IDENTITY) failed, ec = %d\n", TwResult ));
goto exit;
}
//
// return success
//
Rval = TRUE;
pUserMem->TwainAvail = TRUE;
exit:
if (!Rval) {
//
// part of the initialization failed
// so lets clean everything up before exiting
//
TerminateTwain( pUserMem );
}
return Rval;
}
DWORD
ScanningThread(
PUSERMEM pUserMem
)
{
DWORD TwResult;
TW_SETUPMEMXFER TwSetupMemXfer;
TW_IMAGEMEMXFER TwImageMemXfer;
TW_PENDINGXFERS TwPendingXfers;
TW_USERINTERFACE TwUserInterface;
TW_IMAGEINFO TwImageInfo;
HANDLE hFile = INVALID_HANDLE_VALUE;
TIFF_HEADER TiffHdr;
DWORD FileBytes = 0;
DWORD BytesWritten;
LPBYTE Buffer1 = NULL;
LPBYTE CurrBuffer;
LPBYTE p = NULL;
DWORD LineSize;
DWORD i;
DWORD Lines;
LPBYTE ScanBuffer = NULL;
DWORD IfdOffset;
DWORD NextIfdSeekPoint;
WORD NumDirEntries;
DWORD DataOffset;
BOOL FirstTime = TRUE;
Verbose(( "Entering ScanningThread, state = %d\n", pUserMem->State ));
pUserMem->TwainActive = TRUE;
if (pUserMem->State == 5) {
while (pUserMem->State == 5) {
//
// wait for the MSG_XFERREADY message to be
// delivered to the message pump. this moves
// us to state 6
//
WaitForSingleObject( pUserMem->hEventXfer, INFINITE );
ResetEvent( pUserMem->hEventXfer );
Verbose(( "hEventXfer signalled\n" ));
if (pUserMem->TwainCancelled) {
Verbose(( "twain cancelled\n" ));
TwUserInterface.ShowUI = FALSE;
TwUserInterface.ModalUI = FALSE;
TwUserInterface.hParent = NULL;
Scan_DisableDS(pUserMem, &TwUserInterface);
goto exit;
}
//
// get the image info
//
TwResult = Scan_ImageGet(pUserMem,DAT_IMAGEINFO,&TwImageInfo);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GET (DAT_IMAGEINFO) failed, ec=%d\n", TwResult ));
goto exit;
}
//
// we only allow monochrome images
//
if (TwImageInfo.BitsPerPixel > 1) {
DisplayMessageDialog( NULL,
MB_ICONASTERISK | MB_OK | MB_SETFOREGROUND,
IDS_SCAN_ERROR_TITLE,
IDS_SCAN_ERROR_BW );
//
// go back to state 5
//
TwResult = Scan_ControlReset(pUserMem,DAT_PENDINGXFERS,&TwPendingXfers);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_RESET (DAT_PENDINGXFERS) failed, ec=%d\n", TwResult ));
goto exit;
}
} else {
pUserMem->State = 6;
Verbose(( "entering state 6\n" ));
}
}
//
// setup the memory buffer sizes
//
TwResult = Scan_ControlGet(pUserMem,DAT_SETUPMEMXFER, &TwSetupMemXfer);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_GET (DAT_SETUPMEMXFER) failed, ec=%d\n", TwResult ));
goto exit;
}
Buffer1 = (LPBYTE) MemAlloc( TwSetupMemXfer.Preferred );
TwImageMemXfer.Compression = TWON_DONTCARE16;
TwImageMemXfer.BytesPerRow = TWON_DONTCARE32;
TwImageMemXfer.Columns = TWON_DONTCARE32;
TwImageMemXfer.Rows = TWON_DONTCARE32;
TwImageMemXfer.XOffset = TWON_DONTCARE32;
TwImageMemXfer.YOffset = TWON_DONTCARE32;
TwImageMemXfer.BytesWritten = TWON_DONTCARE32;
TwImageMemXfer.Memory.Flags = TWMF_APPOWNS | TWMF_POINTER;
TwImageMemXfer.Memory.Length = TwSetupMemXfer.Preferred;
TwImageMemXfer.Memory.TheMem = Buffer1;
}
Verbose(( "begin transferring image... " ));
Verbose(( "entering state 7, TwResult = %d\n", TwResult ));
while (TwResult != TWRC_XFERDONE) {
try_again:
pUserMem->State = 7;
TwResult = Scan_ImageGet(pUserMem,DAT_IMAGEMEMXFER,&TwImageMemXfer);
if (TwResult == 0) {
if (ScanBuffer == NULL) {
ScanBuffer = VirtualAlloc(
NULL,
TwImageMemXfer.BytesPerRow * (TwImageInfo.ImageLength + 16),
MEM_COMMIT,
PAGE_READWRITE
);
if (ScanBuffer == NULL) {
goto exit;
}
p = ScanBuffer;
}
CopyMemory( p, Buffer1, TwImageMemXfer.BytesWritten );
p += TwImageMemXfer.BytesWritten;
FileBytes += TwImageMemXfer.BytesWritten;
} else if ( TwResult != TWRC_XFERDONE) {
Verbose(( "MGS_GET (DAT_IMAGEMEMXFER) failed, ec = %d ", TwResult ));
goto exit;
}
}
Assert( TwResult == TWRC_XFERDONE );
if (!ScanBuffer || !FileBytes) {
//
// we didn't really scan anything...
//
Verbose(( "asked for tranfer, but nothing was transferred\n" ));
if (FirstTime) {
FirstTime = FALSE;
goto try_again;
}
TwResult = Scan_ControlEndXfer(pUserMem,DAT_PENDINGXFERS, &TwPendingXfers);
pUserMem->State = 5;
//
// disable the data source's user interface
//
TwUserInterface.ShowUI = FALSE;
TwUserInterface.ModalUI = FALSE;
TwUserInterface.hParent = NULL;
Scan_DisableDS(pUserMem, &TwUserInterface);
pUserMem->State = 4;
Verbose(( "entering state 4\n" ));
goto exit;
}
pUserMem->PageCount += 1;
Verbose(( "...finished transferring image\n" ));
hFile = CreateFile(
pUserMem->FileName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL
);
if (hFile == INVALID_HANDLE_VALUE) {
Verbose(( "CreateFile failed, ec=%d\n", GetLastError() ));
goto exit;
}
if (pUserMem->PageCount == 1) {
TiffHdr.Identifier = TIFF_LITTLEENDIAN;
TiffHdr.Version = TIFF_VERSION;
TiffHdr.IFDOffset = 0;
WriteFile( hFile, &TiffHdr, sizeof(TiffHdr), &BytesWritten, NULL );
} else {
ReadFile( hFile, &TiffHdr, sizeof(TiffHdr), &BytesWritten, NULL );
NextIfdSeekPoint = TiffHdr.IFDOffset;
while (NextIfdSeekPoint) {
SetFilePointer( hFile, NextIfdSeekPoint, NULL, FILE_BEGIN );
ReadFile( hFile, &NumDirEntries, sizeof(NumDirEntries), &BytesWritten, NULL );
SetFilePointer( hFile, NumDirEntries*sizeof(TIFF_TAG), NULL, FILE_CURRENT );
ReadFile( hFile, &NextIfdSeekPoint, sizeof(NextIfdSeekPoint), &BytesWritten, NULL );
}
}
NextIfdSeekPoint = SetFilePointer( hFile, 0, NULL, FILE_CURRENT ) - sizeof(NextIfdSeekPoint);
SetFilePointer( hFile, 0, NULL, FILE_END );
DataOffset = SetFilePointer( hFile, 0, NULL, FILE_CURRENT );
LineSize = TwImageInfo.ImageWidth / 8;
LineSize += (TwImageInfo.ImageWidth % 8) ? 1 : 0;
Lines = FileBytes / TwImageMemXfer.BytesPerRow;
CurrBuffer = ScanBuffer;
for (i=0; i<Lines; i++) {
WriteFile( hFile, CurrBuffer, LineSize, &BytesWritten, NULL );
CurrBuffer += TwImageMemXfer.BytesPerRow;
}
IfdOffset = SetFilePointer( hFile, 0, NULL, FILE_CURRENT );
FaxIFDTemplate.xresNum = (DWORD) FIX32ToFloat( TwImageInfo.XResolution );
FaxIFDTemplate.yresNum = (DWORD) FIX32ToFloat( TwImageInfo.YResolution );
FaxIFDTemplate.ifd[IFD_PAGENUMBER].DataOffset = MAKELONG( pUserMem->PageCount-1, 0);
FaxIFDTemplate.ifd[IFD_IMAGEWIDTH].DataOffset = TwImageInfo.ImageWidth;
FaxIFDTemplate.ifd[IFD_IMAGELENGTH].DataOffset = Lines;
FaxIFDTemplate.ifd[IFD_ROWSPERSTRIP].DataOffset = Lines;
FaxIFDTemplate.ifd[IFD_STRIPBYTECOUNTS].DataOffset = Lines * LineSize;
FaxIFDTemplate.ifd[IFD_STRIPOFFSETS].DataOffset = DataOffset;
FaxIFDTemplate.ifd[IFD_XRESOLUTION].DataOffset = IfdOffset + FIELD_OFFSET( FAXIFD, xresNum );
FaxIFDTemplate.ifd[IFD_YRESOLUTION].DataOffset = IfdOffset + FIELD_OFFSET( FAXIFD, yresNum );
FaxIFDTemplate.ifd[IFD_SOFTWARE].DataOffset = IfdOffset + FIELD_OFFSET( FAXIFD, software );
WriteFile( hFile, &FaxIFDTemplate, sizeof(FaxIFDTemplate), &BytesWritten, NULL );
SetFilePointer( hFile, NextIfdSeekPoint, NULL, FILE_BEGIN );
WriteFile( hFile, &IfdOffset, sizeof(DWORD), &BytesWritten, NULL );
//
// end the transfer
//
TwResult = Scan_ControlEndXfer(pUserMem,DAT_PENDINGXFERS, &TwPendingXfers);
if (TwResult != TWRC_SUCCESS) {
Verbose(( "MSG_ENDXFER (DAT_PENDINGXFERS) failed, ec=%d\n", TwResult ));
goto exit;
}
pUserMem->State = 5;
Verbose(( "entering state 5\n" ));
//
// disable the data source's user interface
//
TwUserInterface.ShowUI = FALSE;
TwUserInterface.ModalUI = FALSE;
TwUserInterface.hParent = NULL;
Scan_DisableDS(pUserMem, &TwUserInterface);
pUserMem->State = 4;
Verbose(( "entering state 4\n" ));
PostMessage( pUserMem->hDlgScan, WM_PAGE_COMPLETE, 0, 0 );
exit:
if (ScanBuffer) {
VirtualFree( ScanBuffer, 0, MEM_RELEASE);
}
if (hFile != INVALID_HANDLE_VALUE) {
CloseHandle( hFile );
}
MemFree( Buffer1 );
Verbose(( "leaving scanning thread, state = %d\n", pUserMem->State ));
pUserMem->TwainActive = FALSE;
return 0;
}
BOOL
EnumerateDataSources(
PUSERMEM pUserMem,
HWND ComboBox,
HWND StaticText
)
{
DWORD TwResult;
TW_IDENTITY TwIdentity;
TW_IDENTITY *pDataSource;
DWORD i;
DWORD Count = 0;
TwResult = Scan_GetFirst( pUserMem, &TwIdentity );
if (TwResult != TWRC_SUCCESS) {
return FALSE;
}
do {
i = (DWORD)SendMessageA( ComboBox, CB_ADDSTRING, 0, (LPARAM)TwIdentity.ProductName );
pDataSource = (TW_IDENTITY*) MemAlloc( sizeof(TW_IDENTITY) );
if (pDataSource) {
CopyMemory( pDataSource, &TwIdentity, sizeof(TW_IDENTITY) );
SendMessageA( ComboBox, CB_SETITEMDATA, i, (LPARAM)pDataSource );
}
Count += 1;
TwResult = Scan_GetNext( pUserMem, &TwIdentity );
} while (TwResult == 0);
i = (DWORD)SendMessageA( ComboBox, CB_FINDSTRINGEXACT, 0, (LPARAM)pUserMem->DataSource.ProductName );
if (i == CB_ERR) {
i = 0;
}
SendMessageA( ComboBox, CB_SETCURSEL, i, 0 );
if (Count == 1) {
EnableWindow( StaticText, FALSE );
EnableWindow( ComboBox, FALSE );
}
return TRUE;
}
INT_PTR
ScanWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the first wizard page: entering subject and note information
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
{
PUSERMEM pUserMem;
HANDLE hThread;
DWORD ThreadId;
WCHAR TempPath[MAX_PATH];
//TW_PENDINGXFERS TwPendingXfers;
TW_USERINTERFACE TwUserInterface;
pUserMem = (PUSERMEM) GetWindowLongPtr(hDlg, DWLP_USER);
switch (message) {
case WM_INITDIALOG:
lParam = ((PROPSHEETPAGE *) lParam)->lParam;
pUserMem = (PUSERMEM) lParam;
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
if (GetEnvironmentVariable(L"NTFaxSendNote", TempPath, sizeof(TempPath)) == 0 || TempPath[0] != L'1') {
pUserMem->TwainAvail = FALSE;
return TRUE;
}
if (pUserMem->TwainAvail) {
EnumerateDataSources( pUserMem, GetDlgItem( hDlg, IDC_DATA_SOURCE ), GetDlgItem( hDlg, IDC_STATIC_DATA_SOURCE) );
} else {
pUserMem->TwainAvail = FALSE;
return TRUE;
}
if (GetTempPath( sizeof(TempPath)/sizeof(WCHAR), TempPath )) {
if (GetTempFileName( TempPath, L"fax", 0, pUserMem->FileName )) {
SetEnvironmentVariable( L"ScanTifName", pUserMem->FileName );
}
}
pUserMem->hDlgScan = hDlg;
return TRUE;
case WM_NOTIFY:
switch ( ((NMHDR *) lParam)->code) {
case PSN_SETACTIVE:
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK|PSWIZB_NEXT);
if (!pUserMem->TwainAvail) {
//
// jump to next page
//
SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 );
return TRUE;
}
return FALSE;
break;
case PSN_WIZNEXT:
if (!pUserMem->PageCount) {
//
// we didn't actually scan any pages
//
DeleteFile( pUserMem->FileName ) ;
SetEnvironmentVariable( L"ScanTifName", NULL );
}
//Scan_CloseDS( pUserMem, &pUserMem->DataSource );
CloseDataSource( pUserMem, &pUserMem->DataSource );
Assert(pUserMem->State == 3);
pUserMem->State = 3;
SetWindowLongPtr( hDlg, DWLP_MSGRESULT, IDD_WIZARD_FAXOPTS );
return TRUE;
break;
case PSN_QUERYCANCEL:
//
// we didn't actually scan any pages
//
DeleteFile( pUserMem->FileName ) ;
if (pUserMem->TwainActive) {
TwUserInterface.ShowUI = FALSE;
TwUserInterface.ModalUI = FALSE;
TwUserInterface.hParent = NULL;
DisableDataSource( pUserMem, &TwUserInterface );
}
CloseDataSource( pUserMem, &pUserMem->DataSource );
break;
default:
break;
}
break;
case WM_PAGE_COMPLETE:
SetDlgItemInt( hDlg, IDC_PAGE_COUNT, pUserMem->PageCount, FALSE );
break;
case WM_COMMAND:
if (HIWORD(wParam) == CBN_SELCHANGE) {
TW_IDENTITY *pDataSource;
DWORD i;
i = (DWORD)SendDlgItemMessage( hDlg, IDC_DATA_SOURCE, CB_GETCURSEL, 0, 0 );
pDataSource = (TW_IDENTITY *) SendDlgItemMessage( hDlg, IDC_DATA_SOURCE, CB_GETITEMDATA, i, 0 );
CopyMemory( &pUserMem->DataSource, pDataSource, sizeof(TW_IDENTITY) );
}
if (HIWORD(wParam) == BN_CLICKED) {
//
// scan a page
//
TW_USERINTERFACE TwUserInterface;
TwUserInterface.ShowUI = TRUE;
TwUserInterface.ModalUI = TRUE;
TwUserInterface.hParent = GetParent(pUserMem->hDlgScan);
if ( !pUserMem->TwainActive
&& Scan_OpenDS( pUserMem, &pUserMem->DataSource)
//&& Scan_SetCapabilities( pUserMem )
&& Scan_EnableDS( pUserMem, &TwUserInterface )) {
EnableWindow( GetDlgItem( hDlg, IDC_DATA_SOURCE ), FALSE );
hThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE)ScanningThread,
pUserMem,
0,
&ThreadId
);
if (hThread) {
CloseHandle( hThread );
}
}
}
break;
case WM_DESTROY:
if (pUserMem->TwainAvail) {
TerminateTwain( pUserMem );
}
break;
/* case WM_ACTIVATE:
if (LOWORD(wParam) == WA_ACTIVE) {
if (!pUserMem->TwainActive) {
EnableWindow( hDlg, TRUE );
return TRUE;
}
} */
}
return FALSE;
}
#endif
LPTSTR
FormatTime(
WORD Hour,
WORD Minute,
LPTSTR Buffer,
DWORD BufferSize)
{
SYSTEMTIME SystemTime;
ZeroMemory(&SystemTime,sizeof(SystemTime));
SystemTime.wHour = Hour;
SystemTime.wMinute = Minute;
GetTimeFormat(LOCALE_USER_DEFAULT,
TIME_NOSECONDS,
&SystemTime,
NULL,
Buffer,
BufferSize
);
return Buffer;
}
INT_PTR
FinishWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the last wizard page:
give user a chance to confirm or cancel the dialog.
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
{
PUSERMEM pUserMem;
TCHAR RecipientNameBuffer[64];
TCHAR RecipientNumberBuffer[64];
TCHAR TmpTimeBuffer[64];
TCHAR TimeBuffer[64];
TCHAR SendTimeBuffer[64];
TCHAR NoneBuffer[64];
LPTSTR SenderName;
TCHAR CoverpageBuffer[64];
LPTSTR Coverpage;
HKEY hKey;
if (! (pUserMem = CommonWizardProc(hDlg, message, wParam, lParam, PSWIZB_BACK|PSWIZB_FINISH)) )
return FALSE;
switch (message) {
case WM_NOTIFY:
if (((NMHDR *) lParam)->code != PSN_SETACTIVE) break;
case WM_INITDIALOG:
LoadString(ghInstance,IDS_NONE,NoneBuffer,sizeof(NoneBuffer)/sizeof(TCHAR) );
//
// large title font on last page
//
SetWindowFont(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_READY), pUserMem->hLargeFont, TRUE);
//
// set the sender name if it exists
//
if ( (hKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO,TRUE) ) &&
(SenderName = GetRegistryString(hKey,REGVAL_FULLNAME,TEXT("")) )
) {
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_FROM, SenderName );
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_FROM),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_FROM),TRUE);
MemFree(SenderName);
} else {
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_FROM, NoneBuffer );
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_FROM),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_FROM),FALSE);
}
//
// set the recipient name
//
if (pUserMem->pRecipients && pUserMem->pRecipients->pNext) {
//
// more than one user, just put "Multiple" in the text
//
LoadString(ghInstance,IDS_MULTIPLE_RECIPIENTS,RecipientNameBuffer,sizeof(RecipientNameBuffer)/sizeof(TCHAR) );
LoadString(ghInstance,IDS_MULTIPLE_RECIPIENTS,RecipientNumberBuffer,sizeof(RecipientNumberBuffer)/sizeof(TCHAR) );
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_TO, RecipientNameBuffer );
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_NUMBER, RecipientNumberBuffer );
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_TO),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_TO),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_NUMBER),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_NUMBER),FALSE);
} else {
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_TO, pUserMem->pRecipients->pName );
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_NUMBER, pUserMem->pRecipients->pAddress );
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_TO),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_TO),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_NUMBER),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_NUMBER),TRUE);
}
//
// when to send
//
switch (pUserMem->devmode.dmPrivate.whenToSend) {
case SENDFAX_AT_TIME:
LoadString(ghInstance,IDS_SEND_SPECIFIC,TmpTimeBuffer,sizeof(TmpTimeBuffer)/sizeof(TCHAR) );
wsprintf(SendTimeBuffer,
TmpTimeBuffer,
FormatTime(pUserMem->devmode.dmPrivate.sendAtTime.Hour,
pUserMem->devmode.dmPrivate.sendAtTime.Minute,
TimeBuffer,
sizeof(TimeBuffer)) );
break;
case SENDFAX_AT_CHEAP:
LoadString(ghInstance,IDS_SEND_DISCOUNT,SendTimeBuffer,sizeof(SendTimeBuffer)/sizeof(TCHAR) );
break;
case SENDFAX_ASAP:
LoadString(ghInstance,IDS_SEND_ASAP,SendTimeBuffer,sizeof(SendTimeBuffer)/sizeof(TCHAR) );
};
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_TIME, SendTimeBuffer );
//
// Coverpage
//
if (pUserMem->devmode.dmPrivate.sendCoverPage) {
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_COVERPG),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_SUBJECT),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_COVERPG),TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_SUBJECT),TRUE);
//
// format the coverpage for display to the user
//
// drop path
Coverpage = _tcsrchr(pUserMem->coverPage,TEXT(PATH_SEPARATOR));
if (!Coverpage) {
Coverpage = pUserMem->coverPage;
} else {
Coverpage++;
}
_tcscpy(CoverpageBuffer,Coverpage);
// crop file extension
Coverpage = _tcschr(CoverpageBuffer,TEXT(FILENAME_EXT));
if (Coverpage && *Coverpage) {
*Coverpage = (TCHAR) NUL;
}
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_COVERPG, CoverpageBuffer );
if (pUserMem->pSubject) {
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_SUBJECT, pUserMem->pSubject );
} else {
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_SUBJECT),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_SUBJECT),FALSE);
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_SUBJECT, NoneBuffer );
}
} else {
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_COVERPG, NoneBuffer );
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_SUBJECT, NoneBuffer );
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_COVERPG),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_SUBJECT),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_COVERPG),FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_SUBJECT),FALSE);
}
//
// Billing Code
//
if (pUserMem->devmode.dmPrivate.billingCode[0]) {
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_BILLING), TRUE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_BILLING),TRUE);
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_BILLING, pUserMem->devmode.dmPrivate.billingCode );
} else {
EnableWindow(GetDlgItem(hDlg,IDC_STATIC_WIZ_CONGRATS_BILLING), FALSE);
EnableWindow(GetDlgItem(hDlg,IDC_WIZ_CONGRATS_BILLING), FALSE);
SetDlgItemText(hDlg, IDC_WIZ_CONGRATS_BILLING, NoneBuffer );
}
return TRUE;
default:
return FALSE;
} ;
return TRUE;
}
INT_PTR
WelcomeWizProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Dialog procedure for the last wizard page:
give user a chance to confirm or cancel the dialog.
Arguments:
hDlg - Identifies the wizard page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the message parameter
--*/
{
PUSERMEM pUserMem;
if (! (pUserMem = CommonWizardProc(hDlg, message, wParam, lParam, PSWIZB_NEXT)))
return FALSE;
switch (message) {
case WM_INITDIALOG:
//
// set the large fonts
//
SetWindowFont(GetDlgItem(hDlg,IDC_WIZ_WELCOME_TITLE), pUserMem->hLargeFont, TRUE);
//
// show this text only if we're running the send wizard
//
if (!GetEnvironmentVariable(TEXT("NTFaxSendNote"), NULL, 0)) {
MyHideWindow(GetDlgItem(hDlg,IDC_WIZ_WELCOME_FAXSEND) );
MyHideWindow(GetDlgItem(hDlg,IDC_WIZ_WELCOME_FAXSEND_CONT) );
}
return TRUE;
} ;
return FALSE;
}
BOOL
GetFakeRecipientInfo(
PUSERMEM pUserMem,
DWORD nRecipients
)
/*++
Routine Description:
Skip send fax wizard and get faked recipient information from the registry
Arguments:
pUserMem - Points to the user mode memory structure
nRecipients - Total number of faked recipient entries
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
LPTSTR pRecipientEntry;
DWORD index;
TCHAR buffer[MAX_STRING_LEN];
BOOL success = FALSE;
HKEY hRegKey;
//
// Retrieve information about the next fake recipient entry
//
Verbose(("Send Fax Wizard skipped...\n"));
if (hRegKey = GetUserInfoRegKey(REGKEY_FAX_USERINFO, REG_READWRITE))
index = GetRegistryDword(hRegKey, REGVAL_STRESS_INDEX);
else
index = 0;
if (index >= nRecipients)
index = 0;
wsprintf(buffer, TEXT("FakeRecipient%d"), index);
pRecipientEntry = GetPrinterDataStr(pUserMem->hPrinter, buffer);
if (hRegKey) {
//
// Update an index so that next time around we'll pick a different fake recipient
//
if (++index >= nRecipients)
index = 0;
SetRegistryDword(hRegKey, REGVAL_STRESS_INDEX, index);
RegCloseKey(hRegKey);
}
//
// Each fake recipient entry is a REG_MULTI_SZ of the following format:
// recipient name #1
// recipient fax number #1
// recipient name #2
// recipient fax number #2
// ...
//
if (pRecipientEntry) {
__try {
PRECIPIENT pRecipient;
LPTSTR pName, pAddress, p = pRecipientEntry;
while (*p) {
pName = p;
pAddress = pName + _tcslen(pName) + 1;
p = pAddress + _tcslen(pAddress) + 1;
pRecipient = MemAllocZ(sizeof(RECIPIENT));
pName = DuplicateString(pName);
pAddress = DuplicateString(pAddress);
if (!pRecipient || !pName || !pAddress) {
Error(("Invalid fake recipient information\n"));
MemFree(pRecipient);
MemFree(pName);
MemFree(pAddress);
break;
}
pRecipient->pNext = pUserMem->pRecipients;
pUserMem->pRecipients = pRecipient;
pRecipient->pName = pName;
pRecipient->pAddress = pAddress;
}
} __finally {
if (success = (pUserMem->pRecipients != NULL)) {
//
// Determine whether a cover page should be used
//
LPTSTR pCoverPage;
pCoverPage = GetPrinterDataStr(pUserMem->hPrinter, TEXT("FakeCoverPage"));
if (pUserMem->devmode.dmPrivate.sendCoverPage = (pCoverPage != NULL))
CopyString(pUserMem->coverPage, pCoverPage, MAX_PATH);
MemFree(pCoverPage);
}
}
}
MemFree(pRecipientEntry);
return success;
}
BOOL
SendFaxWizard(
PUSERMEM pUserMem
)
/*++
Routine Description:
Present the Send Fax Wizard to the user. This is invoked
during CREATEDCPRE document event.
Arguments:
pUserMem - Points to the user mode memory structure
Return Value:
TRUE if successful, FALSE if there is an error or the user pressed Cancel.
--*/
#ifdef FAX_SCAN_ENABLED
#define NUM_PAGES 6 // Number of wizard pages
#else
#define NUM_PAGES 5 // Number of wizard pages
#endif
{
PROPSHEETPAGE *ppsp;
PROPSHEETHEADER psh;
INT result;
DWORD nRecipients;
HDC hdc;
int i;
LOGFONT LargeFont;
NONCLIENTMETRICS ncm = {0};
TCHAR FontName[100];
TCHAR FontSize[30];
int iFontSize;
DWORD ThreadId;
HANDLE hThread;
Assert(pUserMem->pRecipients == NULL);
//
// A shortcut to skip fax wizard for debugging/testing purposes
//
if (nRecipients = GetPrinterDataDWord(pUserMem->hPrinter, TEXT("FakeRecipientCount"), 0))
return GetFakeRecipientInfo(pUserMem, nRecipients);
Verbose(("Presenting Send Fax Wizard...\n"));
if (! (ppsp = MemAllocZ(sizeof(PROPSHEETPAGE) * NUM_PAGES))) {
Error(("Memory allocation failed\n"));
return FALSE;
}
//
// fire off a thread to do some slow stuff later on in the wizard.
//
pUserMem->hFaxSvcEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
pUserMem->hTapiEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
#ifdef FAX_SCAN_ENABLED
pUserMem->hTwainEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
if (!pUserMem->hFaxSvcEvent || !pUserMem->hTapiEvent || !pUserMem->hTwainEvent) {
Error(("CreateEvent for async events failed\n"));
return FALSE;
}
#else
if (!pUserMem->hFaxSvcEvent || !pUserMem->hTapiEvent) {
Error(("CreateEvent for async events failed\n"));
return FALSE;
}
#endif
hThread = CreateThread(NULL,0,AsyncWizardThread,pUserMem,0,&ThreadId);
if (hThread) {
CloseHandle(hThread);
} else {
return FALSE;
}
//
// Fill out one PROPSHEETPAGE structure for every page:
// The first page is a welcome page
// The first page is for choose the fax recipient
// The second page is for choosing cover page, subject and note
// The third page is for entering time to send and other options
// The fourth page is for scanning pages
// The last page gives the user a chance to confirm or cancel the dialog
//
FillInPropertyPage( ppsp, IDD_WIZARD_WELCOME, WelcomeWizProc, pUserMem ,0,0);
FillInPropertyPage( ppsp+1, IDD_WIZARD_CHOOSE_WHO, RecipientWizProc, pUserMem ,IDS_WIZ_RECIPIENT_TITLE,IDS_WIZ_RECIPIENT_SUB);
//
// set second page title correctly if we're running as faxsend or from file print
if (!GetEnvironmentVariable(TEXT("NTFaxSendNote"), NULL, 0)) {
FillInPropertyPage( ppsp+2, IDD_WIZARD_CHOOSE_CP, CoverPageWizProc, pUserMem ,IDS_WIZ_COVERPAGE_TITLE_2,IDS_WIZ_COVERPAGE_SUB_2 );
}
else {
FillInPropertyPage( ppsp+2, IDD_WIZARD_CHOOSE_CP, CoverPageWizProc, pUserMem ,IDS_WIZ_COVERPAGE_TITLE_1,IDS_WIZ_COVERPAGE_SUB_1 );
}
#ifdef FAX_SCAN_ENABLED
FillInPropertyPage( ppsp+3, IDD_WIZARD_SCAN, ScanWizProc, pUserMem ,IDS_WIZ_SCAN_TITLE,IDS_WIZ_SCAN_SUB);
FillInPropertyPage( ppsp+4, IDD_WIZARD_FAXOPTS, FaxOptsWizProc, pUserMem ,IDS_WIZ_FAXOPTS_TITLE,IDS_WIZ_FAXOPTS_SUB);
FillInPropertyPage( ppsp+5, IDD_WIZARD_CONGRATS, FinishWizProc, pUserMem ,0,0);
#else
FillInPropertyPage( ppsp+3, IDD_WIZARD_FAXOPTS, FaxOptsWizProc, pUserMem ,IDS_WIZ_FAXOPTS_TITLE,IDS_WIZ_FAXOPTS_SUB);
FillInPropertyPage( ppsp+4, IDD_WIZARD_CONGRATS, FinishWizProc, pUserMem ,0,0);
#endif
//
// Fill out the PROPSHEETHEADER structure
//
ZeroMemory(&psh, sizeof(psh));
psh.dwSize = sizeof(PROPSHEETHEADER);
psh.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD | PSH_WIZARD97 | PSH_WATERMARK | PSH_HEADER;
psh.hwndParent = GetActiveWindow();
psh.hInstance = ghInstance;
psh.hIcon = NULL;
psh.pszCaption = TEXT("");
psh.nPages = NUM_PAGES;
psh.nStartPage = 0;
psh.ppsp = ppsp;
psh.pszbmHeader = MAKEINTRESOURCE(IDB_FAXWIZ_WATERMARK);
psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK_16);
if(hdc = GetDC(NULL)) {
if(GetDeviceCaps(hdc,BITSPIXEL) >= 8) {
psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK_256);
}
ReleaseDC(NULL,hdc);
}
//
// get the large fonts for wizard97
//
ncm.cbSize = sizeof(ncm);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
CopyMemory((LPVOID* )&LargeFont,(LPVOID *) &ncm.lfMessageFont,sizeof(LargeFont) );
LoadString(ghInstance,IDS_LARGEFONT_NAME,FontName,sizeof(FontName)/sizeof(TCHAR) );
LoadString(ghInstance,IDS_LARGEFONT_SIZE,FontSize,sizeof(FontSize)/sizeof(TCHAR) );
iFontSize = _tcstoul( FontSize, NULL, 10 );
// make sure we at least have some basic font
if (*FontName == 0 || iFontSize == 0) {
lstrcpy(FontName,TEXT("MS Shell Dlg") );
iFontSize = 18;
}
lstrcpy(LargeFont.lfFaceName, FontName);
LargeFont.lfWeight = FW_BOLD;
if (hdc = GetDC(NULL)) {
LargeFont.lfHeight = 0 - (GetDeviceCaps(hdc,LOGPIXELSY) * iFontSize / 72);
pUserMem->hLargeFont = CreateFontIndirect(&LargeFont);
ReleaseDC( NULL, hdc);
}
//
// Display the wizard pages
//
if (PropertySheet(&psh) > 0)
result = pUserMem->finishPressed;
else
result = FALSE;
//
// Cleanup properly before exiting
//
//
// free headings
//
for (i = 0; i< NUM_PAGES; i++) {
MemFree( (PVOID)(ppsp+i)->pszHeaderTitle );
MemFree( (PVOID)(ppsp+i)->pszHeaderSubTitle );
}
if (pUserMem->lpWabInit) {
UnInitializeWAB( pUserMem->lpWabInit);
}
DeinitTapiService();
MemFree(ppsp);
DeleteObject(pUserMem->hLargeFont);
FreeCoverPageInfo(pUserMem->pCPInfo);
pUserMem->pCPInfo = NULL;
#ifdef FAX_SCAN_ENABLED
//
// if the user pressed cancel, cleanup leftover scanned file.
//
if (!pUserMem->finishPressed && pUserMem->TwainAvail && pUserMem->FileName) {
DeleteFile( pUserMem->FileName ) ;
SetEnvironmentVariable( L"ScanTifName", NULL );
}
#endif
Verbose(("Wizard finished...\n"));
return result;
}
Reference in a new issue Copy permalink