2455 lines
66 KiB
C++
2455 lines
66 KiB
C++
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1996 - 1999
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
rundll.cxx
|
|
|
|
Abstract:
|
|
|
|
Run dll entry interface for lauching printer related
|
|
UI from shell extenstion and other shell related components.
|
|
|
|
Author:
|
|
|
|
Steve Kiraly (SteveKi) 29-Sept-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
#include "rundll.hxx"
|
|
#include "getopt.hxx"
|
|
#include "parser.hxx"
|
|
#include "permc.hxx"
|
|
#include "asyncdlg.hxx"
|
|
#include "tstpage.hxx"
|
|
#include "time.hxx"
|
|
#include "psetup.hxx"
|
|
#include "drvsetup.hxx"
|
|
#include "instarch.hxx"
|
|
#include "portslv.hxx"
|
|
#include "dsinterf.hxx"
|
|
#include "prtprop.hxx"
|
|
#include "prtshare.hxx"
|
|
#include "dsinterf.hxx"
|
|
#include "drvsetup.hxx"
|
|
#include "driverif.hxx"
|
|
#include "driverlv.hxx"
|
|
#include "archlv.hxx"
|
|
#include "detect.hxx"
|
|
#include "setup.hxx"
|
|
#include "spllibex.hxx"
|
|
#include "spinterf.hxx"
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintUIEntryW
|
|
|
|
Routine Description:
|
|
|
|
Interface for the Rundll32 process.
|
|
|
|
Arguments:
|
|
|
|
hwnd - Window handle of stub window.
|
|
hInstance, - Rundll instance handle.
|
|
pszCmdLine - Pointer to UNICOE command line.
|
|
nCmdShow - Show command value always TRUE.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
--*/
|
|
DWORD
|
|
PrintUIEntryW(
|
|
IN HWND hwnd,
|
|
IN HINSTANCE hInstance,
|
|
IN LPCTSTR pszCmdLine,
|
|
IN UINT nCmdShow
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintUIEntryW interface\n" ) );
|
|
DBGMSG( DBG_TRACE, ( "hwnd %x\n", hwnd ) );
|
|
DBGMSG( DBG_TRACE, ( "hInstance %x\n", hInstance ) );
|
|
DBGMSG( DBG_TRACE, ( "pszCmdLine %ws\n", pszCmdLine ) );
|
|
DBGMSG( DBG_TRACE, ( "nCmdShow %d\n", nCmdShow ) );
|
|
DBGMSG( DBG_TRACE, ( "CommandLine %ws\n", GetCommandLine() ) );
|
|
|
|
//
|
|
// we need to count the error messages to see if necessary to
|
|
// show up UI in case of an error or if somebody has been done
|
|
// this already
|
|
//
|
|
CMsgBoxCounter msgCounter(MB_ICONSTOP|MB_ICONINFORMATION);
|
|
|
|
UINT ac = 0;
|
|
TCHAR **av = NULL;
|
|
BOOL bRetval = FALSE;
|
|
AParams Params = {0};
|
|
|
|
//
|
|
// Strip any trailing white space.
|
|
//
|
|
vStripTrailWhiteSpace( (LPTSTR)pszCmdLine );
|
|
|
|
//
|
|
// Convert the command line to an argv,
|
|
//
|
|
bRetval = StringToArgv( pszCmdLine, // Command line arguments
|
|
&ac, // Place to return arg count
|
|
&av, // Place to return argv
|
|
FALSE ); // There is no file name on the command line
|
|
|
|
if( bRetval )
|
|
{
|
|
//
|
|
// Store pointer to command line.
|
|
//
|
|
Params.pszCmdLine = pszCmdLine;
|
|
|
|
//
|
|
// Parse the command line argumens and execute the command.
|
|
//
|
|
bRetval = bDoCommand( hwnd, ac, av, &Params );
|
|
}
|
|
|
|
if( !bRetval )
|
|
{
|
|
//
|
|
// If we are not in quiet mode display error messsage.
|
|
//
|
|
if( !Params.Flags.IsQuiet && 0 == msgCounter.GetCount() )
|
|
{
|
|
switch( Params.dwLastError )
|
|
{
|
|
case ERROR_SUCCESS:
|
|
case ERROR_CANCELLED:
|
|
break;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
{
|
|
// show up a friendly message that conform the shell32.dll
|
|
// message in this case. this is because this will be invoked
|
|
// primarily from shell32.dll from the runas commands
|
|
iMessage(NULL, IDS_PRINTERS_TITLE, IDS_FRIENDLY_ACCESSDENIED,
|
|
MB_OK|MB_ICONINFORMATION, kMsgNone, NULL);
|
|
}
|
|
break;
|
|
|
|
case ERROR_INVALID_PARAMETER:
|
|
{
|
|
// show up a friendly message to say that the arguments are invalid
|
|
iMessage(NULL, IDS_PRINTERS_TITLE, IDS_ERROR_INVALID_ARG,
|
|
MB_OK|MB_ICONSTOP, kMsgNone, NULL);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
// we are going to show a generic error message here
|
|
iMessage(NULL, IDS_PRINTERS_TITLE, IDS_ERR_GENERIC,
|
|
MB_OK|MB_ICONSTOP, Params.dwLastError, NULL);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If the last error code was not set then set it to a generic
|
|
// error value. We just chose one, ERROR_INVALID_FUNCTION
|
|
//
|
|
if( Params.dwLastError == ERROR_SUCCESS )
|
|
{
|
|
Params.dwLastError = GetLastError();
|
|
|
|
if( Params.dwLastError == ERROR_SUCCESS )
|
|
{
|
|
Params.dwLastError = ERROR_INVALID_FUNCTION;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Ensure we release the command line argv.
|
|
//
|
|
ReleaseArgv( av );
|
|
|
|
//
|
|
// If something failed and the error code was not set then set
|
|
// the error to an unspecified error value.
|
|
//
|
|
if( !bRetval )
|
|
{
|
|
//
|
|
// Set the last error incase the caller ignores the return value.
|
|
//
|
|
SetLastError( Params.dwLastError );
|
|
}
|
|
|
|
return Params.dwLastError;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoCommand
|
|
|
|
Routine Description:
|
|
|
|
Parses the commmand line passed by rundll32.
|
|
|
|
Arguments:
|
|
|
|
hwnd - Parent window handle.
|
|
ac - Number of strings.
|
|
av - Pointer to an array of pointer to strings.
|
|
|
|
Return Value:
|
|
|
|
TRUE function complete ok. FALSE error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoCommand(
|
|
IN HWND hwnd,
|
|
IN INT ac,
|
|
IN LPTSTR *av,
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
INT retval;
|
|
LPTSTR options = TEXT("?KYUPHwuzZkyxqeospS:X:t:d:i:n:r:m:c:l:a:f:b:g:h:v:j:M:W:G:"); // Supported options
|
|
INT iFunction = kUnknown;
|
|
BOOL bStatus = FALSE;
|
|
|
|
//
|
|
// Set to known state
|
|
//
|
|
SetLastError( ERROR_SUCCESS );
|
|
|
|
//
|
|
// Indicate there is not a file name as the first argument.
|
|
//
|
|
TGetOptContext context;
|
|
context.optind = 0;
|
|
|
|
//
|
|
// Process any command line arguments switches.
|
|
//
|
|
for (context.opterr = 0, retval = 0; retval != EOF; )
|
|
{
|
|
retval = getopt (ac, av, options, context);
|
|
|
|
switch (retval)
|
|
{
|
|
case 't':
|
|
pParams->dwSheet = _ttoi( context.optarg );
|
|
break;
|
|
case 'n':
|
|
pParams->pPrinterName = context.optarg;
|
|
break;
|
|
case 'r':
|
|
pParams->pPortName = context.optarg;
|
|
break;
|
|
case 'm':
|
|
pParams->pModelName = context.optarg;
|
|
break;
|
|
case 'M':
|
|
// get the message type first
|
|
pParams->uMsgType = *context.optarg == TEXT('q') ? kMsgConfirmation :
|
|
*context.optarg == TEXT('w') ? kMsgWarning : kMsgUnknownType;
|
|
|
|
// get the real message text here
|
|
context.optarg++;
|
|
if( kMsgUnknownType != pParams->uMsgType && context.optarg && *context.optarg )
|
|
{
|
|
pParams->pMsgConfirm = context.optarg;
|
|
}
|
|
break;
|
|
case 'b':
|
|
pParams->pBasePrinterName = context.optarg;
|
|
break;
|
|
case 'f':
|
|
pParams->pInfFileName = context.optarg;
|
|
break;
|
|
case 'a':
|
|
pParams->pBinFileName = context.optarg;
|
|
break;
|
|
case 'G':
|
|
{
|
|
// global flags
|
|
if( *context.optarg == TEXT('w') )
|
|
{
|
|
// we should suppress the setup driver warnings UI
|
|
// -- i.e. we're in super quiet mode
|
|
pParams->Flags.IsSupressSetupUI = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
case 'g':
|
|
iFunction = *context.optarg == TEXT('a') ? kAddPerMachineConnection :
|
|
*context.optarg == TEXT('d') ? kDeletePerMachineConnection :
|
|
*context.optarg == TEXT('e') ? kEnumPerMachineConnections : kUnknown;
|
|
break;
|
|
case 'j':
|
|
pParams->pProvider = context.optarg;
|
|
break;
|
|
case 'i':
|
|
iFunction = *context.optarg == TEXT('n') ? kInstallNetPrinter :
|
|
*context.optarg == TEXT('l') ? kInstallLocalPrinter :
|
|
*context.optarg == TEXT('d') ? kInstallPrinterDriver :
|
|
*context.optarg == TEXT('a') ? kInstallDriverWithInf :
|
|
*context.optarg == TEXT('f') ? kInstallPrinterWithInf :
|
|
*context.optarg == TEXT('i') ? kInstallLocalPrinterWithInf : kUnknown;
|
|
|
|
break;
|
|
case 'd':
|
|
iFunction = *context.optarg == TEXT('n') ? kDeleteNetPrinter :
|
|
*context.optarg == TEXT('l') ? kDeleteLocalPrinter :
|
|
*context.optarg == TEXT('d') ? kDeletePrinterDriver : kUnknown;
|
|
break;
|
|
case 'o':
|
|
iFunction = kWin32QueueView;
|
|
break;
|
|
case 's':
|
|
iFunction = kServerProperties;
|
|
break;
|
|
case 'p':
|
|
iFunction = kProperties;
|
|
break;
|
|
case 'X':
|
|
iFunction = *context.optarg == TEXT('g') ? kPrinterGetSettings :
|
|
*context.optarg == TEXT('s') ? kPrinterSetSettings : kUnknown;
|
|
break;
|
|
case 'e':
|
|
iFunction = kDocumentDefaults;
|
|
break;
|
|
case 'c':
|
|
pParams->pMachineName = context.optarg;
|
|
break;
|
|
case 'l':
|
|
pParams->pSourcePath = context.optarg;
|
|
break;
|
|
case 'h':
|
|
pParams->pArchitecture = context.optarg;
|
|
break;
|
|
case 'v':
|
|
pParams->pVersion = context.optarg;
|
|
break;
|
|
case 'q':
|
|
pParams->Flags.IsQuiet = TRUE;
|
|
break;
|
|
case 'k':
|
|
iFunction = kPrintTestPage;
|
|
break;
|
|
case 'y':
|
|
iFunction = kSetAsDefault;
|
|
break;
|
|
case 'x':
|
|
pParams->Flags.IsWebPointAndPrint = TRUE;
|
|
break;
|
|
case 'z':
|
|
pParams->Flags.IsNoSharing = TRUE;
|
|
break;
|
|
case 'Z':
|
|
pParams->Flags.IsShared = TRUE;
|
|
break;
|
|
case 'u':
|
|
pParams->Flags.IsUseExistingDriver = TRUE;
|
|
break;
|
|
case 'w':
|
|
pParams->Flags.IsUnknownDriverPrompt = TRUE;
|
|
break;
|
|
case 'W':
|
|
// wizards flags
|
|
pParams->Flags.IsWizardRestartable = *context.optarg == TEXT('r') ? TRUE : FALSE;
|
|
break;
|
|
case 'H':
|
|
pParams->Flags.IsHydraSpecific = TRUE;
|
|
break;
|
|
case 'P':
|
|
pParams->Flags.IsPromptForNeededFiles = TRUE;
|
|
break;
|
|
case 'Y':
|
|
pParams->Flags.IsDontAutoGenerateName = TRUE;
|
|
break;
|
|
case 'K':
|
|
pParams->Flags.IsUseNonLocalizedStrings = TRUE;
|
|
break;
|
|
case 'S':
|
|
iFunction = *context.optarg == TEXT('s') ? kPrinterPersist :
|
|
*context.optarg == TEXT('r') ? kPrinterRestore : kUnknown;
|
|
break;
|
|
case 'U':
|
|
pParams->Flags.IsWindowsUpdate = TRUE;
|
|
break;
|
|
case EOF:
|
|
bStatus = TRUE;
|
|
break;
|
|
case '?':
|
|
iFunction = kCommandHelp;
|
|
bStatus = TRUE;
|
|
retval = EOF;
|
|
break;
|
|
case INVALID_COMAND:
|
|
bStatus = FALSE;
|
|
retval = EOF;
|
|
break;
|
|
default:
|
|
retval = EOF;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If success validate the command line arguments.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Do simple validation on the command line arguments.
|
|
//
|
|
bStatus = bValidateCommand( iFunction, pParams );
|
|
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// If there are any remaining arguments then get
|
|
// the argument count and pointer to it.
|
|
//
|
|
if( context.optind < ac )
|
|
{
|
|
pParams->av = &av[context.optind];
|
|
pParams->ac = ac - context.optind;
|
|
}
|
|
|
|
//
|
|
// Check to see if we need to ask the user to confirm the operation if
|
|
// not in quiet mode.
|
|
//
|
|
BOOL bContinueExecution = TRUE;
|
|
if( !pParams->Flags.IsQuiet && kMsgUnknownType != pParams->uMsgType && pParams->pMsgConfirm )
|
|
{
|
|
//
|
|
// there is a confirmation/warning message specified and we are going to
|
|
// give opportunity to the user to cancel the whole command here
|
|
//
|
|
UINT uFlags = kMsgConfirmation == pParams->uMsgType ? MB_ICONQUESTION :
|
|
kMsgConfirmation == pParams->uMsgType ? MB_ICONEXCLAMATION : 0;
|
|
ASSERT(uFlags); // shouldn't be zero
|
|
uFlags |= MB_YESNO; // we are asking YES/NO question
|
|
bContinueExecution = (IDYES == iMessage2(NULL, MAKEINTRESOURCE(IDS_PRINTERS_TITLE),
|
|
pParams->pMsgConfirm, uFlags, kMsgNone, NULL));
|
|
}
|
|
|
|
if( bContinueExecution )
|
|
{
|
|
//
|
|
// Execute the command.
|
|
//
|
|
bStatus = bExecuteCommand( hwnd, iFunction, pParams );
|
|
}
|
|
}
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bValidateCommand
|
|
|
|
Routine Description:
|
|
|
|
Validates the command line arguments
|
|
|
|
Arguments:
|
|
|
|
iFunction - Function code.
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE arguments are valid. FALSE invalid argument found.
|
|
|
|
--*/
|
|
BOOL
|
|
bValidateCommand(
|
|
IN INT iFunction,
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ("iFunction %d\n", iFunction ) );
|
|
DBGMSG( DBG_TRACE, ("Params\n" ) );
|
|
DBGMSG( DBG_TRACE, ("Flags %x\n", pParams->Flags ) );
|
|
DBGMSG( DBG_TRACE, ("dwSheet %d\n", pParams->dwSheet ) );
|
|
DBGMSG( DBG_TRACE, ("dwLastError %d\n", pParams->dwLastError ) );
|
|
DBGMSG( DBG_TRACE, ("pPrinterName "TSTR"\n", DBGSTR( pParams->pPrinterName ) ) );
|
|
DBGMSG( DBG_TRACE, ("pPortName "TSTR"\n", DBGSTR( pParams->pPortName ) ) );
|
|
DBGMSG( DBG_TRACE, ("pModelName "TSTR"\n", DBGSTR( pParams->pModelName ) ) );
|
|
DBGMSG( DBG_TRACE, ("pInfFileName "TSTR"\n", DBGSTR( pParams->pInfFileName ) ) );
|
|
DBGMSG( DBG_TRACE, ("pBasePrinterName "TSTR"\n", DBGSTR( pParams->pBasePrinterName) ) );
|
|
DBGMSG( DBG_TRACE, ("pMachineName "TSTR"\n", DBGSTR( pParams->pMachineName ) ) );
|
|
DBGMSG( DBG_TRACE, ("pSourcePath "TSTR"\n", DBGSTR( pParams->pSourcePath ) ) );
|
|
DBGMSG( DBG_TRACE, ("pszCmdLine "TSTR"\n", DBGSTR( pParams->pszCmdLine ) ) );
|
|
DBGMSG( DBG_TRACE, ("pBinFileName "TSTR"\n", DBGSTR( pParams->pBinFileName ) ) );
|
|
|
|
BOOL bRetval = FALSE;
|
|
|
|
switch( iFunction )
|
|
{
|
|
case kInstallLocalPrinter:
|
|
case kDeleteLocalPrinter:
|
|
case kInstallPrinterDriver:
|
|
case kEnumPerMachineConnections:
|
|
case kServerProperties:
|
|
case kCommandHelp:
|
|
bRetval = TRUE;
|
|
break;
|
|
|
|
case kInstallLocalPrinterWithInf:
|
|
if( pParams->pInfFileName )
|
|
{
|
|
bRetval = TRUE;
|
|
}
|
|
break;
|
|
|
|
case kSetAsDefault:
|
|
case kAddPerMachineConnection:
|
|
case kDeletePerMachineConnection:
|
|
case kInstallNetPrinter:
|
|
case kDeleteNetPrinter:
|
|
case kWin32QueueView:
|
|
case kProperties:
|
|
case kDocumentDefaults:
|
|
case kPrintTestPage:
|
|
case kPrinterGetSettings:
|
|
case kPrinterSetSettings:
|
|
if( pParams->pPrinterName )
|
|
{
|
|
bRetval = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pParams->dwLastError = ERROR_INVALID_PRINTER_NAME;
|
|
}
|
|
break;
|
|
|
|
case kInstallPrinterWithInf:
|
|
if( pParams->pModelName && pParams->pInfFileName && pParams->pPortName )
|
|
{
|
|
bRetval = TRUE;
|
|
|
|
if( pParams->Flags.IsWebPointAndPrint )
|
|
{
|
|
//
|
|
// Commenting out pBinFileName - for local cab install for wp&p the bin file
|
|
// won't exist. This may be fixed if syncing to the server is added and
|
|
// this could be put back then. - pvine
|
|
//
|
|
bRetval = pParams->pPrinterName /*&& pParams->pBinFileName */? TRUE : FALSE;
|
|
}
|
|
else if( pParams->Flags.IsDontAutoGenerateName )
|
|
{
|
|
bRetval = pParams->pBasePrinterName != NULL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kPrinterPersist:
|
|
case kPrinterRestore:
|
|
bRetval = pParams->pPrinterName && pParams->pBinFileName ? TRUE : FALSE;
|
|
break;
|
|
|
|
case kDeletePrinterDriver:
|
|
case kInstallDriverWithInf:
|
|
if( pParams->pModelName )
|
|
{
|
|
bRetval = TRUE;
|
|
}
|
|
break;
|
|
|
|
case kUnknown:
|
|
pParams->dwLastError = ERROR_INVALID_FUNCTION;
|
|
bRetval = FALSE;
|
|
break;
|
|
}
|
|
|
|
if( !bRetval && ERROR_SUCCESS == pParams->dwLastError )
|
|
{
|
|
//
|
|
// An invalid parameter has been passed.
|
|
//
|
|
pParams->dwLastError = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bExecuteCommand
|
|
|
|
Routine Description:
|
|
|
|
Executes the command from the rundll32 command line
|
|
after it has parsed.
|
|
|
|
Arguments:
|
|
|
|
hwnd - parent window handle.
|
|
iFunction - Function code.
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE function complete ok. FALSE error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
bExecuteCommand(
|
|
IN HWND hwnd,
|
|
IN INT iFunction,
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
TCHAR szBuffer[kPrinterBufMax];
|
|
UINT uSize = COUNTOF( szBuffer );
|
|
|
|
DBGMSG( DBG_TRACE, ("Function %d\n", iFunction ) );
|
|
|
|
szBuffer[0] = TEXT('\0');
|
|
|
|
if( pParams->pPrinterName )
|
|
{
|
|
_tcsncpy( szBuffer, pParams->pPrinterName, COUNTOF( szBuffer ) );
|
|
}
|
|
|
|
//
|
|
// Dispatch the specified function.
|
|
//
|
|
// !!Policy!! if a command is executed then it is responsible
|
|
// for displaying any error UI i.e message boxes.
|
|
//
|
|
switch( iFunction )
|
|
{
|
|
case kInstallNetPrinter:
|
|
(VOID)bPrinterSetup( NULL, MSP_NETPRINTER, MAX_PATH, szBuffer, &uSize, pParams->pMachineName );
|
|
break;
|
|
|
|
case kDeleteNetPrinter:
|
|
bRetval = bPrinterNetRemove( NULL, szBuffer, pParams->Flags.IsQuiet );
|
|
break;
|
|
|
|
case kDeleteLocalPrinter:
|
|
bRetval = bRemovePrinter( NULL, szBuffer, pParams->pMachineName, pParams->Flags.IsQuiet );
|
|
break;
|
|
|
|
case kInstallPrinterDriver:
|
|
bRetval = bDriverSetupNew( NULL, TWizard::kDriverInstall, MAX_PATH, szBuffer, &uSize,
|
|
pParams->pMachineName, 0, pParams->Flags.IsWizardRestartable );
|
|
break;
|
|
|
|
case kInstallLocalPrinter:
|
|
bRetval = bPrinterSetupNew( NULL, TWizard::kPrinterInstall, MAX_PATH, szBuffer, &uSize,
|
|
pParams->pMachineName, NULL, pParams->Flags.IsWizardRestartable );
|
|
break;
|
|
|
|
case kInstallLocalPrinterWithInf:
|
|
bRetval = bPrinterSetupNew( NULL, TWizard::kPrinterInstall, MAX_PATH, szBuffer, &uSize, pParams->pMachineName, pParams->pInfFileName, FALSE );
|
|
break;
|
|
|
|
case kInstallDriverWithInf:
|
|
bRetval = bDoInfDriverInstall( pParams );
|
|
break;
|
|
|
|
case kInstallPrinterWithInf:
|
|
bRetval = bDoInfPrinterInstall( pParams );
|
|
break;
|
|
|
|
case kAddPerMachineConnection:
|
|
vAddPerMachineConnection(pParams->pMachineName,pParams->pPrinterName,pParams->pProvider,pParams->Flags.IsQuiet);
|
|
break;
|
|
|
|
case kDeletePerMachineConnection:
|
|
vDeletePerMachineConnection(pParams->pMachineName,pParams->pPrinterName,pParams->Flags.IsQuiet);
|
|
break;
|
|
|
|
case kEnumPerMachineConnections:
|
|
vEnumPerMachineConnections(pParams->pMachineName,pParams->pInfFileName,pParams->Flags.IsQuiet);
|
|
break;
|
|
|
|
case kWin32QueueView:
|
|
vQueueCreate( NULL, pParams->pPrinterName, SW_SHOW, TRUE );
|
|
break;
|
|
|
|
case kProperties:
|
|
vPrinterPropPages( NULL, pParams->pPrinterName, SW_SHOW, MAKELPARAM( pParams->dwSheet+256, 0 ));
|
|
break;
|
|
|
|
case kDocumentDefaults:
|
|
vDocumentDefaults( NULL, pParams->pPrinterName, SW_SHOW, MAKELPARAM( pParams->dwSheet, 1 ));
|
|
break;
|
|
|
|
case kServerProperties:
|
|
vServerPropPages( NULL, pParams->pPrinterName, SW_SHOW, MAKELPARAM( pParams->dwSheet, 1 ));
|
|
break;
|
|
|
|
case kDeletePrinterDriver:
|
|
bRetval = bDoDriverRemoval( pParams );
|
|
break;
|
|
|
|
case kSetAsDefault:
|
|
bRetval = SetDefaultPrinter( pParams->pPrinterName );
|
|
break;
|
|
|
|
case kPrintTestPage:
|
|
bRetval = bDoPrintTestPage( hwnd, pParams->pPrinterName );
|
|
break;
|
|
|
|
case kPrinterGetSettings:
|
|
bRetval = bDoGetPrintSettings( pParams );
|
|
break;
|
|
|
|
case kPrinterSetSettings:
|
|
bRetval = bDoSetPrintSettings( pParams );
|
|
break;
|
|
|
|
case kPrinterPersist:
|
|
bRetval = bDoPersistPrinterSettings( kPrinterPersist , pParams );
|
|
break;
|
|
|
|
case kPrinterRestore:
|
|
bRetval = bDoPersistPrinterSettings( kPrinterRestore , pParams );
|
|
break;
|
|
|
|
case kCommandHelp:
|
|
vUsage( pParams );
|
|
break;
|
|
|
|
case kUnknown:
|
|
default:
|
|
bRetval = TRUE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Some of the functions do not setup pParams->dwLastError,
|
|
// so we must rely on the GetLastError() in this case.
|
|
//
|
|
if( !bRetval && ERROR_SUCCESS == pParams->dwLastError )
|
|
{
|
|
pParams->dwLastError = GetLastError();
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
vUsage
|
|
|
|
Routine Description:
|
|
|
|
Display a usage message for the rundll switches.
|
|
|
|
Arguments:
|
|
|
|
Nothing.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
VOID
|
|
vUsage(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
TString strTemp;
|
|
|
|
if (!pParams->Flags.IsQuiet)
|
|
{
|
|
TRunDllDisplay Usage( NULL );
|
|
|
|
if (VALID_OBJ( Usage ))
|
|
{
|
|
#ifdef COMMAND_SPECIFIC_HELP
|
|
if( pParams->ac )
|
|
{
|
|
for( UINT i = 0; i < pParams->ac; i++ )
|
|
{
|
|
bStatus DBGCHK = Usage.WriteOut( pParams->av[i] );
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n") );
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
//
|
|
// Note we do not check the return values of the string operations
|
|
// because bombing out is just as bad as printing an empty string. The
|
|
// string class will prevent us from ever crashing.
|
|
//
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, IDS_RUNDLL_TITLE );
|
|
bStatus DBGCHK = Usage.SetTitle( strTemp );
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, IDS_RUNDLL_USAGE );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
|
|
for( UINT i = IDS_RUNDLL_OPTION0; i <= IDS_RUNDLL_OPTION_END; i++ )
|
|
{
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n ") );
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, i );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
}
|
|
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n\r\n") );
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst,IDS_RUNDLL_EXAMPLE0 );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
|
|
for( i = IDS_RUNDLL_EXAMPLE1; i <= IDS_RUNDLL_EXAMPLE_END; i++ )
|
|
{
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n ") );
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, i );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
}
|
|
}
|
|
Usage.bDoModal();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoPersistPrinterSettings
|
|
|
|
Routine Description:
|
|
|
|
Store printer settings into file
|
|
Calls Re/StorePrinterSettings with args :
|
|
pParams->pPrinterName, pParams->pBinFileName and flags builded upon pParams->av
|
|
if pParams->ac == 0 , all setttings will be stored/restored
|
|
|
|
For restoring settings PRINTER_ALL_ACCESS required for specified printer
|
|
|
|
Arguments:
|
|
|
|
iFunction specify what function should be called ( Store/RestorePrinterSettings )
|
|
AParams* ptr to AParam structure
|
|
|
|
Return Value:
|
|
|
|
TRUE if Re/StorePrinterSettings SUCCEEDED.
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
BOOL
|
|
bDoPersistPrinterSettings(
|
|
IN INT iFunction,
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
DWORD dwFlags = 0;
|
|
UINT idx;
|
|
UINT ParamIdx;
|
|
UINT OptionIdx;
|
|
HRESULT hr;
|
|
|
|
struct ParamEntry
|
|
{
|
|
TCHAR Option;
|
|
DWORD Flag;
|
|
|
|
};
|
|
|
|
static ParamEntry PrintSettings_ParamTable [] = {
|
|
{TEXT('2'), PRST_PRINTER_INFO_2},
|
|
{TEXT('7'), PRST_PRINTER_INFO_7},
|
|
{TEXT('c'), PRST_COLOR_PROF},
|
|
{TEXT('d'), PRST_PRINTER_DATA},
|
|
{TEXT('s'), PRST_PRINTER_SEC},
|
|
{TEXT('g'), PRST_PRINTER_DEVMODE},
|
|
{TEXT('u'), PRST_USER_DEVMODE},
|
|
{TEXT('r'), PRST_RESOLVE_NAME},
|
|
{TEXT('f'), PRST_FORCE_NAME},
|
|
{TEXT('p'), PRST_RESOLVE_PORT},
|
|
{TEXT('h'), PRST_RESOLVE_SHARE},
|
|
{TEXT('H'), PRST_DONT_GENERATE_SHARE},
|
|
{TEXT('m'), PRST_MINIMUM_SETTINGS},
|
|
{0, 0},
|
|
};
|
|
|
|
|
|
// for every entry in table
|
|
for (ParamIdx = 0 ; ParamIdx < pParams->ac; ParamIdx++ )
|
|
{
|
|
//for every option argv
|
|
for (idx = 0; PrintSettings_ParamTable[idx].Option; idx++)
|
|
{
|
|
OptionIdx = 0;
|
|
|
|
//for every char in option argv
|
|
while(pParams->av[ParamIdx][OptionIdx])
|
|
{
|
|
if(OptionIdx > 0)
|
|
{
|
|
hr = E_FAIL;
|
|
goto End;
|
|
}
|
|
|
|
if(PrintSettings_ParamTable[idx].Option == pParams->av[ParamIdx][OptionIdx])
|
|
{
|
|
// apply flags if in table
|
|
dwFlags |= PrintSettings_ParamTable[idx].Flag;
|
|
|
|
DBGMSG(DBG_TRACE , ("Char %c\n" , pParams->av[ParamIdx][OptionIdx]));
|
|
|
|
}
|
|
|
|
OptionIdx++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if((dwFlags & PRST_FORCE_NAME) && (dwFlags & PRST_RESOLVE_NAME))
|
|
{
|
|
hr = E_FAIL;
|
|
goto End;
|
|
}
|
|
|
|
//
|
|
// if no "printer" flags specified , set flags to PRST_ALL_SETTINGS
|
|
//
|
|
if(!(dwFlags & PRST_ALL_SETTINGS))
|
|
{
|
|
dwFlags |= PRST_ALL_SETTINGS;
|
|
}
|
|
|
|
|
|
hr = (iFunction == kPrinterRestore) ?
|
|
RestorePrinterSettings( pParams->pPrinterName, pParams->pBinFileName, dwFlags)
|
|
:
|
|
StorePrinterSettings( pParams->pPrinterName, pParams->pBinFileName, dwFlags) ;
|
|
|
|
End:
|
|
|
|
return SUCCEEDED(hr);
|
|
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoWebPnpPreInstall
|
|
|
|
Routine Description:
|
|
|
|
Do Web Point and Print Pre installation tasks.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
pfConnection - pointer where to return connection status
|
|
|
|
Return Value:
|
|
|
|
TRUE Web Point and Print code was successfull, FALSE error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoWebPnpPreInstall(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
|
|
//
|
|
// Inform the point and print code pre entry.
|
|
//
|
|
bStatus DBGCHK = SUCCEEDED(Winspool_WebPnpEntry( pParams->pszCmdLine ));
|
|
|
|
//
|
|
// If something failed return the last error.
|
|
//
|
|
if( !bStatus )
|
|
{
|
|
pParams->dwLastError = GetLastError();
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoInfPrinterInstall
|
|
|
|
Routine Description:
|
|
|
|
Do inf based printer installation.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoInfPrinterInstall(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
TCHAR szBuffer[kPrinterBufMax];
|
|
|
|
//
|
|
// Assume success.
|
|
//
|
|
bStatus DBGNOCHK = TRUE;
|
|
|
|
//
|
|
// If we are invoked for a Web Point and Pint install.
|
|
//
|
|
if( bStatus && pParams->Flags.IsWebPointAndPrint )
|
|
{
|
|
//
|
|
// Inform the point and print code pre entry.
|
|
//
|
|
bStatus DBGCHK = bDoWebPnpPreInstall( pParams );
|
|
}
|
|
|
|
//
|
|
// If web pnp pre installed succeeded.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
TInfInstall II;
|
|
TParameterBlock PB;
|
|
|
|
ZeroMemory( &II, sizeof( II ) );
|
|
ZeroMemory( &PB, sizeof( PB ) );
|
|
ZeroMemory( szBuffer, sizeof( szBuffer ) );
|
|
|
|
if( pParams->pBasePrinterName )
|
|
{
|
|
_tcsncpy( szBuffer, pParams->pBasePrinterName, COUNTOF( szBuffer ) );
|
|
}
|
|
|
|
II.cbSize = sizeof( II );
|
|
II.pszServerName = pParams->pMachineName;
|
|
II.pszInfName = pParams->pInfFileName;
|
|
II.pszModelName = pParams->pModelName;
|
|
II.pszPortName = pParams->pPortName;
|
|
II.pszSourcePath = pParams->pSourcePath;
|
|
II.pszPrinterNameBuffer = szBuffer;
|
|
II.cchPrinterName = COUNTOF( szBuffer );
|
|
|
|
//
|
|
// If this is a web point and print install then set the flags
|
|
// to indicate that we want to create the masq printer.
|
|
//
|
|
II.dwFlags = 0;
|
|
II.dwFlags |= pParams->Flags.IsWebPointAndPrint ? kPnPInterface_WebPointAndPrint : 0;
|
|
II.dwFlags |= pParams->Flags.IsQuiet ? kPnPInterface_Quiet : 0;
|
|
II.dwFlags |= pParams->Flags.IsNoSharing ? kPnPInterface_NoShare : 0;
|
|
II.dwFlags |= pParams->Flags.IsUseExistingDriver ? kPnpInterface_UseExisting : 0;
|
|
II.dwFlags |= pParams->Flags.IsUnknownDriverPrompt ? kPnpInterface_PromptIfUnknownDriver : 0;
|
|
II.dwFlags |= pParams->Flags.IsHydraSpecific ? kPnpInterface_HydraSpecific : 0;
|
|
II.dwFlags |= pParams->Flags.IsPromptForNeededFiles ? kPnPInterface_PromptIfFileNeeded : 0;
|
|
II.dwFlags |= pParams->Flags.IsShared ? kPnPInterface_Share : 0;
|
|
II.dwFlags |= pParams->Flags.IsDontAutoGenerateName ? kPnPInterface_DontAutoGenerateName : 0;
|
|
II.dwFlags |= pParams->Flags.IsSupressSetupUI ? kPnPInterface_SupressSetupUI : 0;
|
|
|
|
PB.pInfInstall = &II;
|
|
|
|
pParams->dwLastError = PnPInterface( kInfInstall, &PB );
|
|
|
|
bStatus DBGNOCHK = (pParams->dwLastError == ERROR_SUCCESS);
|
|
}
|
|
|
|
//
|
|
// If we succeeded and this is a web point and print event.
|
|
//
|
|
if( bStatus && pParams->Flags.IsWebPointAndPrint )
|
|
{
|
|
//
|
|
// Inform the web point and print code that the printer was
|
|
// installed, they can do ay post processing here.
|
|
//
|
|
bStatus DBGCHK = SUCCEEDED(Winspool_WebPnpPostEntry( FALSE, pParams->pBinFileName, pParams->pPortName, szBuffer ));
|
|
}
|
|
|
|
return pParams->dwLastError == ERROR_SUCCESS ? TRUE : FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoInfDriverInstall
|
|
|
|
Routine Description:
|
|
|
|
Do inf based printer driver installation.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoInfDriverInstall(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TInfDriverInstall II = {0};
|
|
TParameterBlock PB = {0};
|
|
|
|
II.cbSize = sizeof( II );
|
|
II.pszServerName = pParams->pMachineName;
|
|
II.pszInfName = pParams->pInfFileName;
|
|
II.pszModelName = pParams->pModelName;
|
|
II.pszSourcePath = pParams->pSourcePath;
|
|
II.pszVersion = pParams->pVersion;
|
|
II.pszArchitecture = pParams->pArchitecture;
|
|
|
|
II.dwFlags = 0;
|
|
II.dwFlags |= pParams->Flags.IsQuiet ? kPnPInterface_Quiet : 0;
|
|
II.dwFlags |= pParams->Flags.IsWindowsUpdate ? kPnPInterface_WindowsUpdate : 0;
|
|
II.dwFlags |= pParams->Flags.IsUseNonLocalizedStrings ? kPnPInterface_UseNonLocalizedStrings : 0;
|
|
II.dwFlags |= pParams->Flags.IsSupressSetupUI ? kPnPInterface_SupressSetupUI : 0;
|
|
|
|
PB.pInfDriverInstall = &II;
|
|
|
|
pParams->dwLastError = PnPInterface( kInfDriverInstall, &PB );
|
|
|
|
return pParams->dwLastError == ERROR_SUCCESS;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoDriverRemoval
|
|
|
|
Routine Description:
|
|
|
|
Do driver delete
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoDriverRemoval(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TDriverRemoval II = {0};
|
|
TParameterBlock PB = {0};
|
|
|
|
II.cbSize = sizeof( II );
|
|
II.pszServerName = pParams->pMachineName;
|
|
II.pszModelName = pParams->pModelName;
|
|
II.pszVersion = pParams->pVersion;
|
|
II.pszArchitecture = pParams->pArchitecture;
|
|
|
|
II.dwFlags = 0;
|
|
II.dwFlags |= pParams->Flags.IsUseNonLocalizedStrings ? kPnPInterface_UseNonLocalizedStrings : 0;
|
|
II.dwFlags |= pParams->Flags.IsQuiet ? kPnPInterface_Quiet : 0;
|
|
II.dwFlags |= pParams->Flags.IsSupressSetupUI ? kPnPInterface_SupressSetupUI : 0;
|
|
|
|
PB.pDriverRemoval = &II;
|
|
|
|
pParams->dwLastError = PnPInterface( kDriverRemoval, &PB );
|
|
|
|
if( ERROR_UNKNOWN_PRINTER_DRIVER == pParams->dwLastError )
|
|
{
|
|
// this error code is used primarily for blocking bad
|
|
// oem drivers so the default message used is pretty
|
|
// incorrect. remap the message to better one based on
|
|
// the context
|
|
CMsgBoxCounter::SetMsg(IDS_ERROR_DRIVER_DOESNT_EXISTS);
|
|
}
|
|
|
|
return pParams->dwLastError == ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
/********************************************************************
|
|
|
|
Setting and Getting printer information methods.
|
|
|
|
********************************************************************/
|
|
|
|
static TSelect::SelectionVal PrintSettings_ValueTable [] = {
|
|
{IDS_RUNDLL_SET_PAUSE, PRINTER_CONTROL_PAUSE, OFFSETOF( PRINTER_INFO_2, Status )},
|
|
{IDS_RUNDLL_SET_RESUME, PRINTER_CONTROL_RESUME, OFFSETOF( PRINTER_INFO_2, Status )},
|
|
{IDS_RUNDLL_SET_PURGE, PRINTER_CONTROL_PURGE, OFFSETOF( PRINTER_INFO_2, Status )},
|
|
{NULL, 0, NULL}};
|
|
|
|
static TSelect::SelectionBit PrintSettings_BitTable [] = {
|
|
{IDS_RUNDLL_SET_QUEUED, PRINTER_ATTRIBUTE_QUEUED, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_DIRECT, PRINTER_ATTRIBUTE_DIRECT, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_DEFAULT, PRINTER_ATTRIBUTE_DEFAULT, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_SHARED, PRINTER_ATTRIBUTE_SHARED, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_HIDDEN, PRINTER_ATTRIBUTE_HIDDEN, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_NETWORK, PRINTER_ATTRIBUTE_NETWORK, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_LOCAL, PRINTER_ATTRIBUTE_LOCAL, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_ENABLEDEVQ, PRINTER_ATTRIBUTE_ENABLE_DEVQ, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_KEEPPRINTEDJOBS,PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_DOCOMPLETEFIRST,PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST,TSelect::kNop},
|
|
{IDS_RUNDLL_SET_WORKOFFLINE, PRINTER_ATTRIBUTE_WORK_OFFLINE, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_ENABLEBIDI, PRINTER_ATTRIBUTE_ENABLE_BIDI, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_RAWONLY, PRINTER_ATTRIBUTE_RAW_ONLY, TSelect::kNop},
|
|
{IDS_RUNDLL_SET_PUBLISHED, PRINTER_ATTRIBUTE_PUBLISHED, TSelect::kNop},
|
|
{0, 0, TSelect::kNop}};
|
|
|
|
static TSelect::Selection PrintSettings_Table [] = {
|
|
{IDS_RUNDLL_SET_PRINTERNAME, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pPrinterName ) },
|
|
{IDS_RUNDLL_SET_SHARENAME, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pShareName ) },
|
|
{IDS_RUNDLL_SET_PORTNAME, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pPortName ) },
|
|
{IDS_RUNDLL_SET_DRIVERNAME, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pDriverName ) },
|
|
{IDS_RUNDLL_SET_COMMENT, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pComment ) },
|
|
{IDS_RUNDLL_SET_LOCATION, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pLocation ) },
|
|
{IDS_RUNDLL_SET_SEPFILE, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pSepFile ) },
|
|
{IDS_RUNDLL_SET_PRINTPROCESSOR, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pPrintProcessor )},
|
|
{IDS_RUNDLL_SET_DATATYPE, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pDatatype ) },
|
|
{IDS_RUNDLL_SET_PARAMETERS, TSelect::kString, NULL, OFFSETOF( PRINTER_INFO_2, pParameters ) },
|
|
{IDS_RUNDLL_SET_ATTRIBUTES, TSelect::kBitTable, PrintSettings_BitTable, OFFSETOF( PRINTER_INFO_2, Attributes ) },
|
|
{IDS_RUNDLL_SET_PRIORITY, TSelect::kInt, NULL, OFFSETOF( PRINTER_INFO_2, Priority ) },
|
|
{IDS_RUNDLL_SET_DEFAULTPRIORITY,TSelect::kInt, NULL, OFFSETOF( PRINTER_INFO_2, DefaultPriority ) },
|
|
{IDS_RUNDLL_SET_STARTTIME, TSelect::kInt, NULL, OFFSETOF( PRINTER_INFO_2, StartTime ) },
|
|
{IDS_RUNDLL_SET_UNTILTIME, TSelect::kInt, NULL, OFFSETOF( PRINTER_INFO_2, UntilTime ) },
|
|
{IDS_RUNDLL_SET_STATUS, TSelect::kValTable, PrintSettings_ValueTable,OFFSETOF( PRINTER_INFO_2, Status ) },
|
|
{NULL, TSelect::kNone, NULL, NULL }};
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoGetPrintSettings
|
|
|
|
Routine Description:
|
|
|
|
Get the specified printer settings.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
bDoGetPrintSettings(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "bDoGetPrintSettings\n" ) );
|
|
return PrintSettings_DisplayInformation( pParams, PrintSettings_Table );
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bDoSetPrintSettings
|
|
|
|
Routine Description:
|
|
|
|
Set the specified printer settings.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
bDoSetPrintSettings(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "bDoSetPrintSettings\n" ) );
|
|
DBGMSG( DBG_TRACE, ( "Argument count %d.\n", pParams->ac ) );
|
|
|
|
TStatusB bStatus;
|
|
bStatus DBGNOCHK = FALSE;
|
|
TSelect Select;
|
|
PRINTER_INFO_2 Info = {0};
|
|
|
|
Info.Attributes = (DWORD)-1;
|
|
Info.Priority = (DWORD)-1;
|
|
Info.DefaultPriority = (DWORD)-1;
|
|
Info.StartTime = (DWORD)-1;
|
|
Info.UntilTime = (DWORD)-1;
|
|
Info.Status = (DWORD)-1;
|
|
|
|
//
|
|
// Validate command arguments
|
|
//
|
|
if( !PrintSettings_ValidateArguments( pParams ) )
|
|
{
|
|
DBGMSG( DBG_WARN, ( "Argument validation failed.\n" ) );
|
|
return pParams->dwLastError == ERROR_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Lookup the printer setting command.
|
|
//
|
|
for( UINT i = 0; i < pParams->ac; i += 2 )
|
|
{
|
|
if( (i+0 < pParams->ac) && (i+1 < pParams->ac) )
|
|
{
|
|
bStatus DBGCHK = Select.bLookup( PrintSettings_Table, &Info, pParams->av[i], pParams->av[i+1] );
|
|
|
|
if( !bStatus )
|
|
{
|
|
DBGMSG( DBG_WARN, ( "Invalid key name found.\n" ) );
|
|
pParams->dwLastError = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DBGMSG( DBG_WARN, ( "Unmatched key / value pair arguments\n" ) );
|
|
pParams->dwLastError = ERROR_INVALID_PARAMETER;
|
|
bStatus DBGNOCHK = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the printer data.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Set the printer information.
|
|
//
|
|
bStatus DBGCHK = PrintSettings_SetInfo( pParams, Info );
|
|
|
|
if( !bStatus )
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_SetInfo failed with %d\n", pParams->dwLastError ) );
|
|
}
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_ValidateArguments
|
|
|
|
Routine Description:
|
|
|
|
Validate the command line arguments
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
PrintSettings_ValidateArguments(
|
|
IN AParams *pParams
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
bStatus DBGNOCHK = FALSE;
|
|
TString strHelp1;
|
|
TString strHelp2;
|
|
|
|
//
|
|
// There must be at least one additional argumet.
|
|
//
|
|
if( !(pParams->ac >= 1) )
|
|
{
|
|
DBGMSG( DBG_WARN, ( "Insufficent number of additional arguments.\n" ) );
|
|
pParams->dwLastError = ERROR_INVALID_PARAMETER;
|
|
return bStatus;
|
|
}
|
|
|
|
//
|
|
// If a help command was specified.
|
|
//
|
|
bStatus DBGCHK = strHelp1.bLoadString( ghInst, IDS_RUNDLL_HELP1 );
|
|
bStatus DBGCHK = strHelp2.bLoadString( ghInst, IDS_RUNDLL_HELP2 );
|
|
if( !_tcsicmp( pParams->av[0], strHelp1 ) || !_tcsicmp( pParams->av[0], strHelp2 ) )
|
|
{
|
|
pParams->dwLastError = ERROR_SUCCESS;
|
|
PrintSettings_DisplayHelp( pParams, PrintSettings_Table );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Success we have validated the arguments.
|
|
//
|
|
bStatus DBGNOCHK = TRUE;
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_SetInfo
|
|
|
|
Routine Description:
|
|
|
|
Set the printer info data.
|
|
|
|
Arguments:
|
|
|
|
Info - Reference to printer info data.
|
|
pParams - pointer to paramter structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
PrintSettings_SetInfo(
|
|
IN AParams *pParams,
|
|
IN PRINTER_INFO_2 &Info
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_SetInfo\n" ) );
|
|
|
|
TStatus Status;
|
|
TStatusB bStatus;
|
|
|
|
bStatus DBGNOCHK = FALSE;
|
|
|
|
HANDLE hPrinter = NULL;
|
|
PPRINTER_INFO_2 pInfo = NULL;
|
|
DWORD cbInfo = 0;
|
|
DWORD dwAccess = 0;
|
|
DWORD dwOldAttributes = 0;
|
|
DWORD dwNewAttributes = 0;
|
|
|
|
//
|
|
// Open the printer.
|
|
//
|
|
Status DBGCHK = TPrinter::sOpenPrinter( pParams->pPrinterName, &dwAccess, &hPrinter );
|
|
|
|
if( Status == ERROR_SUCCESS )
|
|
{
|
|
//
|
|
// Get the printer data.
|
|
//
|
|
bStatus DBGNOCHK = VDataRefresh::bGetPrinter( hPrinter, 2, (PVOID *)&pInfo, (PDWORD)&cbInfo );
|
|
|
|
//
|
|
// Merge in any changed fields.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
TSelect Select;
|
|
|
|
//
|
|
// Convert the bit table to a value.
|
|
//
|
|
Select.bApplyBitTableToValue( PrintSettings_BitTable, pInfo->Attributes, &Info.Attributes );
|
|
|
|
//
|
|
// Publishing and UnPublishing needs to be special cased, since this setting is
|
|
// not done in the printer info 2 structure. The published bit is a read only
|
|
// attribute in the printer info 2, the publish state is changed using set printer
|
|
// info 7.
|
|
//
|
|
dwOldAttributes = pInfo->Attributes;
|
|
dwNewAttributes = Info.Attributes != -1 ? Info.Attributes : pInfo->Attributes;
|
|
|
|
//
|
|
// Copy the changed date into the info sturcture.
|
|
//
|
|
pInfo->pPrinterName = Info.pPrinterName ? Info.pPrinterName : pInfo->pPrinterName;
|
|
pInfo->pShareName = Info.pShareName ? Info.pShareName : pInfo->pShareName;
|
|
pInfo->pPortName = Info.pPortName ? Info.pPortName : pInfo->pPortName;
|
|
pInfo->pDriverName = Info.pDriverName ? Info.pDriverName : pInfo->pDriverName;
|
|
pInfo->pComment = Info.pComment ? Info.pComment : pInfo->pComment;
|
|
pInfo->pLocation = Info.pLocation ? Info.pLocation : pInfo->pLocation;
|
|
pInfo->pSepFile = Info.pSepFile ? Info.pSepFile : pInfo->pSepFile;
|
|
pInfo->pDatatype = Info.pDatatype ? Info.pDatatype : pInfo->pDatatype;
|
|
pInfo->pParameters = Info.pParameters ? Info.pParameters : pInfo->pParameters;
|
|
|
|
pInfo->Attributes = Info.Attributes != -1 ? Info.Attributes : pInfo->Attributes;
|
|
pInfo->Priority = Info.Priority != -1 ? Info.Priority : pInfo->Priority;
|
|
pInfo->DefaultPriority = Info.DefaultPriority != -1 ? Info.DefaultPriority : pInfo->DefaultPriority;
|
|
pInfo->StartTime = Info.StartTime != -1 ? Info.StartTime : pInfo->StartTime;
|
|
pInfo->UntilTime = Info.UntilTime != -1 ? Info.UntilTime : pInfo->UntilTime;
|
|
}
|
|
|
|
//
|
|
// Set the changed printer data.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
bStatus DBGCHK = SetPrinter( hPrinter, 2, (PBYTE)pInfo, 0 );
|
|
|
|
if( bStatus )
|
|
{
|
|
if( Info.Status != -1 )
|
|
{
|
|
bStatus DBGCHK = SetPrinter( hPrinter, 0, NULL, Info.Status );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle the printer publishing case.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Only do something if the attributes are different.
|
|
//
|
|
if( dwOldAttributes != dwNewAttributes )
|
|
{
|
|
//
|
|
// If the current printer state is not shared and it
|
|
// was previously published then unpublish it now.
|
|
//
|
|
if(!(pInfo->Attributes & PRINTER_ATTRIBUTE_SHARED) &&
|
|
dwOldAttributes & PRINTER_ATTRIBUTE_PUBLISHED)
|
|
{
|
|
dwNewAttributes &= ~PRINTER_ATTRIBUTE_PUBLISHED;
|
|
}
|
|
|
|
//
|
|
// Only unpublish requests or shared printer publish requests.
|
|
//
|
|
bStatus DBGCHK = !(dwNewAttributes & PRINTER_ATTRIBUTE_PUBLISHED) ||
|
|
(dwNewAttributes & PRINTER_ATTRIBUTE_PUBLISHED &&
|
|
pInfo->Attributes & PRINTER_ATTRIBUTE_SHARED);
|
|
|
|
if(bStatus)
|
|
{
|
|
PRINTER_INFO_7 Info7 = {0};
|
|
|
|
Info7.dwAction = (dwNewAttributes & PRINTER_ATTRIBUTE_PUBLISHED)
|
|
? DSPRINT_PUBLISH : DSPRINT_UNPUBLISH;
|
|
|
|
bStatus DBGCHK = SetPrinter( hPrinter, 7, (PBYTE)&Info7, 0 );
|
|
|
|
//
|
|
// Printer info 7 fails with ERROR_IO_PENDING when the publishing is occurring
|
|
// in the background. For the rundll32 interface just return success.
|
|
//
|
|
if(!bStatus && (GetLastError() == ERROR_IO_PENDING))
|
|
{
|
|
SetLastError(ERROR_SUCCESS);
|
|
bStatus DBGNOCHK = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the printer info data.
|
|
//
|
|
FreeMem( pInfo );
|
|
|
|
//
|
|
// Close the printer handle if one was opened.
|
|
//
|
|
if( hPrinter )
|
|
{
|
|
ClosePrinter( hPrinter );
|
|
}
|
|
}
|
|
|
|
//
|
|
// If something failed preserve the last error.
|
|
//
|
|
if( !bStatus )
|
|
{
|
|
pParams->dwLastError = GetLastError();
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_DisplayHelp
|
|
|
|
Routine Description:
|
|
|
|
Displays the printer settings command arguments.
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
pSelection - pointer argument selection table.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
PrintSettings_DisplayHelp(
|
|
IN AParams *pParams,
|
|
IN TSelect::Selection *pSelection
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_DisplayHelp\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
TRunDllDisplay Usage( NULL, pParams->pInfFileName, (pParams->pInfFileName && *pParams->pInfFileName) ?
|
|
TRunDllDisplay::kFile : TRunDllDisplay::kEditBox );
|
|
|
|
bStatus DBGNOCHK = VALID_OBJ( Usage );
|
|
|
|
if( bStatus )
|
|
{
|
|
TString strTemp;
|
|
TString strString;
|
|
TString strInt;
|
|
TString strStart;
|
|
TString strEnd;
|
|
TString strSep;
|
|
TString strFormat;
|
|
TString strBit;
|
|
LPCTSTR pszType;
|
|
|
|
//
|
|
// Set the title.
|
|
//
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, IDS_RUNDLL_SET_ATTRIBUTE_TITLE );
|
|
bStatus DBGCHK = Usage.SetTitle( strTemp );
|
|
|
|
//
|
|
// Set the usage example.
|
|
//
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, IDS_RUNDLL_SET_ATTRIBUTE_USAGE );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n") );
|
|
|
|
//
|
|
// Load some constant strings.
|
|
//
|
|
bStatus DBGCHK = strString.bLoadString( ghInst, IDS_RUNDLL_STRING );
|
|
bStatus DBGCHK = strInt.bLoadString( ghInst, IDS_RUNDLL_INTEGER );
|
|
bStatus DBGCHK = strStart.bLoadString( ghInst, IDS_RUNDLL_START );
|
|
bStatus DBGCHK = strEnd.bLoadString( ghInst, IDS_RUNDLL_END );
|
|
bStatus DBGCHK = strSep.bLoadString( ghInst, IDS_RUNDLL_SEP );
|
|
bStatus DBGCHK = strFormat.bLoadString( ghInst, IDS_RUNDLL_FORMAT );
|
|
|
|
for( ; pSelection->iKeyWord; pSelection++ )
|
|
{
|
|
switch( pSelection->eDataType )
|
|
{
|
|
case TSelect::kInt:
|
|
pszType = strInt;
|
|
break;
|
|
|
|
case TSelect::kString:
|
|
pszType = strString;
|
|
break;
|
|
|
|
case TSelect::kValTable:
|
|
case TSelect::kBitTable:
|
|
{
|
|
bStatus DBGCHK = strBit.bUpdate( strStart );
|
|
TSelect::SelectionBit *pSel = (TSelect::SelectionBit *)pSelection->pTable;
|
|
for( ; pSel->iKeyWord; pSel++ )
|
|
{
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, pSel->iKeyWord );
|
|
bStatus DBGCHK = strBit.bCat( strTemp );
|
|
if( (pSel+1)->iKeyWord )
|
|
{
|
|
bStatus DBGCHK = strBit.bCat( strSep );
|
|
}
|
|
}
|
|
bStatus DBGCHK = strBit.bCat( strEnd );
|
|
pszType = strBit;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
pszType = gszNULL;
|
|
break;
|
|
}
|
|
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, pSelection->iKeyWord );
|
|
bStatus DBGCHK = strTemp.bFormat( strFormat, (LPCTSTR)strTemp, pszType );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n") );
|
|
}
|
|
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst,IDS_RUNDLL_EXAMPLE0 );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
|
|
for( UINT i = IDS_RUNDLL_SET_EXAMPLE1; i <= IDS_RUNDLL_SET_EXAMPLE_END; i++ )
|
|
{
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n ") );
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, i );
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
}
|
|
|
|
bStatus DBGCHK = Usage.bDoModal();
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_DisplayInformation
|
|
|
|
Routine Description:
|
|
|
|
Displays the printer settings
|
|
|
|
Arguments:
|
|
|
|
pParams - pointer to paramter structure.
|
|
pSelection - pointer argument selection table.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
PrintSettings_DisplayInformation(
|
|
IN AParams *pParams,
|
|
IN TSelect::Selection *pSelection
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_DisplayInformation\n" ) );
|
|
|
|
TStatus Status( DBG_WARN );
|
|
TString strTemp;
|
|
TString strKeyword;
|
|
TString strFormat1;
|
|
TString strFormat2;
|
|
TString strTitle;
|
|
TStatusB bStatus;
|
|
|
|
bStatus DBGNOCHK = FALSE;
|
|
DWORD dwAccess = 0;
|
|
HANDLE hPrinter = NULL;
|
|
PPRINTER_INFO_2 pInfo = NULL;
|
|
DWORD cbInfo = 0;
|
|
|
|
//
|
|
// Open the printer.
|
|
//
|
|
Status DBGCHK = TPrinter::sOpenPrinter( pParams->pPrinterName, &dwAccess, &hPrinter );
|
|
|
|
if( Status == ERROR_SUCCESS )
|
|
{
|
|
//
|
|
// Get the printer data.
|
|
//
|
|
bStatus DBGNOCHK = VDataRefresh::bGetPrinter( hPrinter, 2, (PVOID *)&pInfo, (PDWORD)&cbInfo );
|
|
|
|
if( bStatus )
|
|
{
|
|
//
|
|
// Display the printer data.
|
|
//
|
|
TRunDllDisplay Usage( NULL, pParams->pInfFileName, (pParams->pInfFileName && *pParams->pInfFileName) ?
|
|
TRunDllDisplay::kFile : TRunDllDisplay::kEditBox );
|
|
|
|
bStatus DBGNOCHK = VALID_OBJ( Usage );
|
|
|
|
if( bStatus )
|
|
{
|
|
Usage.vSetTabStops(64);
|
|
|
|
bStatus DBGCHK = strTitle.bLoadString( ghInst, IDS_RUNDLL_DISPLAY_TITLE );
|
|
bStatus DBGCHK = strTitle.bCat( pParams->pPrinterName );
|
|
Usage.SetTitle( strTitle );
|
|
|
|
bStatus DBGCHK = strFormat1.bLoadString( ghInst, IDS_RUNDLL_DISPLAY_FORMAT1 );
|
|
bStatus DBGCHK = strFormat2.bLoadString( ghInst, IDS_RUNDLL_DISPLAY_FORMAT2 );
|
|
|
|
for( ; pSelection->iKeyWord; pSelection++ )
|
|
{
|
|
bStatus DBGCHK = strKeyword.bLoadString( ghInst, pSelection->iKeyWord );
|
|
|
|
switch( pSelection->eDataType )
|
|
{
|
|
case TSelect::kString:
|
|
bStatus DBGCHK = strTemp.bFormat( strFormat1, (LPCTSTR)strKeyword, *(LPCTSTR *)((PBYTE)pInfo+pSelection->iOffset) );
|
|
break;
|
|
|
|
case TSelect::kInt:
|
|
bStatus DBGCHK = strTemp.bFormat( strFormat2, (LPCTSTR)strKeyword, *(UINT *)((PBYTE)pInfo+pSelection->iOffset) );
|
|
break;
|
|
|
|
case TSelect::kBitTable:
|
|
bStatus DBGCHK = PrintSettings_DisplayAttributes( strTemp, pSelection, *(UINT *)((PBYTE)pInfo+pSelection->iOffset) );
|
|
bStatus DBGCHK = strTemp.bFormat( strFormat1, (LPCTSTR)strKeyword, (LPCTSTR)strTemp );
|
|
break;
|
|
|
|
case TSelect::kValTable:
|
|
bStatus DBGCHK = PrintSettings_DisplayStatus( strTemp, pSelection, *(UINT *)((PBYTE)pInfo+pSelection->iOffset) );
|
|
bStatus DBGCHK = strTemp.bFormat( strFormat1, (LPCTSTR)strKeyword, (LPCTSTR)strTemp );
|
|
break;
|
|
|
|
default:
|
|
bStatus DBGCHK = strTemp.bUpdate( NULL );
|
|
break;
|
|
}
|
|
|
|
bStatus DBGCHK = Usage.WriteOut( strTemp );
|
|
bStatus DBGCHK = Usage.WriteOut( TEXT("\r\n") );
|
|
|
|
}
|
|
|
|
bStatus DBGCHK = Usage.bDoModal();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the printer info data.
|
|
//
|
|
FreeMem( pInfo );
|
|
|
|
//
|
|
// Close the printer handle if one was opened.
|
|
//
|
|
if( hPrinter )
|
|
{
|
|
ClosePrinter( hPrinter );
|
|
}
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_DisplayAttributes
|
|
|
|
Routine Description:
|
|
|
|
Get the current printer attributes in a displayable form.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
PrintSettings_DisplayAttributes(
|
|
IN TString &strBit,
|
|
IN TSelect::Selection *pSelection,
|
|
IN UINT uAttributes
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_DisplayAttributes\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
TString strStart;
|
|
TString strEnd;
|
|
TString strSep;
|
|
TString strTemp;
|
|
|
|
bStatus DBGCHK = strStart.bLoadString( ghInst, IDS_RUNDLL_START );
|
|
bStatus DBGCHK = strEnd.bLoadString( ghInst, IDS_RUNDLL_END );
|
|
bStatus DBGCHK = strSep.bLoadString( ghInst, IDS_RUNDLL_SEP );
|
|
|
|
TSelect::SelectionBit *pSel = (TSelect::SelectionBit *)pSelection->pTable;
|
|
|
|
bStatus DBGCHK = strBit.bUpdate( strStart );
|
|
|
|
for( ; pSel->iKeyWord; pSel++ )
|
|
{
|
|
if( uAttributes & pSel->uBit )
|
|
{
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, pSel->iKeyWord );
|
|
bStatus DBGCHK = strBit.bCat( strTemp );
|
|
bStatus DBGCHK = strBit.bCat( strSep );
|
|
}
|
|
}
|
|
|
|
bStatus DBGCHK = strBit.bCat( strEnd );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
PrintSettings_DisplayStatus
|
|
|
|
Routine Description:
|
|
|
|
Get the status in a displayable form.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error.
|
|
|
|
--*/
|
|
BOOL
|
|
PrintSettings_DisplayStatus(
|
|
IN TString &strVal,
|
|
IN TSelect::Selection *pSelection,
|
|
IN UINT uStatus
|
|
)
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "PrintSettings_DisplayStatus\n" ) );
|
|
|
|
TStatusB bStatus;
|
|
TString strStart;
|
|
TString strEnd;
|
|
TString strTemp;
|
|
|
|
bStatus DBGCHK = strStart.bLoadString( ghInst, IDS_RUNDLL_START );
|
|
bStatus DBGCHK = strEnd.bLoadString( ghInst, IDS_RUNDLL_END );
|
|
|
|
TSelect::SelectionVal *pSel = (TSelect::SelectionVal *)pSelection->pTable;
|
|
|
|
bStatus DBGCHK = strVal.bUpdate( strStart );
|
|
|
|
for( ; pSel->iKeyWord; pSel++ )
|
|
{
|
|
if( uStatus == pSel->uValue )
|
|
{
|
|
bStatus DBGCHK = strTemp.bLoadString( ghInst, pSel->iKeyWord );
|
|
bStatus DBGCHK = strVal.bCat( strTemp );
|
|
break;
|
|
}
|
|
}
|
|
|
|
bStatus DBGCHK = strVal.bCat( strEnd );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
RunDll Usage
|
|
|
|
********************************************************************/
|
|
|
|
TRunDllDisplay::
|
|
TRunDllDisplay(
|
|
IN HWND hWnd,
|
|
IN LPCTSTR pszFileName,
|
|
IN DisplayType Display
|
|
) : _hWnd( hWnd ),
|
|
_bValid( FALSE ),
|
|
_Display( Display ),
|
|
_pFile( NULL ),
|
|
_cxGrip( 0 ),
|
|
_cyGrip( 0 ),
|
|
_hwndGrip( NULL ),
|
|
_cTabStop( 0 ),
|
|
_dwTabStop( 0 )
|
|
{
|
|
memset( &_ptLastSize, 0, sizeof(_ptLastSize) );
|
|
memset( &_ptMinTrack, 0, sizeof(_ptMinTrack) );
|
|
|
|
switch( _Display )
|
|
{
|
|
case kFile:
|
|
_pFile = new TFile( pszFileName );
|
|
_bValid = VALID_PTR( _pFile );
|
|
break;
|
|
|
|
case kEditBox:
|
|
_bValid = TRUE;
|
|
break;
|
|
|
|
default:
|
|
SPLASSERT( FALSE );
|
|
_bValid = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
TRunDllDisplay::
|
|
~TRunDllDisplay(
|
|
VOID
|
|
)
|
|
{
|
|
if( _hwndGrip )
|
|
{
|
|
DestroyWindow( _hwndGrip );
|
|
}
|
|
|
|
delete _pFile;
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
WriteOut(
|
|
LPCTSTR pszData
|
|
)
|
|
{
|
|
SPLASSERT( pszData );
|
|
return _StringOutput.bCat(pszData);
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return _bValid;
|
|
}
|
|
|
|
VOID
|
|
TRunDllDisplay::
|
|
vSetTabStops(
|
|
IN UINT uTabStop
|
|
)
|
|
{
|
|
_cTabStop = 1;
|
|
_dwTabStop = uTabStop;
|
|
}
|
|
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bDoModal(
|
|
VOID
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
|
|
switch( _Display )
|
|
{
|
|
case kEditBox:
|
|
bStatus DBGCHK = (BOOL)DialogBoxParam( ghInst,
|
|
MAKEINTRESOURCE( DLG_RUNDLL ),
|
|
_hWnd,
|
|
MGenericDialog::SetupDlgProc,
|
|
(LPARAM)this );
|
|
break;
|
|
|
|
case kFile:
|
|
bStatus DBGCHK = _pFile->bWrite( _StringOutput );
|
|
break;
|
|
|
|
default:
|
|
bStatus DBGNOCHK = FALSE;
|
|
break;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
SetTitle(
|
|
IN LPCTSTR pszData
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
bStatus DBGCHK = _StringTitle.bUpdate(pszData);
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bSetUI(
|
|
VOID
|
|
)
|
|
{
|
|
TStatusB bStatus;
|
|
|
|
bStatus DBGCHK = bSetEditText( _hDlg, IDC_RUNDLL_TITLE, _StringTitle );
|
|
bStatus DBGCHK = bSetEditText( _hDlg, IDC_RUNDLL_TEXT, _StringOutput );
|
|
SendDlgItemMessage( _hDlg, IDC_RUNDLL_TEXT, EM_SETMODIFY, TRUE, 0 );
|
|
|
|
//
|
|
// Set any applicable tab stops.
|
|
//
|
|
SendDlgItemMessage( _hDlg, IDC_RUNDLL_TEXT, EM_SETTABSTOPS, _cTabStop, (LPARAM)&_dwTabStop );
|
|
|
|
//
|
|
// Set the initial size.
|
|
//
|
|
RECT rect;
|
|
GetWindowRect(_hDlg, &rect);
|
|
_ptLastSize.x = rect.right - rect.left;
|
|
_ptLastSize.y = rect.bottom - rect.top;
|
|
|
|
//
|
|
// Save the minimum track information.
|
|
//
|
|
_ptMinTrack.x = rect.right - rect.left;
|
|
_ptMinTrack.y = rect.bottom - rect.top;
|
|
|
|
//
|
|
// Create the sizing grip.
|
|
//
|
|
RECT rc;
|
|
GetClientRect(_hDlg, &rc);
|
|
|
|
_cxGrip = GetSystemMetrics(SM_CXVSCROLL);
|
|
_cyGrip = GetSystemMetrics(SM_CYHSCROLL);
|
|
|
|
_hwndGrip = CreateWindow( TEXT("Scrollbar"),
|
|
NULL,
|
|
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS |
|
|
WS_CLIPCHILDREN | SBS_BOTTOMALIGN | SBS_SIZEGRIP |
|
|
SBS_SIZEBOXBOTTOMRIGHTALIGN,
|
|
rc.right - _cxGrip,
|
|
rc.bottom - _cyGrip,
|
|
_cxGrip,
|
|
_cyGrip,
|
|
_hDlg,
|
|
(HMENU)-1,
|
|
ghInst,
|
|
NULL );
|
|
|
|
if( !_hwndGrip )
|
|
{
|
|
bStatus DBGCHK = FALSE;
|
|
}
|
|
|
|
//
|
|
// Set the dialog icon.
|
|
//
|
|
INT cxIcon = GetSystemMetrics(SM_CXICON);
|
|
INT cyIcon = GetSystemMetrics(SM_CYICON);
|
|
HANDLE hIcon;
|
|
|
|
if( hIcon = LoadImage( ghInst, MAKEINTRESOURCE(IDI_PRINTER), IMAGE_ICON, cxIcon, cyIcon, 0 ) )
|
|
{
|
|
SendMessage( _hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon );
|
|
}
|
|
|
|
//
|
|
// The small icon size is already cached for the queue view.
|
|
//
|
|
if( hIcon = LoadImage( ghInst, MAKEINTRESOURCE(IDI_PRINTER), IMAGE_ICON, gcxSmIcon, gcySmIcon, 0 ) )
|
|
{
|
|
SendMessage( _hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIcon );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bHandle_WM_SIZE(
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
INT width = LOWORD( lParam );
|
|
INT height = HIWORD( lParam );
|
|
|
|
//
|
|
// Get the current window size.
|
|
//
|
|
RECT rect;
|
|
GetWindowRect(_hDlg, &rect);
|
|
|
|
//
|
|
// Calculate the deltas in the x and y positions that we need to move
|
|
// each of the child controls.
|
|
//
|
|
INT dx = (rect.right - rect.left) - _ptLastSize.x;
|
|
INT dy = (rect.bottom - rect.top) - _ptLastSize.y;
|
|
|
|
//
|
|
// Update the new size.
|
|
//
|
|
_ptLastSize.x = rect.right - rect.left;
|
|
_ptLastSize.y = rect.bottom - rect.top;
|
|
|
|
//
|
|
// Set the sizing grip to the correct location.
|
|
//
|
|
if( _hwndGrip )
|
|
{
|
|
SetWindowPos( _hwndGrip,
|
|
NULL,
|
|
width - _cxGrip,
|
|
height - _cyGrip,
|
|
_cxGrip,
|
|
_cyGrip,
|
|
SWP_NOZORDER | SWP_NOACTIVATE );
|
|
}
|
|
|
|
//
|
|
// Move the ok button.
|
|
//
|
|
GetWindowRect(GetDlgItem(_hDlg, IDOK), &rect);
|
|
|
|
MapWindowPoints(NULL, _hDlg, (LPPOINT)&rect, 2);
|
|
|
|
SetWindowPos(GetDlgItem(_hDlg, IDOK),
|
|
NULL,
|
|
rect.left+dx,
|
|
rect.top+dy,
|
|
0,
|
|
0,
|
|
SWP_NOZORDER|SWP_NOSIZE);
|
|
|
|
//
|
|
// Resize the edit control
|
|
//
|
|
GetWindowRect(GetDlgItem(_hDlg, IDC_RUNDLL_TEXT), &rect);
|
|
|
|
MapWindowPoints(NULL, _hDlg, (LPPOINT)&rect, 2);
|
|
|
|
SetWindowPos(GetDlgItem(_hDlg, IDC_RUNDLL_TEXT),
|
|
NULL,
|
|
0,
|
|
0,
|
|
(rect.right-rect.left)+dx,
|
|
(rect.bottom-rect.top)+dy,
|
|
SWP_NOZORDER|SWP_NOMOVE);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bHandle_WM_GETMINMAXINFO(
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
LPMINMAXINFO pmmi = (LPMINMAXINFO)lParam;
|
|
|
|
if( ( _ptMinTrack.x != 0 ) || ( _ptMinTrack.y != 0 ) )
|
|
{
|
|
pmmi->ptMinTrackSize = _ptMinTrack;
|
|
bRetval = FALSE;
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
BOOL
|
|
TRunDllDisplay::
|
|
bHandleMessage(
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL bStatus = TRUE;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
bSetUI();
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
bStatus = bHandle_WM_SIZE( wParam, lParam );
|
|
break;
|
|
|
|
case WM_GETMINMAXINFO:
|
|
bStatus = bHandle_WM_GETMINMAXINFO( wParam, lParam );
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch ( LOWORD( wParam ) )
|
|
{
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
EndDialog( _hDlg, LOWORD( wParam ) );
|
|
break;
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
bStatus = FALSE;
|
|
break;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Very simple file output class
|
|
|
|
********************************************************************/
|
|
|
|
TFile::
|
|
TFile(
|
|
IN LPCTSTR pszFileName,
|
|
IN BOOL bNoUnicodeByteMark
|
|
) : _strFileName( pszFileName ),
|
|
_hFile( INVALID_HANDLE_VALUE ),
|
|
_bValid( FALSE )
|
|
{
|
|
if( !_strFileName.bEmpty() )
|
|
{
|
|
_hFile = CreateFile( _strFileName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL );
|
|
|
|
if( _hFile != INVALID_HANDLE_VALUE )
|
|
{
|
|
_bValid = TRUE;
|
|
}
|
|
|
|
//
|
|
// If we are built for unicode then write the unicode byte mark.
|
|
//
|
|
#ifdef UNICODE
|
|
if( _bValid && !bNoUnicodeByteMark )
|
|
{
|
|
WORD wUnicodeByteMark = kUnicodePrefix;
|
|
_bValid = bWrite( sizeof( wUnicodeByteMark ), reinterpret_cast<LPBYTE>( &wUnicodeByteMark ) );
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
TFile::
|
|
~TFile(
|
|
VOID
|
|
)
|
|
{
|
|
if( _hFile != INVALID_HANDLE_VALUE )
|
|
{
|
|
CloseHandle( _hFile );
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
TFile::
|
|
bValid(
|
|
VOID
|
|
)
|
|
{
|
|
return _bValid;
|
|
}
|
|
|
|
BOOL
|
|
TFile::
|
|
bWrite(
|
|
IN TString &strString,
|
|
OUT UINT *pBytesWritten OPTIONAL
|
|
)
|
|
{
|
|
return bWrite( strString.uLen() * sizeof( TCHAR ),
|
|
reinterpret_cast<LPBYTE>( const_cast<LPTSTR>( static_cast<LPCTSTR>( strString ) ) ),
|
|
pBytesWritten );
|
|
}
|
|
|
|
BOOL
|
|
TFile::
|
|
bWrite(
|
|
IN UINT uSize,
|
|
IN LPBYTE pData,
|
|
OUT UINT *pBytesWritten OPTIONAL
|
|
)
|
|
{
|
|
DWORD dwWritten;
|
|
TStatusB bStatus;
|
|
|
|
bStatus DBGCHK = WriteFile(_hFile,
|
|
pData,
|
|
uSize,
|
|
&dwWritten,
|
|
NULL );
|
|
if( bStatus )
|
|
{
|
|
if( pBytesWritten )
|
|
{
|
|
*pBytesWritten = dwWritten;
|
|
}
|
|
|
|
bStatus DBGCHK = dwWritten == uSize ? TRUE : FALSE;
|
|
}
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
|