/*++
Copyright (C) Microsoft Corporation, 1995 - 1999
All rights reserved.
Module Name:
docprop.cxx
Abstract:
Job Properties
Author:
Steve Kiraly (SteveKi) 10/19/95
Revision History:
Lazar Ivanov (LazarI) - added DocumentPropertiesWrap (Nov-03-2000)
--*/
#include "precomp.hxx"
#pragma hdrstop
#include "time.hxx"
#include "docdata.hxx"
#include "propmgr.hxx"
#include "docprop.hxx"
/*++
Routine Name:
vDocPropSelections
Routine Description:
Displays Document property sheets for multiple selections.
Arguments:
TSelection - pointer to a list of document selections.
Return Value:
Nothing.
--*/
VOID
vDocumentPropSelections(
IN HWND hWnd,
IN LPCTSTR pszPrinterName,
IN TSelection *pSelection
)
{
//
// Get the selection information. We are in a loop to
// handle the selection of multiple jobs.
//
for( UINT i = 0; i < pSelection->_cSelected; ++i ){
//
// Display the document property pages.
//
vDocumentPropPages(
hWnd,
pszPrinterName,
pSelection->_pid[i],
SW_SHOWNORMAL,
0 );
}
}
/*++
Routine Description:
This function opens the property sheet of specified document.
We can't guarentee that this propset will perform all lengthy
operations in a worker thread (we synchronously call things like
ConfigurePort). Therefore, we spawn off a separate thread to
handle document properties.
Arguments:
hWnd - Specifies the parent window (optional).
pszPrinter - Specifies the printer name
nCmdShow - Initial show state
lParam - May spcify a sheet specifc index to directly open.
Return Value:
--*/
VOID
vDocumentPropPages(
IN HWND hWnd,
IN LPCTSTR pszPrinterName,
IN IDENT JobId,
IN INT iCmdShow,
IN LPARAM lParam
)
{
HANDLE hThread;
//
// Create the document specific data
//
TDocumentData* pDocumentData = new TDocumentData( pszPrinterName,
JobId,
iCmdShow,
lParam );
//
// If errors were encountered creating document data.
//
if( !VALID_PTR( pDocumentData )){
goto Fail;
}
//
// Create the thread which handles the UI. vPrinterPropPages adopts
// pPrinterData, therefore only on thread creation failure do we
// releae the document data back to the heap.
//
DWORD dwIgnore;
hThread = TSafeThread::Create( NULL,
0,
(LPTHREAD_START_ROUTINE)iDocumentPropPagesProc,
pDocumentData,
0,
&dwIgnore );
//
// Check thread creation.
//
if( !hThread ){
//
// Display error message, and release document data.
//
vShowResourceError( hWnd );
delete pDocumentData;
} else {
CloseHandle( hThread );
}
return;
Fail:
//
// Display the error message.
//
iMessage( hWnd,
IDS_ERR_DOC_JOB_PROPERTY_TITLE,
IDS_ERR_DOC_JOB_PROPERTY_JOB_NA,
MB_OK|MB_ICONSTOP,
kMsgGetLastError,
NULL );
delete pDocumentData;
}
/*++
Routine Name:
iDocumentPropPagesProc
Routine Description:
This is the routine called by the create thread call to display the
document property sheets.
Arguments:
pDocumentData - Pointer to the document data needed for all property sheets.
Return Value:
TRUE - if the property sheets were displayed.
FALSE - error creating and displaying property sheets.
--*/
INT
iDocumentPropPagesProc(
IN TDocumentData *pDocumentData ADOPT
)
{
DBGMSG( DBG_TRACE, ( "iDocumentPropPagesProc\n") );
BOOL bStatus;
bStatus = pDocumentData->bRegisterWindow( PRINTER_PIDL_TYPE_JOBID |
pDocumentData->JobId( ));
if( bStatus ){
//
// Check if the window is already present. If it is, then
// exit immediately.
//
if( !pDocumentData->hwnd( )){
delete pDocumentData;
return 0;
}
bStatus = pDocumentData->bLoad();
}
if( !bStatus ){
iMessage( pDocumentData->hwnd(),
IDS_ERR_DOC_JOB_PROPERTY_TITLE,
IDS_ERR_DOC_JOB_PROPERTY_JOB_NA,
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
kMsgGetLastError,
NULL );
delete pDocumentData;
return 0;
}
//
// Create the ducument property sheet windows.
//
TDocumentWindows DocumentWindows( pDocumentData );
//
// Were the document windows create
//
if( !VALID_OBJ( DocumentWindows ) ){
vShowResourceError( pDocumentData->hwnd() );
bStatus = FALSE;
}
//
// Display the property pages.
//
if( bStatus ){
if( !DocumentWindows.bDisplayPages( pDocumentData->hwnd() ) ){
vShowResourceError( pDocumentData->hwnd() );
bStatus = FALSE;
}
}
//
// Ensure we release the document data.
// We have adopted pPrinterData, so we must free it.
//
delete pDocumentData;
return bStatus;
}
/********************************************************************
Document Prop Base Class
********************************************************************/
/*++
Routine Name:
TDocumentProp
Routine Description:
Initialized the document property sheet base class
Arguments:
pDocumentData - Pointer to the document data needed for all property sheets.
Return Value:
None.
--*/
TDocumentProp::
TDocumentProp(
TDocumentData* pDocumentData
) : _pDocumentData( pDocumentData ),
_bApplyData( FALSE )
{
}
/*++
Routine Name:
~TDocumentProp
Routine Description:
Base class desctuctor.
Arguments:
None.
Return Value:
Nothing.
--*/
TDocumentProp::
~TDocumentProp(
)
{
}
/*++
Routine Name:
bHandleMessage
Routine Description:
Base class message handler. This routine is called by
derived classes who do not want to handle the message.
Arguments:
uMsg - Windows message
wParam - Word parameter
lParam - Long parameter
Return Value:
TRUE if message was handled, FALSE if message not handled.
--*/
BOOL
TDocumentProp::
bHandleMessage(
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
BOOL bStatus = TRUE;
switch( uMsg ){
//
// Set the values on the UI.
//
case WM_INITDIALOG:
bStatus = bSetUI();
break;
//
// Handle help and context help.
//
case WM_HELP:
case WM_CONTEXTMENU:
bStatus = PrintUIHelp( uMsg, _hDlg, wParam, lParam );
break;
case WM_NOTIFY:
switch( ((LPNMHDR)lParam)->code )
{
//
// User switched to the next page.
//
case PSN_KILLACTIVE:
bStatus = bReadUI();
vSetDlgMsgResult( !bStatus ? TRUE : FALSE );
break;
//
// User chiose the apply button.
//
case PSN_APPLY:
_bApplyData = TRUE;
bStatus = ( _bApplyData ) ? bSaveUI() : FALSE;
if( !bStatus )
{
//
// Switch to page with the error.
//
PropSheet_SetCurSelByID( GetParent( _hDlg ), DLG_DOC_JOB_GENERAL );
}
vSetDlgMsgResult( !bStatus ? PSNRET_INVALID_NOCHANGEPAGE : PSNRET_NOERROR );
break;
//
// Indicate the use canceled the dialog.
//
case PSN_QUERYCANCEL:
_bApplyData = FALSE;
break;
default:
bStatus = FALSE;
break;
}
break;
default:
bStatus = FALSE;
break;
}
if( !bStatus )
{
//
// Allow the derived classes to handle the message.
//
bStatus = _bHandleMessage( uMsg, wParam, lParam );
}
//
// If the message was handled check if the
// apply button should be enabled.
//
if( bStatus )
{
if( _pDocumentData->bCheckForChange() )
{
PropSheet_Changed( GetParent( _hDlg ), _hDlg );
}
else
{
PropSheet_UnChanged( GetParent( _hDlg), _hDlg );
}
}
return bStatus;
}
/********************************************************************
General Document Property Sheet.
********************************************************************/
/*++
Routine Name:
TDocumentGeneral
Routine Description:
Document property sheet derived class.
Arguments:
None.
Return Value:
Nothing.
--*/
TDocumentGeneral::
TDocumentGeneral(
IN TDocumentData* pDocumentData
) : TDocumentProp( pDocumentData ),
_bSetUIDone( FALSE )
{
}
/*++
Routine Name:
~TDocumentGeneral
Routine Description:
Document derived class destructor.
Arguments:
None.
Return Value:
Nothing.
--*/
TDocumentGeneral::
~TDocumentGeneral(
)
{
}
/*++
Routine Name:
bValid
Routine Description:
Document property sheet derived class valid object indicator.
Arguments:
None.
Return Value:
Returns the status of the base class.
--*/
BOOL
TDocumentGeneral::
bValid(
VOID
)
{
return TDocumentProp::bValid();
}
/*++
Routine Name:
bSetStartAndUntilTime
Routine Description:
Initialized the start and until time.
Arguments:
None.
Return Value:
TRUE time controls initialized, FALSE error occured.
--*/
BOOL
TDocumentGeneral::
bSetStartAndUntilTime(
VOID
)
{
TString strFormatString;
TStatusB bStatus;
//
// Get the time format string without seconds.
//
bStatus DBGCHK = bGetTimeFormatString( strFormatString );
//
// If we have retrived a valid time format string then use it,
// else use the default format string implemented by common control.
//
if( bStatus )
{
DateTime_SetFormat(GetDlgItem( _hDlg, IDC_DOC_JOB_START_TIME ), static_cast<LPCTSTR>( strFormatString ) );
DateTime_SetFormat(GetDlgItem( _hDlg, IDC_DOC_JOB_UNTIL_TIME ), static_cast<LPCTSTR>( strFormatString ) );
}
//
// If the printer is always available.
//
BOOL bAlways = ( _pDocumentData->pJobInfo()->StartTime == _pDocumentData->pJobInfo()->UntilTime );
//
// Set the start time.
//
SYSTEMTIME StartTime = { 0 };
DWORD dwLocalStartTime = 0;
GetLocalTime( &StartTime );
dwLocalStartTime = ( !bAlways ) ? SystemTimeToLocalTime( _pDocumentData->pJobInfo()->StartTime ) : 0;
StartTime.wHour = static_cast<WORD>( dwLocalStartTime / 60 );
StartTime.wMinute = static_cast<WORD>( dwLocalStartTime % 60 );
DateTime_SetSystemtime(GetDlgItem( _hDlg, IDC_DOC_JOB_START_TIME ), GDT_VALID, &StartTime );
//
// Set the until time.
//
SYSTEMTIME UntilTime = { 0 };
DWORD dwLocalUntilTime = 0;
GetLocalTime( &UntilTime );
dwLocalUntilTime = ( !bAlways ) ? SystemTimeToLocalTime( _pDocumentData->pJobInfo()->UntilTime ) : 0;
UntilTime.wHour = static_cast<WORD>( dwLocalUntilTime / 60 );
UntilTime.wMinute = static_cast<WORD>( dwLocalUntilTime % 60 );
DateTime_SetSystemtime(GetDlgItem( _hDlg, IDC_DOC_JOB_UNTIL_TIME ), GDT_VALID, &UntilTime );
return TRUE;
}
/*++
Routine Name:
bSetUI
Routine Description:
Loads the property sheet dialog with the document data
information.
Arguments:
None.
Return Value:
TRUE if data loaded successfully, FALSE if error occurred.
--*/
BOOL
TDocumentGeneral::
bSetUI(
VOID
)
{
//
// Get the flag if always availble.
//
BOOL bAlways = ( _pDocumentData->pJobInfo()->StartTime ==
_pDocumentData->pJobInfo()->UntilTime );
//
// Initialize the stat and until time controls.
//
if( !bSetStartAndUntilTime() )
{
DBGMSG( DBG_TRACE, ( "TDocumentGeneral::bSetStartAndUntilTime failed %d\n", GetLastError( )));
}
//
// Read the job size format string.
//
TString strFormat;
if( strFormat.bLoadString( ghInst, IDS_JOB_SIZE ) ){
//
// Set the size in byes of the job.
//
bSetEditTextFormat( _hDlg,
IDC_DOC_JOB_SIZE,
strFormat,
_pDocumentData->pJobInfo()->Size );
}
//
// Set the Number of pages in the job.
//
bSetEditTextFormat( _hDlg,
IDC_DOC_JOB_PAGES,
TEXT( "%d" ),
_pDocumentData->pJobInfo()->TotalPages );
//
// Set the document text.
//
bSetEditText( _hDlg, IDC_DOC_JOB_TITLE, _pDocumentData->pJobInfo()->pDocument );
bSetEditText( _hDlg, IDC_DOC_JOB_DATATYPE, _pDocumentData->pJobInfo()->pDatatype );
bSetEditText( _hDlg, IDC_DOC_JOB_PROCCESSOR, _pDocumentData->pJobInfo()->pPrintProcessor );
bSetEditText( _hDlg, IDC_DOC_JOB_OWNER, _pDocumentData->pJobInfo()->pUserName );
bSetEditText( _hDlg, IDC_DOC_JOB_NOTIFY, _pDocumentData->pJobInfo()->pNotifyName );
//
// Set the Priority indicator.
//
bSetEditTextFormat( _hDlg,
IDC_DOC_JOB_PRIORITY,
TEXT( "%d" ),
_pDocumentData->pJobInfo()->Priority );
SendDlgItemMessage( _hDlg,
IDC_DOC_JOB_PRIORITY_CONTROL,
TBM_SETRANGE,
FALSE,
MAKELONG( TDocumentData::kPriorityLowerBound, TDocumentData::kPriorityUpperBound ));
SendDlgItemMessage( _hDlg,
IDC_DOC_JOB_PRIORITY_CONTROL,
TBM_SETPOS,
TRUE,
_pDocumentData->pJobInfo()->Priority );
//
// Format the submitted time field.
//
TStatusB bStatus = FALSE;
TCHAR szBuff[kStrMax] = {0};
SYSTEMTIME LocalTime;
//
// Convert to local time.
//
bStatus DBGCHK = SystemTimeToTzSpecificLocalTime(
NULL,
&_pDocumentData->pJobInfo()->Submitted,
&LocalTime );
if( !bStatus ){
DBGMSG( DBG_MIN, ( "SysTimeToTzSpecLocalTime failed %d\n", GetLastError( )));
}
if( bStatus ){
//
// Convert using local format information.
//
bStatus DBGCHK = GetTimeFormat( LOCALE_USER_DEFAULT,
0,
&LocalTime,
NULL,
szBuff,
COUNTOF( szBuff ));
if( !bStatus ){
DBGMSG( DBG_MIN, ( "No Time %d, ", GetLastError( )));
}
}
if( bStatus ){
//
// Tack on space between time and date.
//
lstrcat( szBuff, TEXT(" ") );
//
// Get data format.
//
bStatus DBGCHK = GetDateFormat( LOCALE_USER_DEFAULT,
0,
&LocalTime,
NULL,
szBuff + lstrlen( szBuff ),
COUNTOF( szBuff ) - lstrlen( szBuff ) );
if( !bStatus ){
DBGMSG( DBG_MIN, ( "No Date %d\n", GetLastError( )));
}
}
//
// Set the submitted field
//
bStatus DBGCHK = bSetEditText( _hDlg, IDC_DOC_JOB_AT, szBuff );
//
// Set schedule radio buttons.
//
CheckRadioButton( _hDlg, IDC_DOC_JOB_START, IDC_DOC_JOB_ALWAYS,
bAlways ? IDC_DOC_JOB_ALWAYS : IDC_DOC_JOB_START );
vEnableAvailable( !bAlways );
//
// Disable all the controls if not an administrator.
//
if( !_pDocumentData->bAdministrator( )){
//
// Disable the time controls.
//
vEnableAvailable( FALSE );
//
// Disable things if not administrator.
//
static UINT auAvailable[] = {
IDC_DOC_JOB_NOTIFY,
IDC_DOC_JOB_PRIORITY_CONTROL,
IDC_DOC_JOB_ALWAYS,
IDC_DOC_JOB_START,
};
COUNT i;
for( i = 0; i < COUNTOF( auAvailable ); ++i ){
vEnableCtl( _hDlg, auAvailable[i], FALSE );
}
}
_bSetUIDone = TRUE;
return TRUE;
}
/*++
Routine Name:
bReadUI
Routine Description:
Stores the property information to the print server.
Arguments:
Nothing data is contained with in the class.
Return Value:
TRUE if data is stores successfully, FALSE if error occurred.
--*/
BOOL
TDocumentGeneral::
bReadUI(
VOID
)
{
DBGMSG( DBG_TRACE, ( "TDocumentGeneral::bReadUI\n") );
//
// Attempt to validate any UI changeable data.
// Currently not much can be validated, since all the
// controls have set constraints.
//
//
// Extract the UI and save it into the Document Data.
//
_pDocumentData->pJobInfo()->Priority = (DWORD)SendDlgItemMessage( _hDlg,
IDC_DOC_JOB_PRIORITY_CONTROL,
TBM_GETPOS,
0,
0 );
//
// Get the notify name.
//
bGetEditText( _hDlg, IDC_DOC_JOB_NOTIFY, _pDocumentData->strNotifyName() );
_pDocumentData->pJobInfo()->pNotifyName = (LPTSTR)(LPCTSTR)_pDocumentData->strNotifyName();
//
// If the Job always is set then indicate
// not time restriction in the start time and until time.
//
if( bGetCheck( _hDlg, IDC_DOC_JOB_ALWAYS ) ){
_pDocumentData->pJobInfo()->StartTime = 0;
_pDocumentData->pJobInfo()->UntilTime = 0;
} else {
//
// Get the Start time.
//
SYSTEMTIME StartTime;
DateTime_GetSystemtime( GetDlgItem( _hDlg, IDC_DOC_JOB_START_TIME ), &StartTime );
_pDocumentData->pJobInfo()->StartTime = LocalTimeToSystemTime( StartTime.wHour * 60 + StartTime.wMinute );
//
// Get the Until time.
//
SYSTEMTIME UntilTime;
DateTime_GetSystemtime( GetDlgItem( _hDlg, IDC_DOC_JOB_UNTIL_TIME ), &UntilTime );
_pDocumentData->pJobInfo()->UntilTime = LocalTimeToSystemTime( UntilTime.wHour * 60 + UntilTime.wMinute );
//
// If the printer start and until time are the same this is
// exactly the same as always available.
//
if( _pDocumentData->pJobInfo()->StartTime == _pDocumentData->pJobInfo()->UntilTime )
{
_pDocumentData->pJobInfo()->StartTime = 0;
_pDocumentData->pJobInfo()->UntilTime = 0;
}
}
//
// Set the job position to unspecified it may
// have changed while this dialog was up.
//
_pDocumentData->pJobInfo()->Position = JOB_POSITION_UNSPECIFIED;
return TRUE;
}
/*++
Routine Name:
bSaveUI
Routine Description:
Saves the UI data to some API call or print server.
Arguments:
Nothing data is contained with in the class.
Return Value:
TRUE if data is stores successfully, FALSE if error occurred.
--*/
BOOL
TDocumentGeneral::
bSaveUI(
VOID
)
{
DBGMSG( DBG_TRACE, ( "TDocumentGeneral::bSaveUI\n") );
//
// Clear the error saving flag.
//
_pDocumentData->bErrorSaving() = TRUE;
//
// Save the document data.
//
if( !_pDocumentData->bStore() ){
DWORD dwLastError = GetLastError ();
if( dwLastError == ERROR_INVALID_TIME ){
_pDocumentData->iErrorMsgId() = IDS_ERR_DOC_JOB_PROPERTY_TIME;
} else {
_pDocumentData->iErrorMsgId() = IDS_ERR_DOC_JOB_PROPERTY_MODIFY;
}
_pDocumentData->bErrorSaving() = FALSE;
}
//
// If there was an error saving the document data.
//
if( !_pDocumentData->bErrorSaving() ){
//
// Display the error message.
//
iMessage( _hDlg,
IDS_ERR_DOC_JOB_PROPERTY_TITLE,
_pDocumentData->iErrorMsgId(),
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
kMsgNone,
NULL );
return FALSE;
}
return TRUE;
}
/*++
Routine Name:
vEanbleAvailablity
Routine Description:
Enables the time availabilty of the job
Arguments:
TRUE enable the availablity, FALSE disable time availablity.
Return Value:
Nothing.
--*/
VOID
TDocumentGeneral::
vEnableAvailable(
IN BOOL bEnable
)
{
vEnableCtl( _hDlg, IDC_DOC_JOB_START_TIME, bEnable );
vEnableCtl( _hDlg, IDC_DOC_JOB_UNTIL_TIME, bEnable );
}
/*++
Routine Name:
bReadUI
Routine Description:
Stores the property information to the print server.
Arguments:
Nothing data is contained with in the class.
Return Value:
TRUE if data is stores successfully, FALSE if error occurred.
--*/
VOID
TDocumentGeneral::
vSetActive(
VOID
)
{
DBGMSG( DBG_TRACE, ( "TDocumentGeneral::vSetActive\n") );
(VOID)bSetStartAndUntilTime();
}
/*++
Routine Name:
bHandleMessage
Routine Description:
Document property sheet message handler. This handler only
handles events it wants and the base class handle will do the
standard message handling.
Arguments:
uMsg - Windows message
wParam - Word parameter
lParam - Long parameter
Return Value:
TRUE if message was handled, FALSE if message not handled.
--*/
BOOL
TDocumentGeneral::
_bHandleMessage(
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
BOOL bStatus = TRUE;
switch( uMsg )
{
case WM_HSCROLL:
//
// Check for slider notification.
//
if( GET_WM_HSCROLL_HWND( wParam, lParam ) == GetDlgItem(_hDlg, IDC_DOC_JOB_PRIORITY_CONTROL ) ){
bSetEditTextFormat( _hDlg,
IDC_DOC_JOB_PRIORITY,
TEXT("%d"),
SendDlgItemMessage( _hDlg,
IDC_DOC_JOB_PRIORITY_CONTROL,
TBM_GETPOS,
0,
0 ) );
}
break;
case WM_COMMAND:
switch( GET_WM_COMMAND_ID( wParam, lParam ))
{
case IDC_DOC_JOB_ALWAYS:
vEnableAvailable( FALSE );
PropSheet_Changed( GetParent( _hDlg ), _hDlg );
break;
case IDC_DOC_JOB_START:
vEnableAvailable( TRUE );
PropSheet_Changed( GetParent( _hDlg ), _hDlg );
break;
case IDC_DOC_JOB_NOTIFY:
bStatus = GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE;
break;
default:
bStatus = FALSE;
break;
}
break;
case WM_WININICHANGE:
vSetActive();
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( wParam )
{
case 0:
{
switch( pnmh->code )
{
case PSN_SETACTIVE:
vSetActive();
break;
default:
bStatus = FALSE;
break;
}
}
break;
case IDC_DOC_JOB_START_TIME:
case IDC_DOC_JOB_UNTIL_TIME:
{
switch( pnmh->code )
{
case DTN_DATETIMECHANGE:
break;
default:
bStatus = FALSE;
break;
}
}
break;
default:
bStatus = FALSE;
break;
}
}
break;
default:
bStatus = FALSE;
break;
}
//
// If message handled look for change.
//
if( bStatus && _bSetUIDone )
{
(VOID)bReadUI();
}
return bStatus;
}
/********************************************************************
Document property windows.
********************************************************************/
/*++
Routine Description:
Document property windows.
Arguments:
pDocumentData - Document data to display.
Return Value:
TRUE - Success, FALSE - failure.
--*/
TDocumentWindows::
TDocumentWindows(
TDocumentData* pDocumentData
) : _pDocumentData( pDocumentData ),
_General( pDocumentData )
{
DBGMSG( DBG_TRACE, ( "TDocumentWindows ctor\n") );
}
TDocumentWindows::
~TDocumentWindows(
)
{
DBGMSG( DBG_TRACE, ( "TDocumentWindows dtor\n") );
}
/*++
Routine Name:
bBuildPages
Routine Description:
Builds the document property windows.
Arguments:
None - class specific.
Return Value:
TRUE pages built ok, FALSE failure building pages.
--*/
BOOL
TDocumentWindows::
bBuildPages(
IN PPROPSHEETUI_INFO pCPSUIInfo
)
{
TStatusB bStatus;
DBGMSG( DBG_TRACE, ( "TDocumentWindows bBuildPages\n") );
//
// Set the default activation context to be V6 prior calling into
// compstui to create the pages. This will force V6 context unless
// the callbacks which create the compstui pages specify otherwise
// on a per page basis.
//
bStatus DBGCHK = (BOOL)pCPSUIInfo->pfnComPropSheet(
pCPSUIInfo->hComPropSheet,
CPSFUNC_SET_FUSION_CONTEXT,
reinterpret_cast<LPARAM>(g_hActCtx),
static_cast<LPARAM>(0));
if (bStatus)
{
PROPSHEETPAGE psp;
ZeroMemory( &psp, sizeof( psp ) );
psp.dwSize = sizeof( psp );
psp.dwFlags = PSP_DEFAULT;
psp.hInstance = ghInst;
psp.pfnDlgProc = MGenericProp::SetupDlgProc;
psp.pszTemplate = MAKEINTRESOURCE( DLG_DOC_JOB_GENERAL );
psp.lParam = (LPARAM)(MGenericProp*)&_General;
if( pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_ADD_PROPSHEETPAGE,
(LPARAM)&psp,
NULL ) <= 0 )
{
DBGMSG( DBG_TRACE, ( "CPSFUNC_ADD_PROPSHEETPAGE failed.\n") );
bStatus DBGCHK = FALSE;
}
if (bStatus)
{
//
// If the dev mode is null don't display the
// device property sheets.
//
if( _pDocumentData->pJobInfo()->pDevMode )
{
ZeroMemory( &_dph, sizeof( _dph ) );
_dph.cbSize = sizeof( _dph );
_dph.hPrinter = _pDocumentData->hPrinter();
_dph.pszPrinterName = (LPTSTR)(LPCTSTR)_pDocumentData->strPrinterName();
_dph.pdmOut = _pDocumentData->pJobInfo()->pDevMode;
_dph.pdmIn = _pDocumentData->pJobInfo()->pDevMode;
_dph.fMode = DM_IN_BUFFER | DM_PROMPT | DM_NOPERMISSION;
if( pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_ADD_PFNPROPSHEETUI,
(LPARAM)DocumentPropertySheets,
(LPARAM)&_dph ) <= 0 )
{
DBGMSG( DBG_TRACE, ( "CPSFUNC_ADD_PFNPROPSHEETUI failed.\n") );
bStatus DBGCHK = FALSE;
}
}
}
}
return bStatus;
}
BOOL
TDocumentWindows::
bSetHeader(
IN PPROPSHEETUI_INFO pCPSUIInfo,
IN PPROPSHEETUI_INFO_HEADER pPSUIInfoHdr
)
{
DBGMSG( DBG_TRACE, ( "TDocumentWindows bSetHeader\n") );
UNREFERENCED_PARAMETER( pCPSUIInfo );
pPSUIInfoHdr->pTitle = _pDocumentData->pJobInfo()->pDocument;
pPSUIInfoHdr->Flags = PSUIHDRF_PROPTITLE;
pPSUIInfoHdr->hWndParent = _pDocumentData->hwnd();
pPSUIInfoHdr->hInst = ghInst;
pPSUIInfoHdr->IconID = IDI_DOCUMENT;
return TRUE;
}
BOOL
TDocumentWindows::
bValid(
VOID
)
{
return _General.bValid();
}
/********************************************************************
Document properties UI (driver UI)
********************************************************************/
TDocumentProperties::
TDocumentProperties(
IN HWND hwnd,
IN HANDLE hPrinter,
IN LPCTSTR pszPrinter,
IN PDEVMODE pDevModeIn,
OUT PDEVMODE pDevModeOut,
IN DWORD dwHideBits,
IN DWORD dwFlags
):
_hwnd(hwnd),
_hPrinter(hPrinter),
_pszPrinter(pszPrinter),
_pDevModeIn(pDevModeIn),
_pDevModeOut(pDevModeOut),
_dwHideBits(dwHideBits),
_dwFlags(dwFlags),
_lResult(-1)
{
// nothing
}
LONG
TDocumentProperties::
lGetResult(
VOID
) const
{
return _lResult;
}
BOOL
TDocumentProperties::
bBuildPages(
IN PPROPSHEETUI_INFO pCPSUIInfo
)
{
BOOL bRet = FALSE;
if( bValid() )
{
//
// Set the default activation context to be V6 prior calling into
// compstui to create the pages. This will force V6 context unless
// the callbacks which create the compstui pages specify otherwise
// on a per page basis.
//
bRet = (BOOL)pCPSUIInfo->pfnComPropSheet(
pCPSUIInfo->hComPropSheet,
CPSFUNC_SET_FUSION_CONTEXT,
reinterpret_cast<LPARAM>(g_hActCtx),
static_cast<LPARAM>(0));
if( bRet )
{
ZeroMemory(&_dph, sizeof(_dph));
_dph.cbSize = sizeof(_dph);
_dph.hPrinter = _hPrinter;
_dph.pszPrinterName = const_cast<LPTSTR>(_pszPrinter);
_dph.pdmIn = _pDevModeIn;
_dph.pdmOut = _pDevModeOut;
_dph.fMode = _dwFlags;
if( _dwHideBits )
{
_lResult = pCPSUIInfo->pfnComPropSheet(pCPSUIInfo->hComPropSheet,
CPSFUNC_SET_DMPUB_HIDEBITS, static_cast<LPARAM>(_dwHideBits), 0);
}
else
{
//
// If no bit is hided, The result value should be valid.
//
_lResult = 1;
}
if( _lResult > 0 )
{
_lResult = pCPSUIInfo->pfnComPropSheet(pCPSUIInfo->hComPropSheet,
CPSFUNC_ADD_PFNPROPSHEETUI, reinterpret_cast<LPARAM>(DocumentPropertySheets),
reinterpret_cast<LPARAM>(&_dph));
}
}
}
return (_lResult > 0);
}
BOOL
TDocumentProperties::
bSetHeader(
IN PPROPSHEETUI_INFO pCPSUIInfo,
IN PPROPSHEETUI_INFO_HEADER pPSUInfoHeader
)
{
// construct the title & setup the header
UNREFERENCED_PARAMETER(pCPSUIInfo);
if( 0 == _strTitle.uLen() )
{
_strTitle.bLoadString(ghInst, IDS_PRINTER_PREFERENCES);
}
pPSUInfoHeader->pTitle = const_cast<LPTSTR>(static_cast<LPCTSTR>(_strTitle));
pPSUInfoHeader->Flags = PSUIHDRF_EXACT_PTITLE | PSUIHDRF_NOAPPLYNOW;
pPSUInfoHeader->hWndParent = _hwnd;
pPSUInfoHeader->hInst = ghInst;
pPSUInfoHeader->IconID = IDI_PRINTER;
return TRUE;
}
// table to remap the devmode field selections to DMPUB_* ids.
static DWORD arrDmFlagMap[] =
{
DM_ORIENTATION, MAKE_DMPUB_HIDEBIT( DMPUB_ORIENTATION ),
DM_PAPERSIZE , MAKE_DMPUB_HIDEBIT( 0 ),
DM_PAPERLENGTH, MAKE_DMPUB_HIDEBIT( 0 ),
DM_PAPERWIDTH , MAKE_DMPUB_HIDEBIT( 0 ),
DM_SCALE , MAKE_DMPUB_HIDEBIT( DMPUB_SCALE ),
DM_COPIES , MAKE_DMPUB_HIDEBIT( DMPUB_COPIES_COLLATE ),
DM_DEFAULTSOURCE, MAKE_DMPUB_HIDEBIT( DMPUB_DEFSOURCE ),
DM_PRINTQUALITY, MAKE_DMPUB_HIDEBIT( DMPUB_PRINTQUALITY ),
DM_COLOR , MAKE_DMPUB_HIDEBIT( DMPUB_COLOR ),
DM_DUPLEX , MAKE_DMPUB_HIDEBIT( DMPUB_DUPLEX ),
DM_YRESOLUTION, MAKE_DMPUB_HIDEBIT( 0 ),
DM_TTOPTION , MAKE_DMPUB_HIDEBIT( DMPUB_TTOPTION ),
DM_COLLATE , MAKE_DMPUB_HIDEBIT( DMPUB_COPIES_COLLATE ),
DM_FORMNAME , MAKE_DMPUB_HIDEBIT( DMPUB_FORMNAME ),
DM_LOGPIXELS , MAKE_DMPUB_HIDEBIT( 0 ),
DM_BITSPERPEL , MAKE_DMPUB_HIDEBIT( 0 ),
DM_PELSWIDTH , MAKE_DMPUB_HIDEBIT( 0 ),
DM_PELSHEIGHT , MAKE_DMPUB_HIDEBIT( 0 ),
DM_DISPLAYFLAGS, MAKE_DMPUB_HIDEBIT( 0 ),
DM_DISPLAYFREQUENCY, MAKE_DMPUB_HIDEBIT( 0 ),
DM_ICMMETHOD , MAKE_DMPUB_HIDEBIT( DMPUB_ICMMETHOD ),
DM_ICMINTENT , MAKE_DMPUB_HIDEBIT( DMPUB_ICMINTENT ),
DM_MEDIATYPE , MAKE_DMPUB_HIDEBIT( DMPUB_MEDIATYPE ),
DM_DITHERTYPE , MAKE_DMPUB_HIDEBIT( DMPUB_DITHERTYPE ),
DM_PANNINGWIDTH, MAKE_DMPUB_HIDEBIT( 0 ),
DM_PANNINGHEIGHT, MAKE_DMPUB_HIDEBIT( 0 )
};
static DWORD
RemapExclusionFlags(DWORD fExclusionFlags)
{
// walk through to collect the exclusion bits from the table above.
DWORD dwFlags = 0;
for( UINT i = 0; i < ARRAYSIZE(arrDmFlagMap); i += 2 )
{
if( fExclusionFlags & arrDmFlagMap[i] )
{
dwFlags |= arrDmFlagMap[i+1];
}
}
return dwFlags;
}
LONG
DocumentPropertiesWrapNative(
HWND hwnd, // handle to parent window
HANDLE hPrinter, // handle to printer object
LPTSTR pDeviceName, // device name
PDEVMODE pDevModeOutput, // modified device mode
PDEVMODE pDevModeInput, // original device mode
DWORD fMode, // mode options
DWORD fExclusionFlags // exclusion flags
)
{
// lResult <= 0 means error, for more information see
// the description of DocumentProperties in SDK.
LONG lResult = (-1);
if( hPrinter && pDeviceName && pDevModeOutput && pDevModeInput )
{
if (fMode & DM_PROMPT)
{
// invoke compstui to show up the driver UI
TDocumentProperties props(hwnd, hPrinter, pDeviceName, pDevModeInput, pDevModeOutput,
RemapExclusionFlags(fExclusionFlags), fMode);
if( props.bDisplayPages(hwnd, &lResult) )
{
// convert the result to IDOK/IDCANCEL
lResult = (lResult == CPSUI_OK) ? IDOK : IDCANCEL;
}
else
{
// error occured.
lResult = (-1);
}
}
else
{
// this is no UI call - just invoke DocumentProperties.
lResult = DocumentProperties(hwnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode);
}
}
return lResult;
}
LONG
DocumentPropertiesWrapWOW64(
HWND hwnd, // handle to parent window
HANDLE hPrinter, // handle to printer object
LPTSTR pDeviceName, // device name
PDEVMODE pDevModeOutput, // modified device mode
PDEVMODE pDevModeInput, // original device mode
DWORD fMode, // mode options
DWORD fExclusionFlags // exclusion flags
)
{
CDllLoader dll(TEXT("winspool.drv"));
ptr_PrintUIDocumentPropertiesWrap pfnPrintUIDocumentPropertiesWrap =
(ptr_PrintUIDocumentPropertiesWrap )dll.GetProcAddress(ord_PrintUIDocumentPropertiesWrap);
LONG lResult = (-1);
if( pfnPrintUIDocumentPropertiesWrap )
{
lResult = pfnPrintUIDocumentPropertiesWrap(hwnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode, fExclusionFlags);
}
return lResult;
}
LONG
DocumentPropertiesWrap(
HWND hwnd, // handle to parent window
HANDLE hPrinter, // handle to printer object
LPTSTR pDeviceName, // device name
PDEVMODE pDevModeOutput, // modified device mode
PDEVMODE pDevModeInput, // original device mode
DWORD fMode, // mode options
DWORD fExclusionFlags // exclusion flags
)
{
// if running in WOW64 environment we need to call winspool.drv to remote the
// call into the surrogate 64bit process where the driver UI can be displayed.
LONG lResult = IsRunningWOW64() ?
DocumentPropertiesWrapWOW64(hwnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode, fExclusionFlags) :
DocumentPropertiesWrapNative(hwnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode, fExclusionFlags);
return lResult;
}