3523 lines
76 KiB
C++
3523 lines
76 KiB
C++
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1995 - 1999
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
svrprop.cxx
|
|
|
|
Abstract:
|
|
|
|
Server Properties
|
|
|
|
Author:
|
|
|
|
Steve Kiraly (SteveKi) 11/15/95
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
#include "psetup.hxx"
|
|
#include "drvver.hxx"
|
|
#include "drvsetup.hxx"
|
|
#include "portslv.hxx"
|
|
#include "portdlg.hxx"
|
|
#include "driverif.hxx"
|
|
#include "driverlv.hxx"
|
|
#include "driverdt.hxx"
|
|
#include "svrprop.hxx"
|
|
#include "forms.hxx"
|
|
#include "time.hxx"
|
|
#include "instarch.hxx"
|
|
#include "dsinterf.hxx"
|
|
#include "prtprop.hxx"
|
|
#include "archlv.hxx"
|
|
#include "detect.hxx"
|
|
#include "setup.hxx"
|
|
#include "prndata.hxx"
|
|
#include "persist.hxx"
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
WOW64 version.
|
|
|
|
see vServerPropPages below.
|
|
|
|
Arguments:
|
|
|
|
see vServerPropPages below.
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
VOID
|
|
vServerPropPagesWOW64(
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszServerName,
|
|
IN INT iCmdShow,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
//
|
|
// This function potentially may load the driver UI so we call a private API
|
|
// exported by winspool.drv, which will RPC the call to a special 64 bit surrogate
|
|
// process where the 64 bit driver can be loaded.
|
|
//
|
|
CDllLoader dll(TEXT("winspool.drv"));
|
|
if (dll)
|
|
{
|
|
ptr_PrintUIServerPropPages pfn =
|
|
(ptr_PrintUIServerPropPages )dll.GetProcAddress(ord_PrintUIServerPropPages);
|
|
|
|
if (pfn)
|
|
{
|
|
// call into winspool.drv
|
|
pfn(hwnd, pszServerName, iCmdShow, lParam);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Native version.
|
|
|
|
see vServerPropPages below.
|
|
|
|
Arguments:
|
|
|
|
see vServerPropPages below.
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
VOID
|
|
vServerPropPagesNative(
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszServerName,
|
|
IN INT iCmdShow,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "vServerPropPages\n") );
|
|
|
|
BOOL bModal = FALSE;
|
|
DWORD dwSheetNumber = LOWORD( lParam );
|
|
//
|
|
// If the high word is non zero then dialog is modal.
|
|
//
|
|
if( HIWORD( lParam ) ) {
|
|
bModal = TRUE;
|
|
}
|
|
|
|
//
|
|
// Create the server specific data.
|
|
//
|
|
TServerData *pServerData = new TServerData( pszServerName,
|
|
iCmdShow,
|
|
dwSheetNumber,
|
|
hwnd,
|
|
bModal );
|
|
//
|
|
// If errors were encountered creating document data.
|
|
//
|
|
if( !VALID_PTR( pServerData )){
|
|
goto Fail;
|
|
}
|
|
|
|
//
|
|
// If lparam is has the high word non zero the dialog is modal.
|
|
//
|
|
if( bModal ) {
|
|
|
|
//
|
|
// If a failure occured then the message has already been displayed,
|
|
// therefore we just exit.
|
|
//
|
|
iServerPropPagesProc( pServerData );
|
|
return;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Create the thread which handles the UI. iServerPropPagesProc adopts
|
|
// pServerData, therefore only on thread creation failure do we
|
|
// release the data back to the heap.
|
|
//
|
|
DWORD dwIgnore;
|
|
HANDLE hThread;
|
|
hThread = TSafeThread::Create( NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE)iServerPropPagesProc,
|
|
pServerData,
|
|
0,
|
|
&dwIgnore );
|
|
|
|
//
|
|
// Check thread creation.
|
|
//
|
|
if( !hThread ){
|
|
goto Fail;
|
|
}
|
|
|
|
//
|
|
// Thread handle is not needed.
|
|
//
|
|
CloseHandle( hThread );
|
|
return;
|
|
}
|
|
|
|
Fail:
|
|
|
|
if( !pServerData ){
|
|
|
|
vShowResourceError( hwnd );
|
|
|
|
} else {
|
|
|
|
iMessage( hwnd,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_PROP_CANNOT_VIEW,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
}
|
|
|
|
delete pServerData;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens the property sheet of specified server.
|
|
|
|
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 (e.g., "My HP LaserJet IIISi").
|
|
nCmdShow - Initial show state
|
|
lParam - May specify a sheet number to open to or if the high word
|
|
is non zero then dialog is modal.
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
VOID
|
|
vServerPropPages(
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszServerName,
|
|
IN INT iCmdShow,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
if (IsRunningWOW64())
|
|
{
|
|
vServerPropPagesWOW64(hwnd, pszServerName, iCmdShow, lParam);
|
|
}
|
|
else
|
|
{
|
|
vServerPropPagesNative(hwnd, pszServerName, iCmdShow, lParam);
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
aRoutine Name:
|
|
|
|
iServerPropPagesProc
|
|
|
|
Routine Description:
|
|
|
|
This is the routine called by the create thread call to display the
|
|
server property sheets.
|
|
|
|
Arguments:
|
|
|
|
pServerData - Pointer to the Server data set used by all property sheets.
|
|
|
|
Return Value:
|
|
|
|
TRUE - if the property sheets were displayed.
|
|
FALSE - error creating and displaying property sheets.
|
|
|
|
--*/
|
|
INT WINAPI
|
|
iServerPropPagesProc(
|
|
IN TServerData *pServerData ADOPT
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "iServerPropPagesProc\n") );
|
|
|
|
BOOL bStatus = pServerData->bRegisterWindow( PRINTER_PIDL_TYPE_PROPERTIES );
|
|
|
|
if( bStatus ){
|
|
|
|
//
|
|
// Check if the window is already present.
|
|
//
|
|
if( pServerData->bIsWindowPresent() ){
|
|
DBGMSG( DBG_TRACE, ( "iServerPropPagesProc: currently running.\n" ) );
|
|
bStatus = FALSE;
|
|
}
|
|
}
|
|
|
|
if( bStatus ) {
|
|
|
|
bStatus = pServerData->bLoad();
|
|
|
|
if( !bStatus ){
|
|
|
|
iMessage( pServerData->_hwnd,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_PROP_CANNOT_VIEW,
|
|
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
} else {
|
|
|
|
//
|
|
// Create the Server property sheet windows.
|
|
//
|
|
TServerWindows ServerWindows( pServerData );
|
|
|
|
//
|
|
// Were the document windows create
|
|
//
|
|
if( !VALID_OBJ( ServerWindows ) ){
|
|
|
|
iMessage( pServerData->_hwnd,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_PROP_CANNOT_VIEW,
|
|
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
|
|
bStatus = FALSE;
|
|
}
|
|
|
|
//
|
|
// Build the property pages.
|
|
//
|
|
if( bStatus ){
|
|
if( !ServerWindows.bBuildPages( ) ){
|
|
vShowResourceError( NULL );
|
|
bStatus = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Display the property pages.
|
|
//
|
|
if( bStatus ){
|
|
if( !ServerWindows.bDisplayPages( ) ){
|
|
vShowResourceError( NULL );
|
|
bStatus = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Ensure we release the document data.
|
|
// We have adopted pSeverData, so we must free it.
|
|
//
|
|
delete pServerData;
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
TServerData
|
|
|
|
Routine Description:
|
|
|
|
Server data property sheet constructor.
|
|
|
|
Arguments:
|
|
|
|
pszPrinterName - Name of printer or queue where jobs reside.
|
|
JobId - Job id to display properties of.
|
|
iCmdShow - Show dialog style.
|
|
lParam - Indicates which page to display initialy
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
|
|
TServerData::
|
|
TServerData(
|
|
IN LPCTSTR pszServerName,
|
|
IN INT iCmdShow,
|
|
IN LPARAM lParam,
|
|
IN HWND hwnd,
|
|
IN BOOL bModal
|
|
) : MSingletonWin( pszServerName, hwnd, bModal ),
|
|
_iCmdShow( iCmdShow ),
|
|
_uStartPage( (UINT)lParam ),
|
|
_bValid( FALSE ),
|
|
_hPrintServer( NULL ),
|
|
_hDefaultSmallIcon( NULL ),
|
|
_bCancelButtonIsClose( FALSE ),
|
|
_dwDriverVersion( 0 ),
|
|
_bRemoteDownLevel( FALSE ),
|
|
_bRebootRequired( FALSE )
|
|
{
|
|
if( !MSingletonWin::bValid( )){
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Retrieve icons.
|
|
//
|
|
LoadPrinterIcons( _strPrinterName, NULL, &_hDefaultSmallIcon );
|
|
|
|
SPLASSERT( _hDefaultSmallIcon );
|
|
|
|
//
|
|
// Set the server name to NULL if it's local.
|
|
//
|
|
_pszServerName = _strPrinterName.bEmpty() ? NULL : (LPCTSTR)_strPrinterName;
|
|
|
|
//
|
|
// Get the machine name.
|
|
//
|
|
vCreateMachineName( _strPrinterName,
|
|
_pszServerName ? FALSE : TRUE,
|
|
_strMachineName );
|
|
|
|
//
|
|
// Get the print servers driver version, the driver
|
|
// version corresponds to the actual spooler version, we
|
|
// are using this for downlevel detection.
|
|
//
|
|
if( !bGetCurrentDriver( _pszServerName, &_dwDriverVersion ) )
|
|
{
|
|
//
|
|
// Note this is not a fatal error, we won't have the
|
|
// add/delete/configure ports buttons enabled.
|
|
//
|
|
DBGMSG( DBG_WARN, ( "Get driver version failed.\n" ) );
|
|
}
|
|
|
|
//
|
|
// Check if we are remotely administering a downlevel machine
|
|
//
|
|
_bRemoteDownLevel = ( bIsRemote( _pszServerName ) && ( GetDriverVersion( _dwDriverVersion ) <= 2 ) ) ? TRUE : FALSE;
|
|
|
|
_bValid = TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
~TServerData
|
|
|
|
Routine Description:
|
|
|
|
Stores the document data back to the server.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
|
|
TServerData::
|
|
~TServerData(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Insure we close the print server.
|
|
//
|
|
if( _hPrintServer ){
|
|
ClosePrinter( _hPrintServer );
|
|
}
|
|
|
|
//
|
|
// Destroy the printer icon.
|
|
//
|
|
if( _hDefaultSmallIcon ){
|
|
DestroyIcon( _hDefaultSmallIcon );
|
|
}
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bValid
|
|
|
|
Routine Description:
|
|
|
|
Returns objects state.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE object is in valid state, FALSE object is not valid.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerData::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return _bValid;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
vCreateMachineName
|
|
|
|
Routine Description:
|
|
|
|
Create the machine name for display. bLocal indicates the
|
|
provided server name is for the local machine, Since a
|
|
local machine is often represented by the NULL pointer we
|
|
will get the computer name if a local server name is passed. If the
|
|
bLocal is false strPrinterName contains the name of the remote
|
|
printer server.
|
|
|
|
Arguments:
|
|
|
|
strServerName - Name of the print server.
|
|
bLocal - TRUE str server name is local, or FALSE strPrinterName is name of
|
|
remote print server.
|
|
strMachineName - Target of the fetched machine name.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
VOID
|
|
TServerData::
|
|
vCreateMachineName(
|
|
IN const TString &strServerName,
|
|
IN BOOL bLocal,
|
|
IN TString &strMachineName
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
LPCTSTR pszBuffer;
|
|
|
|
//
|
|
// If a server name was provided then set the title to
|
|
// the server name, otherwise get the computer name.
|
|
//
|
|
if( !bLocal ){
|
|
|
|
//
|
|
// Copy the server name.
|
|
//
|
|
bStatus DBGCHK = strMachineName.bUpdate( strServerName );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Server name is null, therefore it is the local machine.
|
|
//
|
|
bStatus DBGCHK = bGetMachineName( strMachineName );
|
|
}
|
|
|
|
//
|
|
// Remove any leading slashes.
|
|
//
|
|
pszBuffer = (LPCTSTR)strMachineName;
|
|
for( ; pszBuffer && (*pszBuffer == TEXT( '\\' )); pszBuffer++ )
|
|
;
|
|
|
|
//
|
|
// Update the name we display on the sheets.
|
|
//
|
|
bStatus DBGCHK = strMachineName.bUpdate( pszBuffer );
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bLoad
|
|
|
|
Routine Description:
|
|
|
|
Loads the property sheet specific data.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE - Data loaded successfully,
|
|
FALSE - Data was not loaded.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerData::
|
|
bLoad(
|
|
VOID
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerData::bLoad\n") );
|
|
|
|
//
|
|
// Attempt to open print server with full access.
|
|
//
|
|
TStatus Status;
|
|
DWORD dwAccess = 0;
|
|
Status DBGCHK = TPrinter::sOpenPrinter( pszServerName(),
|
|
&dwAccess,
|
|
&_hPrintServer );
|
|
|
|
if( Status == ERROR_SUCCESS ){
|
|
|
|
//
|
|
// Save administrator capability flag.
|
|
//
|
|
bAdministrator() = (dwAccess == SERVER_ALL_ACCESS);
|
|
|
|
//
|
|
// Get the default title from the resource file.
|
|
//
|
|
if( !_strTitle.bLoadString( ghInst, IDS_SERVER_SETTINGS_TITLE ) ){
|
|
DBGMSG( DBG_WARN, ( "strTitle().bLoadString failed with %d\n", GetLastError () ) );
|
|
vShowResourceError( hwnd() );
|
|
}
|
|
|
|
//
|
|
// Null terminate the title buffer.
|
|
//
|
|
TCHAR szTitle[kStrMax+kPrinterBufMax] = {0};
|
|
UINT nSize = COUNTOF( szTitle );
|
|
|
|
//
|
|
// Create the property sheet title.
|
|
//
|
|
if( pszServerName() ){
|
|
_tcscpy( szTitle, pszServerName() );
|
|
_tcscat( szTitle, TEXT( "\\" ) );
|
|
}
|
|
|
|
//
|
|
// Build the title buffer.
|
|
//
|
|
_tcscat( szTitle, _strTitle );
|
|
|
|
//
|
|
// Format the title similar to the shell.
|
|
//
|
|
ConstructPrinterFriendlyName( szTitle, szTitle, &nSize );
|
|
|
|
//
|
|
// Update the property sheet title.
|
|
//
|
|
if( !_strTitle.bUpdate( szTitle ) ){
|
|
DBGMSG( DBG_WARN, ( "strTitle().bUpdate failed with %d\n", GetLastError () ) );
|
|
vShowResourceError( hwnd() );
|
|
}
|
|
}
|
|
|
|
return Status == ERROR_SUCCESS;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bStore
|
|
|
|
Routine Description:
|
|
|
|
Stores the document data from back to the printer system.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE - Server data stored successfully,
|
|
FALSE - if document data was not stored.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerData::
|
|
bStore(
|
|
VOID
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Server Property Base Class
|
|
|
|
********************************************************************/
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
TServerProp
|
|
|
|
Routine Description:
|
|
|
|
Initialized the server property sheet base class
|
|
|
|
Arguments:
|
|
|
|
pServerData - Pointer to server data needed for all property sheets.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
TServerProp::
|
|
TServerProp(
|
|
IN TServerData* pServerData
|
|
) : _pServerData( pServerData )
|
|
{
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
~TServerProp
|
|
|
|
Routine Description:
|
|
|
|
Base class desctuctor.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
TServerProp::
|
|
~TServerProp(
|
|
)
|
|
{
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bValid
|
|
|
|
Routine Description:
|
|
|
|
Determis if an object is in a valid state.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE object is valid. FALSE object is not valid.
|
|
--*/
|
|
BOOL
|
|
TServerProp::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return ( _pServerData ) ? TRUE : FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
vCancelToClose
|
|
|
|
Routine Description:
|
|
|
|
Change the cancel button to close, the user has basically
|
|
made a change that cannot be undone using the cancel button.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
VOID
|
|
TServerProp::
|
|
vCancelToClose(
|
|
IN HWND hDlg
|
|
)
|
|
{
|
|
PropSheet_CancelToClose( GetParent( hDlg ) );
|
|
_pServerData->bCancelButtonIsClose() = TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerProp::
|
|
bHandleMessage(
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = TRUE;
|
|
|
|
UNREFERENCED_PARAMETER( wParam );
|
|
|
|
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;
|
|
|
|
//
|
|
// Save the data.
|
|
//
|
|
case WM_DESTROY:
|
|
bStatus = FALSE;
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
switch( ((LPNMHDR)lParam)->code )
|
|
{
|
|
//
|
|
// User switched to the next page.
|
|
//
|
|
case PSN_KILLACTIVE:
|
|
bStatus = bReadUI();
|
|
vSetDlgMsgResult( !bStatus );
|
|
//
|
|
// Must return true, to make the property sheet
|
|
// control look at the dlg message result.
|
|
//
|
|
bStatus = TRUE;
|
|
break;
|
|
|
|
//
|
|
// User has chosen the close or apply button.
|
|
//
|
|
case PSN_APPLY:
|
|
{
|
|
LPPSHNOTIFY pPSHNotify = (LPPSHNOTIFY)lParam;
|
|
|
|
//
|
|
// Save the UI to the system.
|
|
//
|
|
bStatus = bSaveUI();
|
|
|
|
//
|
|
// If there was a failure then switch to this page.
|
|
//
|
|
if( !bStatus )
|
|
{
|
|
//
|
|
// Switch to page with the error.
|
|
//
|
|
PropSheet_SetCurSelByID( GetParent( _hDlg ), uGetPageId() );
|
|
}
|
|
|
|
//
|
|
// If the lParam is true the close button was used to
|
|
// dismiss the dialog. Let the dialog exit if the close
|
|
// button was clicked and one of the dialogs failed.
|
|
//
|
|
if( pPSHNotify->lParam == TRUE && bStatus == FALSE )
|
|
{
|
|
//
|
|
// If the cancel button is has the closed text, then
|
|
// prompt the user if they want to exit on failure.
|
|
// The cancel button state is stored in the server data
|
|
// because it has to be global to all property sheets.
|
|
//
|
|
if( _pServerData->bCancelButtonIsClose() )
|
|
{
|
|
//
|
|
// Display the error message.
|
|
//
|
|
if( iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_WANT_TO_EXIT,
|
|
MB_YESNO|MB_ICONSTOP,
|
|
kMsgNone,
|
|
NULL ) == IDYES )
|
|
{
|
|
bStatus = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Indicate the return value to the property sheet control
|
|
//
|
|
vSetDlgMsgResult( bStatus == FALSE ? PSNRET_INVALID_NOCHANGEPAGE : PSNRET_NOERROR );
|
|
|
|
//
|
|
// Must return true, to make the property sheet
|
|
// control look at the dlg message result.
|
|
//
|
|
bStatus = TRUE;
|
|
}
|
|
|
|
break;
|
|
|
|
//
|
|
// Indicate the user chose the cancel button.
|
|
//
|
|
case PSN_QUERYCANCEL:
|
|
bStatus = FALSE;
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Forms Server Property Sheet.
|
|
|
|
********************************************************************/
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
TServerForms
|
|
|
|
Routine Description:
|
|
|
|
Document property sheet derived class.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
TServerForms::
|
|
TServerForms(
|
|
IN TServerData *pServerData
|
|
) : TServerProp( pServerData )
|
|
{
|
|
//
|
|
// This does forms specific initialization.
|
|
//
|
|
_p = FormsInit( pServerData->pszServerName(),
|
|
pServerData->hPrintServer(),
|
|
pServerData->bAdministrator(),
|
|
pServerData->strMachineName() );
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
~TServerForms
|
|
|
|
Routine Description:
|
|
|
|
Document derived class destructor.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
|
|
TServerForms::
|
|
~TServerForms(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Forms specific termination.
|
|
//
|
|
FormsFini( _p );
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerForms::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return ( _p ) ? TRUE : FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerForms::
|
|
bSetUI(
|
|
VOID
|
|
)
|
|
|
|
{
|
|
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
|
|
TServerForms::
|
|
bReadUI(
|
|
VOID
|
|
)
|
|
{
|
|
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
|
|
TServerForms::
|
|
bSaveUI(
|
|
VOID
|
|
)
|
|
{
|
|
// force a save form event.
|
|
bHandleMessage( WM_COMMAND,
|
|
(WPARAM)MAKELPARAM( IDD_FM_PB_SAVEFORM, kMagic ),
|
|
(LPARAM)GetDlgItem( _hDlg, IDD_FM_PB_SAVEFORM ));
|
|
|
|
// check to see if failed
|
|
return (ERROR_SUCCESS == Forms_GetLastError(_p));
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bHandleMessage
|
|
|
|
Routine Description:
|
|
|
|
Server 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
|
|
TServerForms::
|
|
bHandleMessage(
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
LONG_PTR PrevValue;
|
|
|
|
//
|
|
// !!Hack!!
|
|
//
|
|
// This is code to get the borrowed forms dialog
|
|
// code from printman, to work. It is saving our "this" pointer and
|
|
// placing the forms specific data in the GWL_USERDATA.
|
|
//
|
|
PrevValue = GetWindowLongPtr( _hDlg, GWLP_USERDATA );
|
|
|
|
SetWindowLongPtr( _hDlg, GWLP_USERDATA, (LONG_PTR)_p );
|
|
|
|
if( uMsg == WM_INITDIALOG )
|
|
{
|
|
lParam = (LPARAM)_p;
|
|
}
|
|
|
|
bStatus = FormsDlg( _hDlg, uMsg, wParam, lParam );
|
|
|
|
SetWindowLongPtr( _hDlg, GWLP_USERDATA, PrevValue );
|
|
|
|
//
|
|
// If the message was handled - check to call PSM_CANCELTOCLOSE
|
|
//
|
|
if( bStatus && Forms_IsThereCommitedChanges(_p) )
|
|
{
|
|
vCancelToClose( _hDlg );
|
|
}
|
|
|
|
//
|
|
// If the message was not handled pass it on to the derrived base class.
|
|
//
|
|
if( !bStatus )
|
|
{
|
|
bStatus = TServerProp::bHandleMessage( uMsg, wParam, lParam );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Settings Server Property Sheet.
|
|
|
|
********************************************************************/
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
TServerSettings
|
|
|
|
Routine Description:
|
|
|
|
Document property sheet derived class.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
TServerSettings::
|
|
TServerSettings(
|
|
IN TServerData *pServerData
|
|
) : TServerProp( pServerData ),
|
|
_bBeepErrorJobs( FALSE ),
|
|
_bEventLogging( FALSE ),
|
|
_bNotifyPrintedJobs( FALSE ),
|
|
_bNotifyLocalPrintedJobs( FALSE ),
|
|
_bNotifyNetworkPrintedJobs( TRUE ),
|
|
_bNotifyPrintedJobsComputer( FALSE ),
|
|
_bChanged( FALSE ),
|
|
_bDownLevelServer( TRUE ),
|
|
_bNewOptionSupport( TRUE )
|
|
{
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
~TServerSettings
|
|
|
|
Routine Description:
|
|
|
|
Document derived class destructor.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
|
|
TServerSettings::
|
|
~TServerSettings(
|
|
VOID
|
|
)
|
|
{
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerSettings::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return TServerProp::bValid();
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerSettings::
|
|
bSetUI(
|
|
VOID
|
|
)
|
|
|
|
{
|
|
return bSetUI( kServerAttributesLoad );
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bSetUI
|
|
|
|
Routine Description:
|
|
|
|
Loads the property sheet dialog with the document data
|
|
information.
|
|
|
|
Arguments:
|
|
|
|
The specified load type.
|
|
|
|
Return Value:
|
|
|
|
TRUE if data loaded successfully, FALSE if error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerSettings::
|
|
bSetUI(
|
|
INT LoadType
|
|
)
|
|
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerSettings::bSetUI\n") );
|
|
|
|
//
|
|
// Set the printer title.
|
|
//
|
|
if( !bSetEditText( _hDlg, IDC_SERVER_NAME, _pServerData->strMachineName() ))
|
|
return FALSE;
|
|
|
|
//
|
|
// Load the server attributes into the class variables. If this fails
|
|
// it is assumed the machine is either a downlevel server or something
|
|
// went wrong.
|
|
//
|
|
if( sServerAttributes( LoadType ) == kStatusError ){
|
|
|
|
//
|
|
// Disable the controls.
|
|
//
|
|
vEnable( FALSE );
|
|
|
|
//
|
|
// Indicate the server is not compatible.
|
|
//
|
|
_bDownLevelServer = FALSE;
|
|
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_SETTINGS_NOT_AVAILABLE,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgNone,
|
|
NULL );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Set the spool directory edit control.
|
|
//
|
|
if( !bSetEditText( _hDlg, IDC_SERVER_SPOOL_DIRECTORY, _strSpoolDirectory ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Save a copy of the origianl spool directory.
|
|
//
|
|
if( !_strSpoolDirectoryOrig.bUpdate( _strSpoolDirectory ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Reset the changed flag, the message handler sees a edit control
|
|
// change message when we set the spool directory.
|
|
//
|
|
_bChanged = FALSE;
|
|
|
|
//
|
|
// Set check box states.
|
|
//
|
|
vSetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_ERROR, _bEventLogging & EVENTLOG_ERROR_TYPE );
|
|
vSetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_WARN, _bEventLogging & EVENTLOG_WARNING_TYPE );
|
|
vSetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_INFO, _bEventLogging & EVENTLOG_INFORMATION_TYPE );
|
|
vSetCheck( _hDlg, IDC_SERVER_REMOTE_JOB_ERRORS, _bBeepErrorJobs );
|
|
vSetCheck( _hDlg, IDC_SERVER_JOB_NOTIFY, _bNotifyPrintedJobs );
|
|
vSetCheck( _hDlg, IDC_SERVER_LOCAL_JOB_NOTIFY, _bNotifyLocalPrintedJobs );
|
|
vSetCheck( _hDlg, IDC_SERVER_NETWORK_JOB_NOTIFY, _bNotifyNetworkPrintedJobs );
|
|
vSetCheck( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER, _bNotifyPrintedJobsComputer );
|
|
|
|
//
|
|
// In remote case, we don't show the "notify user" check box and move the lower controls up.
|
|
//
|
|
if( bIsRemote( _pServerData->pszServerName() ) )
|
|
{
|
|
RECT rc;
|
|
RECT rcUpper;
|
|
int deltaY;
|
|
|
|
ShowWindow( GetDlgItem( _hDlg, IDC_SERVER_LOCAL_JOB_NOTIFY ), SW_HIDE );
|
|
ShowWindow( GetDlgItem( _hDlg, IDC_SERVER_NETWORK_JOB_NOTIFY ), SW_HIDE );
|
|
|
|
GetWindowRect( GetDlgItem( _hDlg, IDC_SERVER_NETWORK_JOB_NOTIFY ), &rc );
|
|
GetWindowRect( GetDlgItem( _hDlg, IDC_SERVER_REMOTE_JOB_ERRORS ), &rcUpper );
|
|
deltaY = rcUpper.bottom - rc.bottom;
|
|
|
|
MoveWindowWrap( GetDlgItem( _hDlg, IDC_DOWNLEVEL_LINE ), 0, deltaY );
|
|
MoveWindowWrap( GetDlgItem( _hDlg, IDC_DOWNLEVEL_TEXT ), 0, deltaY );
|
|
MoveWindowWrap( GetDlgItem( _hDlg, IDC_SERVER_JOB_NOTIFY ), 0, deltaY );
|
|
MoveWindowWrap( GetDlgItem( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER ), 0, deltaY );
|
|
}
|
|
|
|
//
|
|
// Only NT 5.0 and greater supports the SPLREG_NET_POPUP_TO_COMPUTER
|
|
//
|
|
if( !_bNewOptionSupport )
|
|
{
|
|
ShowWindow( GetDlgItem( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER ), SW_HIDE);
|
|
}
|
|
|
|
//
|
|
// Enable of disable the UI based on the administrator state.
|
|
//
|
|
vEnable( _pServerData->bAdministrator() );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID
|
|
TServerSettings::
|
|
vEnable(
|
|
BOOL bState
|
|
)
|
|
{
|
|
//
|
|
// Set the UI control state.
|
|
//
|
|
vEnableCtl( _hDlg, IDC_SERVER_EVENT_LOGGING_ERROR, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_EVENT_LOGGING_WARN, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_EVENT_LOGGING_INFO, bState );
|
|
vEnableCtl( _hDlg, IDC_SPOOL_FOLDER_TEXT, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_SPOOL_DIRECTORY, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_REMOTE_JOB_ERRORS, bState );
|
|
vEnableCtl( _hDlg, IDC_DOWNLEVEL_TEXT, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_JOB_NOTIFY, bState );
|
|
vEnableCtl( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER, bState && _bNotifyPrintedJobs );
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bReadUI
|
|
|
|
Routine Description:
|
|
|
|
Read the UI data storing it back to this object.
|
|
|
|
Arguments:
|
|
|
|
Nothing data is contained with in the class.
|
|
|
|
Return Value:
|
|
|
|
TRUE if data is read successfully, FALSE if error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerSettings::
|
|
bReadUI(
|
|
VOID
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerSettings::bReadUI\n") );
|
|
|
|
TStatusB bStatus;
|
|
|
|
//
|
|
// Read the spool directory edit box.
|
|
//
|
|
bStatus DBGCHK = bGetEditText( _hDlg, IDC_SERVER_SPOOL_DIRECTORY, _strSpoolDirectory );
|
|
|
|
//
|
|
// Do minor validation on the spool directory.
|
|
//
|
|
if( _strSpoolDirectory.bEmpty() && _bDownLevelServer )
|
|
{
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_SETTINGS_INVALID_DIR,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgNone,
|
|
NULL );
|
|
|
|
bStatus DBGNOCHK = FALSE;
|
|
}
|
|
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Read settings check boxes.
|
|
//
|
|
_bEventLogging = bGetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_ERROR ) << 0;
|
|
_bEventLogging |= bGetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_WARN ) << 1;
|
|
_bEventLogging |= bGetCheck( _hDlg, IDC_SERVER_EVENT_LOGGING_INFO ) << 2;
|
|
_bBeepErrorJobs = bGetCheck( _hDlg, IDC_SERVER_REMOTE_JOB_ERRORS );
|
|
_bNotifyLocalPrintedJobs = bGetCheck( _hDlg, IDC_SERVER_LOCAL_JOB_NOTIFY );
|
|
_bNotifyNetworkPrintedJobs = bGetCheck( _hDlg, IDC_SERVER_NETWORK_JOB_NOTIFY );
|
|
_bNotifyPrintedJobs = bGetCheck( _hDlg, IDC_SERVER_JOB_NOTIFY );
|
|
_bNotifyPrintedJobsComputer = bGetCheck( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bSaveUI
|
|
|
|
Routine Description:
|
|
|
|
Saves the UI data with some API call 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
|
|
TServerSettings::
|
|
bSaveUI(
|
|
VOID
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerSettings::bSaveUI\n") );
|
|
|
|
BOOL bStatus = TRUE;
|
|
BOOL bErrorShown = FALSE;
|
|
|
|
//
|
|
// If data was chagned save the settings.
|
|
//
|
|
if( _bChanged && _bDownLevelServer ) {
|
|
|
|
if( lstrcmpi(_strSpoolDirectoryOrig, _strSpoolDirectory) ) {
|
|
|
|
//
|
|
// The spooler folder has been changed. Warn the user
|
|
// for potential loose of the current printing jobs.
|
|
//
|
|
INT iResult = iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_SERVER_PROPERTIES_CHANGESPOOLFOLDER_WARN,
|
|
MB_YESNO|MB_ICONEXCLAMATION|MB_DEFBUTTON2,
|
|
kMsgNone,
|
|
NULL );
|
|
|
|
if( IDNO == iResult ) {
|
|
|
|
//
|
|
// The user did not what to continue, don't close the dialog.
|
|
//
|
|
SetLastError( ERROR_CANCELLED );
|
|
bStatus = FALSE;
|
|
|
|
}
|
|
}
|
|
|
|
if( bStatus ) {
|
|
|
|
switch( sServerAttributes( kServerAttributesStore ) ){
|
|
|
|
case kStatusCannotSaveUserNotification:
|
|
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_GENERIC,
|
|
MB_OK|MB_ICONHAND,
|
|
kMsgNone,
|
|
NULL );
|
|
|
|
bStatus = FALSE;
|
|
bErrorShown = TRUE;
|
|
break;
|
|
|
|
case kStatusInvalidSpoolDirectory:
|
|
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_SETTINGS_INVALID_DIR,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgNone,
|
|
NULL );
|
|
//
|
|
// Set focus to control with error.
|
|
//
|
|
SetFocus( GetDlgItem( _hDlg, IDC_SERVER_SPOOL_DIRECTORY ) );
|
|
bStatus = FALSE;
|
|
bErrorShown = TRUE;
|
|
break;
|
|
|
|
case kStatusSuccess:
|
|
|
|
_bChanged = FALSE;
|
|
bStatus = TRUE;
|
|
break;
|
|
|
|
case kStatusError:
|
|
default:
|
|
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
if( bStatus && _pServerData->bAdministrator() ) {
|
|
|
|
//
|
|
// Update the new original spooler directory
|
|
//
|
|
bStatus = _strSpoolDirectoryOrig.bUpdate( _strSpoolDirectory );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !bStatus ) {
|
|
|
|
//
|
|
// Display the error message.
|
|
//
|
|
if( GetLastError() != ERROR_CANCELLED && !bErrorShown ) {
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_SERVER_SETTINGS_SAVE,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
}
|
|
}
|
|
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
sServerAttributes
|
|
|
|
Routine Description:
|
|
|
|
Loads and stores server attributes.
|
|
|
|
Arguments:
|
|
|
|
Direction flag either kStore or kLoad pr kDefault
|
|
|
|
Return Value:
|
|
|
|
Status values, see EStatus for for details.
|
|
|
|
--*/
|
|
|
|
INT
|
|
TServerSettings::
|
|
sServerAttributes(
|
|
INT iFlag
|
|
)
|
|
{
|
|
INT iStatus;
|
|
TStatusH hr;
|
|
|
|
//
|
|
// Create the printer data access class.
|
|
//
|
|
TPrinterDataAccess Data( _pServerData->_hPrintServer );
|
|
TPersist NotifyUser( gszPrinterPositions, TPersist::kCreate|TPersist::kRead|TPersist::kWrite );
|
|
|
|
//
|
|
// Relax the return type checking, BOOL are not REG_DWORD but REG_BINARY
|
|
//
|
|
Data.RelaxReturnTypeCheck( TRUE );
|
|
|
|
switch( iFlag )
|
|
{
|
|
|
|
//
|
|
// Load from the spooler
|
|
//
|
|
case kServerAttributesLoad:
|
|
|
|
hr DBGCHK = Data.Get( SPLREG_DEFAULT_SPOOL_DIRECTORY, _strSpoolDirectory );
|
|
hr DBGCHK = Data.Get( SPLREG_BEEP_ENABLED, _bBeepErrorJobs );
|
|
hr DBGCHK = Data.Get( SPLREG_EVENT_LOG, _bEventLogging );
|
|
hr DBGCHK = Data.Get( SPLREG_NET_POPUP, _bNotifyPrintedJobs );
|
|
|
|
hr DBGCHK = NotifyUser.bRead( gszLocalPrintNotification, _bNotifyLocalPrintedJobs ) ? S_OK : E_FAIL;
|
|
hr DBGCHK = NotifyUser.bRead( gszNetworkPrintNotification, _bNotifyNetworkPrintedJobs ) ? S_OK : E_FAIL;
|
|
hr DBGCHK = Data.Get( SPLREG_NET_POPUP_TO_COMPUTER, _bNotifyPrintedJobsComputer );
|
|
|
|
//
|
|
// If we fail reading the net popup to computer with invalid parameter
|
|
// we are talking to a downlevel machine pre nt 5.0 machine. If this
|
|
// is the case we simple do not show this option in the UI and continue
|
|
// normally.
|
|
//
|
|
if( FAILED( hr ) && HRESULT_CODE( hr ) == ERROR_INVALID_PARAMETER )
|
|
{
|
|
_bNewOptionSupport = FALSE;
|
|
}
|
|
|
|
//
|
|
// If were are talking to a downlevel machine pre nt 4.0,
|
|
// get printer data calls will fail with error invalid handle. We
|
|
// only check the last value read, since this error code should never
|
|
// happen on any calls to get printer data.
|
|
//
|
|
if( FAILED( hr ) && HRESULT_CODE( hr ) == ERROR_INVALID_HANDLE )
|
|
{
|
|
iStatus = kStatusError;
|
|
}
|
|
else
|
|
{
|
|
iStatus = kStatusSuccess;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// Store to the spooler
|
|
//
|
|
case kServerAttributesStore:
|
|
|
|
//
|
|
// We save this data for local case
|
|
//
|
|
if( !bIsRemote( _pServerData->pszServerName() ) && VALID_OBJ( NotifyUser ) )
|
|
{
|
|
if( !NotifyUser.bWrite( gszLocalPrintNotification, _bNotifyLocalPrintedJobs ) ||
|
|
!NotifyUser.bWrite( gszNetworkPrintNotification, _bNotifyNetworkPrintedJobs ) )
|
|
{
|
|
iStatus = kStatusCannotSaveUserNotification;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the current user is not administrator, we just return
|
|
//
|
|
if( !_pServerData->bAdministrator() )
|
|
{
|
|
iStatus = kStatusSuccess;
|
|
break;
|
|
}
|
|
|
|
hr DBGCHK = Data.Set( SPLREG_DEFAULT_SPOOL_DIRECTORY, _strSpoolDirectory );
|
|
|
|
if( FAILED( hr ) )
|
|
{
|
|
iStatus = kStatusInvalidSpoolDirectory;
|
|
}
|
|
else
|
|
{
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
hr DBGCHK = Data.Set( SPLREG_BEEP_ENABLED, _bBeepErrorJobs );
|
|
}
|
|
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
hr DBGCHK = Data.Set( SPLREG_EVENT_LOG, _bEventLogging );
|
|
}
|
|
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
hr DBGCHK = Data.Set( SPLREG_NET_POPUP, _bNotifyPrintedJobs );
|
|
}
|
|
|
|
if( SUCCEEDED( hr ) && _bNewOptionSupport )
|
|
{
|
|
hr DBGCHK = Data.Set( SPLREG_NET_POPUP_TO_COMPUTER, _bNotifyPrintedJobsComputer );
|
|
}
|
|
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
iStatus = kStatusSuccess;
|
|
|
|
if( HRESULT_CODE( hr ) == ERROR_SUCCESS_RESTART_REQUIRED )
|
|
{
|
|
_pServerData->_bRebootRequired = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iStatus = kStatusError;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
//
|
|
// Load defaults from the spooler.
|
|
//
|
|
case kServerAttributesDefault:
|
|
|
|
iStatus = kStatusSuccess;
|
|
break;
|
|
|
|
//
|
|
// Default is to return an error.
|
|
//
|
|
default:
|
|
|
|
iStatus = kStatusError;
|
|
break;
|
|
}
|
|
|
|
return iStatus;
|
|
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bHandleMessage
|
|
|
|
Routine Description:
|
|
|
|
Server 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
|
|
TServerSettings::
|
|
bHandleMessage(
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
BOOL bChanged = FALSE;
|
|
|
|
switch( uMsg ){
|
|
|
|
case WM_COMMAND:
|
|
|
|
//
|
|
// Monitor changes in the UI to highlight the apply button.
|
|
//
|
|
switch( GET_WM_COMMAND_ID( wParam, lParam ) ) {
|
|
|
|
case IDC_SERVER_SPOOL_DIRECTORY:
|
|
bChanged = GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE;
|
|
bStatus = TRUE;
|
|
break;
|
|
|
|
case IDC_SERVER_REMOTE_JOB_ERRORS:
|
|
case IDC_SERVER_LOCAL_JOB_NOTIFY:
|
|
case IDC_SERVER_NETWORK_JOB_NOTIFY:
|
|
case IDC_SERVER_JOB_NOTIFY:
|
|
case IDC_SERVER_JOB_NOTIFY_COMPUTER:
|
|
case IDC_SERVER_EVENT_LOGGING_ERROR:
|
|
case IDC_SERVER_EVENT_LOGGING_WARN:
|
|
case IDC_SERVER_EVENT_LOGGING_INFO:
|
|
{
|
|
if( IDC_SERVER_JOB_NOTIFY == GET_WM_COMMAND_ID( wParam, lParam ) )
|
|
{
|
|
vEnableCtl( _hDlg, IDC_SERVER_JOB_NOTIFY_COMPUTER,
|
|
bGetCheck( _hDlg, IDC_SERVER_JOB_NOTIFY ) );
|
|
}
|
|
|
|
bChanged = TRUE;
|
|
bStatus = TRUE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If something changed enable the apply button.
|
|
//
|
|
if( bChanged ){
|
|
_bChanged = TRUE;
|
|
PropSheet_Changed( GetParent( _hDlg ), _hDlg );
|
|
}
|
|
|
|
//
|
|
// If the message was not handled let the base class handle it.
|
|
//
|
|
if( bStatus == FALSE )
|
|
bStatus = TServerProp::bHandleMessage( uMsg, wParam, lParam );
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Port selection.
|
|
|
|
********************************************************************/
|
|
TServerPorts::
|
|
TServerPorts(
|
|
IN TServerData *pServerData
|
|
) : TServerProp( pServerData )
|
|
{
|
|
}
|
|
|
|
TServerPorts::
|
|
~TServerPorts(
|
|
VOID
|
|
)
|
|
{
|
|
}
|
|
|
|
BOOL
|
|
TServerPorts::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return ( TServerProp::bValid() && _PortsLV.bValid() );
|
|
}
|
|
|
|
BOOL
|
|
TServerPorts::
|
|
bReadUI(
|
|
VOID
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
TServerPorts::
|
|
bSaveUI(
|
|
VOID
|
|
)
|
|
{
|
|
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
|
|
TServerPorts::
|
|
bSetUI(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Set the printer title.
|
|
//
|
|
if( !bSetEditText( _hDlg, IDC_SERVER_NAME, _pServerData->strMachineName() ))
|
|
{
|
|
vShowUnexpectedError( _pServerData->hwnd(), IDS_SERVER_PROPERTIES_TITLE );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Initialize the ports listview.
|
|
//
|
|
if( !_PortsLV.bSetUI( GetDlgItem( _hDlg, IDC_PORTS ), FALSE, FALSE, TRUE, _hDlg, 0, 0, IDC_PORT_DELETE ) )
|
|
{
|
|
DBGMSG( DBG_WARN, ( "ServerPort.vSetUI: failed %d\n", GetLastError( )));
|
|
vShowUnexpectedError( _pServerData->hwnd(), IDS_SERVER_PROPERTIES_TITLE );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Load ports into the view.
|
|
//
|
|
if( !_PortsLV.bReloadPorts( _pServerData->pszServerName() ) )
|
|
{
|
|
DBGMSG( DBG_WARN, ( "ServerPort.vSetUI: bReloadPorts failed %d\n", GetLastError( )));
|
|
vShowUnexpectedError( _pServerData->hwnd(), IDS_SERVER_PROPERTIES_TITLE );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Select the first item
|
|
//
|
|
_PortsLV.vSelectItem( 0 );
|
|
|
|
//
|
|
// Adding / deleting / configuring ports is not supported on remote downlevel machines.
|
|
//
|
|
if( !_pServerData->bAdministrator() || _pServerData->bRemoteDownLevel() )
|
|
{
|
|
//
|
|
// Disable things if not administrator.
|
|
//
|
|
vEnableCtl( _hDlg, IDC_PORT_CREATE, FALSE );
|
|
vEnableCtl( _hDlg, IDC_PORT_DELETE, FALSE );
|
|
vEnableCtl( _hDlg, IDC_PROPERTIES, FALSE );
|
|
}
|
|
|
|
//
|
|
// Bidi support is currently disabled.
|
|
//
|
|
ShowWindow( GetDlgItem( _hDlg, IDC_ENABLE_BIDI ), SW_HIDE );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bHandleMessage
|
|
|
|
Routine Description:
|
|
|
|
Server 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
|
|
TServerPorts::
|
|
bHandleMessage(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
|
|
switch( uMsg ){
|
|
|
|
case WM_COMMAND:
|
|
switch( GET_WM_COMMAND_ID( wParam, lParam ) ){
|
|
|
|
case IDC_PORT_DELETE:
|
|
{
|
|
//
|
|
// Delete the selected port.
|
|
//
|
|
HWND hwnd = GetDlgItem( _hDlg, IDC_PORT_DELETE );
|
|
|
|
//
|
|
// We will only delete the port if the button is enabled, this check is
|
|
// necessary if the user uses the delete key on the keyboard to delete
|
|
// the port.
|
|
//
|
|
if( IsWindowEnabled( hwnd ) )
|
|
{
|
|
bStatus = _PortsLV.bDeletePorts( _hDlg, _pServerData->pszServerName( ));
|
|
|
|
if( bStatus )
|
|
{
|
|
SetFocus( hwnd );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_PROPERTIES:
|
|
|
|
//
|
|
// Configure the selected port.
|
|
//
|
|
bStatus = _PortsLV.bConfigurePort( _hDlg, _pServerData->pszServerName( ));
|
|
SetFocus( GetDlgItem( _hDlg, IDC_PROPERTIES ) );
|
|
break;
|
|
|
|
case IDC_PORT_CREATE: {
|
|
//
|
|
// Create add ports class.
|
|
//
|
|
TAddPort AddPort( _hDlg,
|
|
_pServerData->pszServerName(),
|
|
TRUE );
|
|
|
|
//
|
|
// Insure the add port was created successfully.
|
|
//
|
|
bStatus = VALID_OBJ( AddPort );
|
|
|
|
if( !bStatus ) {
|
|
|
|
vShowUnexpectedError( _hDlg, TAddPort::kErrorMessage );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Interact with the Add Ports dialog.
|
|
//
|
|
bStatus = AddPort.bDoModal();
|
|
|
|
if( bStatus ){
|
|
|
|
//
|
|
// Load the machine's ports into the listview.
|
|
//
|
|
bStatus = _PortsLV.bReloadPorts( _pServerData->pszServerName( ), TRUE );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
|
|
//
|
|
// Handle any ports list view messages.
|
|
//
|
|
switch( wParam )
|
|
{
|
|
case IDC_PORTS:
|
|
|
|
//
|
|
// Enable/disable buttons depending on the current status
|
|
//
|
|
if( _pServerData->bAdministrator() && ( ((LPNMHDR)lParam)->code == LVN_ITEMCHANGED ) )
|
|
{
|
|
if( _pServerData->bRemoteDownLevel() )
|
|
{
|
|
// remote or downlevel case - all buttons will be disabled
|
|
vEnableCtl( _hDlg, IDC_PORT_CREATE, FALSE );
|
|
vEnableCtl( _hDlg, IDC_PORT_DELETE, FALSE );
|
|
vEnableCtl( _hDlg, IDC_PROPERTIES, FALSE );
|
|
}
|
|
else if( 0 == _PortsLV.cSelectedItems() )
|
|
{
|
|
// no selection case. disable config & delete buttons
|
|
vEnableCtl( _hDlg, IDC_PORT_CREATE, TRUE );
|
|
vEnableCtl( _hDlg, IDC_PORT_DELETE, FALSE );
|
|
vEnableCtl( _hDlg, IDC_PROPERTIES, FALSE );
|
|
}
|
|
else if( 1 == _PortsLV.cSelectedItems() )
|
|
{
|
|
// only one port is selected - enable all buttons
|
|
vEnableCtl( _hDlg, IDC_PORT_CREATE, TRUE );
|
|
vEnableCtl( _hDlg, IDC_PORT_DELETE, TRUE );
|
|
vEnableCtl( _hDlg, IDC_PROPERTIES, TRUE );
|
|
}
|
|
else
|
|
{
|
|
// many ports are selected and we are not in remote and/or downlevel case
|
|
// enable only the create and delete buttons
|
|
vEnableCtl( _hDlg, IDC_PORT_CREATE, TRUE );
|
|
vEnableCtl( _hDlg, IDC_PORT_DELETE, TRUE );
|
|
vEnableCtl( _hDlg, IDC_PROPERTIES, FALSE );
|
|
}
|
|
}
|
|
|
|
(VOID)_PortsLV.bHandleNotifyMessage( lParam );
|
|
|
|
bStatus = FALSE;
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
|
|
}
|
|
|
|
//
|
|
// If the message was handled.
|
|
//
|
|
if( bStatus != FALSE )
|
|
{
|
|
vCancelToClose( _hDlg );
|
|
return bStatus;
|
|
}
|
|
|
|
//
|
|
// If the message was not handled pass it on to the base class.
|
|
//
|
|
if( bStatus == FALSE )
|
|
bStatus = TServerProp::bHandleMessage( uMsg, wParam, lParam );
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Server Driver Administration.
|
|
|
|
********************************************************************/
|
|
TServerDrivers::
|
|
TServerDrivers(
|
|
IN TServerData *pServerData
|
|
) : TServerProp( pServerData ),
|
|
_bChanged( FALSE ),
|
|
_bCanRemoveDrivers( TRUE )
|
|
{
|
|
}
|
|
|
|
TServerDrivers::
|
|
~TServerDrivers(
|
|
VOID
|
|
)
|
|
{
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return TServerProp::bValid() && VALID_OBJ( _DriversLV );
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bReadUI(
|
|
VOID
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bSaveUI
|
|
|
|
Routine Description:
|
|
|
|
Save the contenst of the UI to the system.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if save was successful, FALSE if error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerDrivers::
|
|
bSaveUI(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Display the hour glass the refresh may take awhile.
|
|
//
|
|
TWaitCursor Cur;
|
|
|
|
//
|
|
// Create a driver noitfy.
|
|
//
|
|
TServerDriverNotify Notify ( this );
|
|
|
|
//
|
|
// Install / Remove / Update any drivers.
|
|
//
|
|
(VOID)_DriversLV.bSendDriverInfoNotification( Notify );
|
|
|
|
//
|
|
// Refesh the drivers list.
|
|
//
|
|
TStatusB bStatus;
|
|
bStatus DBGCHK = _DriversLV.bRefresh();
|
|
if( !bStatus )
|
|
{
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_ERR_DRIVERS_NOT_REFRESHED,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
}
|
|
|
|
//
|
|
// Sort the environment column.
|
|
//
|
|
(VOID)_DriversLV.bSortColumn( TDriversLV::kEnvironmentColumn );
|
|
|
|
//
|
|
// Sort the driver name.
|
|
//
|
|
(VOID)_DriversLV.bSortColumn( TDriversLV::kDriverNameColumn );
|
|
|
|
//
|
|
// Select the first item in the list view.
|
|
//
|
|
_DriversLV.vSelectItem( 0 );
|
|
|
|
//
|
|
// Return success only if there was not a falure and the refresh succeeded.
|
|
//
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerDrivers::
|
|
bSetUI(
|
|
VOID
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
|
|
//
|
|
// Set the printer title.
|
|
//
|
|
bStatus DBGCHK = bSetEditText( _hDlg, IDC_SERVER_NAME, _pServerData->strMachineName() );
|
|
|
|
//
|
|
// If we are an administrator handle the delete message.
|
|
//
|
|
UINT idRemove = _pServerData->bAdministrator() ? IDC_REMOVE_DRIVER : 0;
|
|
|
|
//
|
|
// Set the drivers list view.
|
|
//
|
|
bStatus DBGCHK = _DriversLV.bSetUI( _pServerData->pszServerName(), _hDlg, IDC_MORE_DETAILS, IDC_ITEM_SELECTED, idRemove );
|
|
|
|
//
|
|
// Load the list view with driver data.
|
|
//
|
|
bStatus DBGCHK = _DriversLV.bRefresh();
|
|
|
|
//
|
|
// Set the default sort order.
|
|
//
|
|
bStatus DBGCHK = _DriversLV.bSortColumn( TDriversLV::kEnvironmentColumn );
|
|
|
|
//
|
|
// Sort the driver name.
|
|
//
|
|
bStatus DBGCHK = _DriversLV.bSortColumn( TDriversLV::kDriverNameColumn );
|
|
|
|
//
|
|
// Update the button state.
|
|
//
|
|
vUpdateButtons();
|
|
|
|
//
|
|
// Select the first item in the list view.
|
|
//
|
|
_DriversLV.vSelectItem( 0 );
|
|
|
|
//
|
|
// If we are talking to a down level spooler then deleting printer drivers
|
|
// can only be done with a call to DeletePrinterDriver, no ex version exists.
|
|
// Because DeletePrinterDriver only allows the caller to delete all drivers
|
|
// of a specific environment with out regards to version, we have decided to
|
|
// not allow removing printer drivers on down level machines. In addition
|
|
// DeletePrinterDriver is as kind of broken since it does not actually remove
|
|
// the driver files, it only removes the registry entries.
|
|
//
|
|
if( GetDriverVersion( _pServerData->dwDriverVersion() ) <= 2 )
|
|
{
|
|
_bCanRemoveDrivers = FALSE;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
vUpdateButtons
|
|
|
|
Routine Description:
|
|
|
|
Update the dialog buttons.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
VOID
|
|
TServerDrivers::
|
|
vUpdateButtons(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Default is the details button disabled.
|
|
//
|
|
vEnableCtl( _hDlg, IDC_MORE_DETAILS, FALSE );
|
|
vEnableCtl( _hDlg, IDC_UPDATE_DRIVER, FALSE );
|
|
vEnableCtl( _hDlg, IDC_REMOVE_DRIVER, FALSE );
|
|
|
|
//
|
|
// If not an administrator then disable the add button.
|
|
//
|
|
if( !_pServerData->bAdministrator() )
|
|
{
|
|
vEnableCtl( _hDlg, IDC_ADD_DRIVER, FALSE );
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bHandleMessage
|
|
|
|
Routine Description:
|
|
|
|
Server 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
|
|
TServerDrivers::
|
|
bHandleMessage(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = TRUE;
|
|
BOOL bChanged = FALSE;
|
|
|
|
switch( uMsg )
|
|
{
|
|
case WM_COMMAND:
|
|
switch( GET_WM_COMMAND_ID( wParam, lParam ) )
|
|
{
|
|
case IDC_ADD_DRIVER:
|
|
if( bHandleAddDriver( uMsg, wParam, lParam ) )
|
|
bChanged = TRUE;
|
|
break;
|
|
|
|
case IDC_UPDATE_DRIVER:
|
|
if( bHandleUpdateDriver( uMsg, wParam, lParam ) )
|
|
bChanged = TRUE;
|
|
break;
|
|
|
|
case IDC_REMOVE_DRIVER:
|
|
if( bHandleRemoveDriver( uMsg, wParam, lParam ) )
|
|
bChanged = TRUE;
|
|
break;
|
|
|
|
case IDC_MORE_DETAILS:
|
|
bHandleDriverDetails( uMsg, wParam, lParam );
|
|
break;
|
|
|
|
case IDC_ITEM_SELECTED:
|
|
bHandleDriverItemSelection( uMsg, wParam, lParam );
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If something changed save the changes and change the
|
|
// the ok button to close and gray the cancel button.
|
|
//
|
|
if( bChanged ){
|
|
|
|
//
|
|
// Update the button state.
|
|
//
|
|
vUpdateButtons();
|
|
|
|
//
|
|
// Save the UI and convert CancelToClose
|
|
//
|
|
(VOID)bSaveUI();
|
|
vCancelToClose( _hDlg );
|
|
}
|
|
|
|
//
|
|
// Let the list view handle their message.
|
|
//
|
|
if( bStatus == FALSE )
|
|
bStatus = _DriversLV.bHandleMessage( uMsg, wParam, lParam );
|
|
|
|
//
|
|
// If the message was not handled pass it on to the base class.
|
|
//
|
|
if( bStatus == FALSE )
|
|
bStatus = TServerProp::bHandleMessage( uMsg, wParam, lParam );
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bHandleDriverItemSelection(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDrivers::bHandleDriverItemSelection\n" ) );
|
|
|
|
//
|
|
// Get the button state in a local variable.
|
|
//
|
|
BOOL bButtonState = _DriversLV.bIsAnyItemSelcted();
|
|
|
|
//
|
|
// If any item is selected then enable the properties button.
|
|
//
|
|
vEnableCtl( _hDlg, IDC_MORE_DETAILS, bButtonState );
|
|
vEnableCtl( _hDlg, IDC_UPDATE_DRIVER, bButtonState && _pServerData->bAdministrator() );
|
|
vEnableCtl( _hDlg, IDC_REMOVE_DRIVER, bButtonState && _pServerData->bAdministrator() && _bCanRemoveDrivers );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bHandleAddDriver(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDrivers::bHandleAddDriver\n" ) );
|
|
|
|
TString strDriverName;
|
|
TStatusB bStatus;
|
|
BOOL bCanceled;
|
|
UINT nDriverInstallCount = 0;
|
|
|
|
//
|
|
// Add any new drivers, displaying the add driver wizard.
|
|
//
|
|
bStatus DBGCHK = bInstallNewPrinterDriver( _hDlg,
|
|
TWizard::kDriverInstall,
|
|
_pServerData->pszServerName(),
|
|
strDriverName,
|
|
NULL,
|
|
kDriverWizardDefault,
|
|
&bCanceled,
|
|
FALSE,
|
|
&nDriverInstallCount );
|
|
//
|
|
// If any driver was installed then return true
|
|
// inorder to indicate we need to refresh the driver list view.
|
|
//
|
|
if( nDriverInstallCount )
|
|
{
|
|
bStatus DBGNOCHK = TRUE;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bHandleRemoveDriver(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDrivers::bHandleRemoveDriver\n" ) );
|
|
|
|
//
|
|
// If we cannot remove the drivers because we are administrating
|
|
// a downlevel machine then do nothing.
|
|
//
|
|
if( !_bCanRemoveDrivers )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
TStatusB bStatus;
|
|
|
|
//
|
|
// Get a list of the selected items.
|
|
//
|
|
UINT nCount = 0;
|
|
TDriverTransfer DriverTransfer;
|
|
bStatus DBGCHK = _DriversLV.bGetSelectedDriverInfo( DriverTransfer, &nCount );
|
|
|
|
DBGMSG( DBG_TRACE, ( "Selected count %d\n", nCount ) );
|
|
|
|
//
|
|
// Warn the user that they are about to delete a driver
|
|
// from the system permently.
|
|
//
|
|
if( bStatus && nCount )
|
|
{
|
|
bStatus DBGNOCHK = bWarnUserDriverDeletion( DriverTransfer.DriverInfoList_pGetByIndex( 0 ), nCount );
|
|
}
|
|
|
|
//
|
|
// Delete the driver if the count is non zero.
|
|
//
|
|
if( bStatus && nCount )
|
|
{
|
|
//
|
|
// Initialize the list iterator.
|
|
//
|
|
TIter Iter;
|
|
DriverTransfer.DriverInfoList_vIterInit( Iter );
|
|
|
|
TDriverInfo *pDriverInfo;
|
|
|
|
for( Iter.vNext(); Iter.bValid(); )
|
|
{
|
|
pDriverInfo = DriverTransfer.DriverInfoList_pConvert( Iter );
|
|
Iter.vNext();
|
|
|
|
DBGMSG( DBG_TRACE, ( "Selected Driver Name: "TSTR"\n", (LPCTSTR)pDriverInfo->strName() ) );
|
|
|
|
//
|
|
// If the driver was added but not installed then
|
|
// removed it the item entirely.
|
|
//
|
|
if( pDriverInfo->vGetInfoState() == TDriverInfo::kAdd )
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "Uninstalled driver was removed.\n" ) );
|
|
pDriverInfo->vSetInfoState( TDriverInfo::kRemoved );
|
|
}
|
|
|
|
//
|
|
// Mark the item to be removed.
|
|
//
|
|
else
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "Driver removed.\n" ) );
|
|
pDriverInfo->vSetInfoState( TDriverInfo::kRemove );
|
|
}
|
|
}
|
|
//
|
|
// Return the removed items back to the list and delete
|
|
// these items form the UI part of the list view.
|
|
//
|
|
_DriversLV.vDeleteDriverInfoFromListView( DriverTransfer );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Return the selected items back to the list view.
|
|
//
|
|
_DriversLV.vReturnDriverInfoToListView( DriverTransfer );
|
|
}
|
|
|
|
//
|
|
// If there are no more drivers in the list view then remove
|
|
// default button state from the remove button and change it
|
|
// to the add button, since the add button is always enabled.
|
|
//
|
|
if( !_DriversLV.uGetListViewItemCount() )
|
|
{
|
|
SendMessage( GetDlgItem( _hDlg, IDC_REMOVE_DRIVER ),
|
|
BM_SETSTYLE,
|
|
MAKEWPARAM( BS_PUSHBUTTON, 0 ),
|
|
MAKELPARAM( TRUE, 0 ) );
|
|
|
|
SendMessage( GetDlgItem( _hDlg, IDC_ADD_DRIVER ),
|
|
BM_SETSTYLE,
|
|
MAKEWPARAM( BS_DEFPUSHBUTTON, 0 ),
|
|
MAKELPARAM( TRUE, 0 ) );
|
|
|
|
SetFocus( GetDlgItem( _hDlg, IDC_ADD_DRIVER ) );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bHandleUpdateDriver(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDrivers::bHandleUpdateDriver\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
bStatus DBGNOCHK = FALSE;
|
|
|
|
//
|
|
// Get a list of the selected items.
|
|
//
|
|
UINT nCount = 0;
|
|
TDriverTransfer DriverTransfer;
|
|
bStatus DBGCHK = _DriversLV.bGetSelectedDriverInfo( DriverTransfer, &nCount );
|
|
|
|
DBGMSG( DBG_TRACE, ( "Selected count %d\n", nCount ) );
|
|
|
|
//
|
|
// Warn the user that they are about to update a driver from the system permently.
|
|
//
|
|
if( bStatus && nCount )
|
|
{
|
|
bStatus DBGNOCHK = bWarnUserDriverUpdate( DriverTransfer.DriverInfoList_pGetByIndex( 0 ), nCount );
|
|
}
|
|
|
|
//
|
|
// Delete the driver if the count is non zero.
|
|
//
|
|
if( bStatus && nCount )
|
|
{
|
|
//
|
|
// Initialize the list iterator.
|
|
//
|
|
TIter Iter;
|
|
DriverTransfer.DriverInfoList_vIterInit( Iter );
|
|
|
|
TDriverInfo *pDriverInfo;
|
|
|
|
for( Iter.vNext(); Iter.bValid(); Iter.vNext() )
|
|
{
|
|
pDriverInfo = DriverTransfer.DriverInfoList_pConvert( Iter );
|
|
|
|
DBGMSG( DBG_TRACE, ( "Selected Driver Name: "TSTR"\n", (LPCTSTR)pDriverInfo->strName() ) );
|
|
|
|
//
|
|
// Mark all the selected driver as update canidates.
|
|
//
|
|
pDriverInfo->vSetInfoState( TDriverInfo::kUpdate );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the selected items back to the list view.
|
|
//
|
|
_DriversLV.vReturnDriverInfoToListView( DriverTransfer );
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bHandleDriverDetails(
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDrivers::bHandleDetails\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
TDriverInfo *pDriverInfo;
|
|
TDriversLV::THandle Handle;
|
|
|
|
for( bStatus DBGNOCHK = TRUE; bStatus ; )
|
|
{
|
|
bStatus DBGNOCHK = _DriversLV.bGetSelectedDriverInfo( &pDriverInfo, Handle );
|
|
|
|
if( bStatus )
|
|
{
|
|
TDriverDetails Details( _hDlg, pDriverInfo );
|
|
|
|
if( VALID_OBJ( Details ) )
|
|
{
|
|
Details.bDoModal();
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bWarnUserDriverDeletion(
|
|
IN TDriverInfo *pDriverInfo,
|
|
IN UINT nCount
|
|
) const
|
|
{
|
|
//
|
|
// If there are multiple items selected then the warning message
|
|
// is changed.
|
|
//
|
|
INT iMsg = nCount == 1 ? IDS_ERR_DELETE_PRINTER_DRIVER : IDS_ERR_DELETE_PRINTER_DRIVERN;
|
|
|
|
//
|
|
// Return success of the user was warned and decided to complete
|
|
// the printer driver removal.
|
|
//
|
|
return iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
iMsg,
|
|
MB_YESNO | MB_ICONQUESTION,
|
|
kMsgNone,
|
|
NULL,
|
|
static_cast<LPCTSTR>( pDriverInfo->strName() ) ) == IDYES ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL
|
|
TServerDrivers::
|
|
bWarnUserDriverUpdate(
|
|
IN TDriverInfo *pDriverInfo,
|
|
IN UINT nCount
|
|
) const
|
|
{
|
|
//
|
|
// If there are multiple items selected then the warning message
|
|
// is changed.
|
|
//
|
|
INT iMsg = nCount == 1 ? IDS_ERR_UPDATE_PRINTER_DRIVER : IDS_ERR_UPDATE_PRINTER_DRIVERN;
|
|
|
|
//
|
|
// Return success of the user was warned and decided to complete
|
|
// the printer driver removal.
|
|
//
|
|
return iMessage( _hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
iMsg,
|
|
MB_YESNO | MB_ICONQUESTION,
|
|
kMsgNone,
|
|
NULL,
|
|
static_cast<LPCTSTR>( pDriverInfo->strName() ) ) == IDYES ? TRUE : FALSE;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Server Driver Notify
|
|
|
|
********************************************************************/
|
|
TServerDriverNotify::
|
|
TServerDriverNotify(
|
|
TServerDrivers *pServerDrivers
|
|
) : _pServerDrivers( pServerDrivers ),
|
|
_pDi( NULL ),
|
|
_uNotifyCount( 0 ),
|
|
_bActionFailed( FALSE )
|
|
{
|
|
}
|
|
|
|
TServerDriverNotify::
|
|
~TServerDriverNotify(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Ensure we release the printer driver installation object.
|
|
//
|
|
delete _pDi;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bNotify
|
|
|
|
Routine Description:
|
|
|
|
Called for all driver info classes in the list view.
|
|
|
|
Arguments:
|
|
|
|
pDriverInfo - Pointer to driver info class.
|
|
|
|
Return Value:
|
|
|
|
TRUE continue for the remaing driver info classes.
|
|
FALSE stop notification.
|
|
|
|
--*/
|
|
BOOL
|
|
TServerDriverNotify::
|
|
bNotify(
|
|
IN TDriverInfo *pDriverInfo
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDriverNotify::bNotify\n" ) );
|
|
|
|
//
|
|
// Adjust the notify count, used for detection the multi selection
|
|
//
|
|
//
|
|
_uNotifyCount++;
|
|
|
|
BOOL bStatus = TRUE;
|
|
INT iMessageId = 0;
|
|
|
|
switch( pDriverInfo->vGetInfoState() )
|
|
{
|
|
case TDriverInfo::kRemove:
|
|
bStatus = bRemove( pDriverInfo );
|
|
iMessageId = IDS_ERR_ALL_DRIVER_NOT_REMOVED;
|
|
break;
|
|
|
|
case TDriverInfo::kAdd:
|
|
bStatus = bInstall( pDriverInfo );
|
|
iMessageId = IDS_ERR_ALL_DRIVER_NOT_INSTALLED;
|
|
break;
|
|
|
|
case TDriverInfo::kUpdate:
|
|
bStatus = bUpdate( pDriverInfo );
|
|
iMessageId = IDS_ERR_ALL_DRIVER_NOT_UPDATED;
|
|
break;
|
|
|
|
default:
|
|
bStatus = TRUE;
|
|
iMessageId = 0;
|
|
break;
|
|
}
|
|
|
|
if( !bStatus )
|
|
{
|
|
if( iMessageId && GetLastError() != ERROR_CANCELLED )
|
|
{
|
|
//
|
|
// Display the error message.
|
|
//
|
|
iMessage( _pServerDrivers->_hDlg,
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
iMessageId,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgGetLastError,
|
|
NULL,
|
|
static_cast<LPCTSTR>( pDriverInfo->strName() ),
|
|
static_cast<LPCTSTR>( pDriverInfo->strEnvironment() ),
|
|
static_cast<LPCTSTR>( pDriverInfo->strVersion() ) );
|
|
}
|
|
|
|
_bActionFailed = TRUE;
|
|
|
|
//
|
|
// Currently we continue if an error occurred.
|
|
//
|
|
bStatus = TRUE;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TServerDriverNotify::
|
|
bInstall(
|
|
IN TDriverInfo *pDriverInfo
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDriverNotify::bInstall\n" ) );
|
|
SPLASSERT( FALSE );
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
TServerDriverNotify::
|
|
bRemove(
|
|
IN TDriverInfo *pDriverInfo
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDriverNotify::bRemove\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
bStatus DBGNOCHK = TRUE;
|
|
|
|
//
|
|
// Delete the specfied printer driver.
|
|
//
|
|
bStatus DBGCHK = DeletePrinterDriverEx( (LPTSTR)_pServerDrivers->_pServerData->pszServerName(),
|
|
(LPTSTR)(LPCTSTR)pDriverInfo->strEnv(),
|
|
(LPTSTR)(LPCTSTR)pDriverInfo->strName(),
|
|
DPD_DELETE_UNUSED_FILES|DPD_DELETE_SPECIFIC_VERSION,
|
|
pDriverInfo->dwVersion());
|
|
|
|
//
|
|
// If we are trying this action on a down level spooler.
|
|
//
|
|
if( !bStatus && GetLastError() == RPC_S_PROCNUM_OUT_OF_RANGE )
|
|
{
|
|
bStatus DBGCHK = DeletePrinterDriver( (LPTSTR)_pServerDrivers->_pServerData->pszServerName(),
|
|
(LPTSTR)(LPCTSTR)pDriverInfo->strEnv(),
|
|
(LPTSTR)(LPCTSTR)pDriverInfo->strName() );
|
|
}
|
|
|
|
//
|
|
// If the driver was deleted then mark the driver structure as removed.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
pDriverInfo->vSetInfoState( TDriverInfo::kRemoved );
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TServerDriverNotify::
|
|
bUpdate(
|
|
IN TDriverInfo *pDriverInfo
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "TServerDriverNotify::bUpdate\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
DWORD dwEncode = 0;
|
|
DWORD dwPrevInstallFlags = 0;
|
|
|
|
bStatus DBGNOCHK = TRUE;
|
|
|
|
//
|
|
// Lazy load the printer drivers installation class.
|
|
//
|
|
if( !_pDi )
|
|
{
|
|
_pDi = new TPrinterDriverInstallation( _pServerDrivers->_pServerData->pszServerName(),
|
|
_pServerDrivers->_hDlg );
|
|
|
|
bStatus DBGNOCHK = VALID_PTR( _pDi );
|
|
}
|
|
|
|
if( bStatus )
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "Installing driver "TSTR"\n", (LPCTSTR)pDriverInfo->_strName ) );
|
|
|
|
//
|
|
// Encode the printer driver architercure and version
|
|
//
|
|
bStatus DBGCHK = bEncodeArchVersion( pDriverInfo->_strEnv,
|
|
pDriverInfo->_dwVersion,
|
|
&dwEncode );
|
|
|
|
//
|
|
// Get the current install flags.
|
|
//
|
|
dwPrevInstallFlags = _pDi->GetInstallFlags();
|
|
|
|
//
|
|
// We do not copy the inf for version 2 drivers.
|
|
//
|
|
if( GetDriverVersion( dwEncode ) == 2 )
|
|
{
|
|
//
|
|
// We don't copy the inf for version 2 drivers.
|
|
//
|
|
_pDi->SetInstallFlags( DRVINST_DONOTCOPY_INF);
|
|
}
|
|
|
|
//
|
|
// On NT5 and greater we can overwrite all the driver files,
|
|
// however on less than NT5 we can only copy newer files.
|
|
//
|
|
DWORD dwAddPrinterDriverFlags = APD_COPY_ALL_FILES;
|
|
DWORD dwCurrentDriverEncode = 0;
|
|
|
|
if( _pDi->bGetCurrentDriverEncode( &dwCurrentDriverEncode ) )
|
|
{
|
|
if( GetDriverVersion( dwCurrentDriverEncode ) <= 2 )
|
|
{
|
|
dwAddPrinterDriverFlags = APD_COPY_NEW_FILES;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Select and install the printer driver.
|
|
//
|
|
BOOL bOfferReplacementDriver = FALSE;
|
|
dwAddPrinterDriverFlags |= APD_INSTALL_WARNED_DRIVER;
|
|
bStatus DBGCHK = _pDi->bSetDriverName( pDriverInfo->_strName ) &&
|
|
_pDi->bInstallDriver( &pDriverInfo->_strName, bOfferReplacementDriver,
|
|
FALSE, _pServerDrivers->_hDlg, dwEncode, dwAddPrinterDriverFlags, TRUE );
|
|
|
|
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Indicate this driver has been installed.
|
|
//
|
|
pDriverInfo->vSetInfoState( TDriverInfo::kInstalled );
|
|
}
|
|
|
|
//
|
|
// Restore the previous install flags.
|
|
//
|
|
_pDi->SetInstallFlags( dwPrevInstallFlags );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Server property windows.
|
|
|
|
********************************************************************/
|
|
TServerWindows::
|
|
TServerWindows(
|
|
IN TServerData *pServerData
|
|
) : _pServerData( pServerData ),
|
|
_Forms( pServerData ),
|
|
_Ports( pServerData ),
|
|
_Settings( pServerData ),
|
|
_Drivers( pServerData )
|
|
{
|
|
}
|
|
|
|
TServerWindows::
|
|
~TServerWindows(
|
|
)
|
|
{
|
|
}
|
|
|
|
/*++
|
|
|
|
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
|
|
TServerWindows::
|
|
bBuildPages(
|
|
VOID
|
|
)
|
|
{
|
|
|
|
DBGMSG( DBG_TRACE, ( "TServerWindows bBuildPages\n") );
|
|
|
|
struct SheetInitializer {
|
|
MGenericProp *pSheet;
|
|
INT iDialog;
|
|
};
|
|
|
|
SheetInitializer aSheetInit[] = {
|
|
{&_Forms, DLG_FORMS },
|
|
{&_Ports, DLG_SERVER_PORTS },
|
|
{&_Drivers, DLG_SERVER_DRIVERS },
|
|
{&_Settings, DLG_SERVER_SETTINGS },
|
|
{NULL, NULL, }
|
|
};
|
|
|
|
BOOL bReturn = FALSE;
|
|
BOOL bSheetsDestroyed = FALSE;
|
|
PROPSHEETHEADER psh;
|
|
HPROPSHEETPAGE ahpsp[COUNTOF( aSheetInit )];
|
|
PROPSHEETPAGE psp;
|
|
|
|
ZeroMemory( &psp, sizeof( psp ));
|
|
ZeroMemory( &psh, sizeof( psh ));
|
|
ZeroMemory( ahpsp, sizeof( ahpsp ));
|
|
|
|
psh.dwSize = sizeof( psh );
|
|
psh.hwndParent = _pServerData->hwnd();
|
|
psh.dwFlags = PSH_USEHICON | PSH_PROPTITLE;
|
|
psh.phpage = ahpsp;
|
|
psh.hIcon = _pServerData->hDefaultSmallIcon();
|
|
psh.nStartPage = _pServerData->uStartPage();
|
|
psh.hInstance = ghInst;
|
|
psh.pszCaption = (LPCTSTR)_pServerData->strTitle();
|
|
psh.nPages = COUNTOF( ahpsp );
|
|
|
|
psp.dwSize = sizeof( psp );
|
|
psp.hInstance = ghInst;
|
|
psp.pfnDlgProc = MGenericProp::SetupDlgProc;
|
|
|
|
//
|
|
// Create the property sheets.
|
|
//
|
|
for( UINT i = 0; i < COUNTOF( ahpsp ); ++i ){
|
|
psp.pszTemplate = MAKEINTRESOURCE( aSheetInit[i].iDialog );
|
|
psp.lParam = (LPARAM)(MGenericProp*)aSheetInit[i].pSheet;
|
|
ahpsp[i] = CreatePropertySheetPage( &psp );
|
|
}
|
|
|
|
//
|
|
// Insure the index matches the number of pages.
|
|
//
|
|
SPLASSERT( i == psh.nPages );
|
|
|
|
//
|
|
// Verify all pages were created.
|
|
//
|
|
for( i = 0; i < COUNTOF( ahpsp ); ++i ){
|
|
if( !ahpsp[i] ){
|
|
DBGMSG( DBG_WARN, ( "Server Property sheet Unable to create page %d\n", i ));
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Indicate we do not have to distory the property sheets.
|
|
//
|
|
bSheetsDestroyed = TRUE;
|
|
|
|
//
|
|
// Display the property sheets.
|
|
//
|
|
if( PropertySheet( &psh ) < 0 ){
|
|
|
|
DBGMSG( DBG_WARN, ( "Server Property Sheet failed %d\n", GetLastError()));
|
|
vShowResourceError( _pServerData->hwnd() );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Check if the reboot flag was returned.
|
|
//
|
|
if( _pServerData->_bRebootRequired ) {
|
|
|
|
//
|
|
// Display message, reboot neccessary.
|
|
//
|
|
if (_pServerData->pszServerName()) {
|
|
|
|
//
|
|
// if the server name is not NULL, we assume it is a remote printers folder.
|
|
// This is not true if user opens the local printers folder from
|
|
// \\local-machine-name, but this is a rare case that we can ignore.
|
|
//
|
|
|
|
iMessage( _pServerData->hwnd(),
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_SERVER_SETTINGS_CHANGED_REMOTE,
|
|
MB_ICONEXCLAMATION,
|
|
kMsgNone,
|
|
NULL,
|
|
_pServerData->pszServerName()
|
|
);
|
|
}
|
|
else {
|
|
|
|
iMessage( _pServerData->hwnd(),
|
|
IDS_SERVER_PROPERTIES_TITLE,
|
|
IDS_SERVER_SETTINGS_CHANGED,
|
|
MB_ICONEXCLAMATION,
|
|
kMsgNone,
|
|
NULL
|
|
);
|
|
}
|
|
}
|
|
|
|
bReturn = TRUE;
|
|
|
|
}
|
|
|
|
Done:
|
|
|
|
//
|
|
// If Sheets weren't destoryed, do it now.
|
|
//
|
|
if( !bSheetsDestroyed ){
|
|
|
|
for( i = 0; i < COUNTOF( ahpsp ); ++i ){
|
|
if( ahpsp[i] ){
|
|
DestroyPropertySheetPage( ahpsp[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDisplayPages
|
|
|
|
Routine Description:
|
|
|
|
Displays the document property pages.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if pages were displayed, FALSE
|
|
|
|
--*/
|
|
BOOL
|
|
TServerWindows::
|
|
bDisplayPages(
|
|
VOID
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bValid
|
|
|
|
Routine Description:
|
|
|
|
Returns if class and its dat members are vaild.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE - class is valid, FALSE class is invalid.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
TServerWindows::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Validated all the known pages.
|
|
//
|
|
if( VALID_OBJ( _Forms ) &&
|
|
VALID_OBJ( _Ports ) &&
|
|
VALID_OBJ( _Drivers ) &&
|
|
VALID_OBJ( _Settings ) ){
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|