3254 lines
76 KiB
C++
3254 lines
76 KiB
C++
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1995 - 1999
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
Util.cxx
|
|
|
|
Abstract:
|
|
|
|
Misc util functions.
|
|
|
|
Author:
|
|
|
|
Albert Ting (AlbertT) 27-Jan-1995
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
#include <shgina.h>
|
|
#include "result.hxx"
|
|
#include "msgbox.hxx"
|
|
#include "spllibex.hxx"
|
|
#include "prndata.hxx"
|
|
|
|
//
|
|
// Global functions
|
|
//
|
|
|
|
static MSG_HLPMAP gMsgHelpTable [] =
|
|
{
|
|
{ ERROR_INVALID_PRINTER_NAME, IDS_ERR_WITH_HELP1, gszHelpTroubleShooterURL},
|
|
{ ERROR_KM_DRIVER_BLOCKED, IDS_COULDNOTCONNECTTOPRINTER_BLOCKED_HELP, gszHelpTroubleShooterURL},
|
|
{ 0, 0, 0},
|
|
};
|
|
|
|
enum
|
|
{
|
|
//
|
|
// Not mapped error code.
|
|
// Show up the text from the GetLastError()
|
|
//
|
|
IDS_NOT_MAPPED = (UINT )(-1)
|
|
};
|
|
|
|
#define MAKERESOURCEINT(psz) PTR2UINT(psz)
|
|
|
|
//
|
|
// This global error mapping table is proposed to filter out
|
|
// the errors that are showed up to the end user to a certain
|
|
// well known set, which we have a good explanation for. All the
|
|
// rest of the errors will be mapped to the generic error text.
|
|
// if the message mapping is IDS_NOT_MAPPED it means the text
|
|
// coming from the GetLastError/FormatMessage APIs is good enough
|
|
// so we are going to use it. Otherwise the mapping ID is a
|
|
// resource id of the remapped text.
|
|
//
|
|
static MSG_ERRMAP gGlobalErrorMapTable[] =
|
|
{
|
|
|
|
//
|
|
// Category 1 - Print Spooler Error Codes
|
|
//
|
|
ERROR_UNKNOWN_PRINT_MONITOR, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_DRIVER_IN_USE, IDS_NOT_MAPPED,
|
|
ERROR_SPOOL_FILE_NOT_FOUND, IDS_ERRMAP_SPOOL_FILE_NOT_FOUND,
|
|
ERROR_SPL_NO_STARTDOC, IDS_ERRMAP_SPL_NO_STARTDOC,
|
|
ERROR_SPL_NO_ADDJOB, IDS_ERRMAP_SPL_NO_STARTDOC,
|
|
ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED, IDS_NOT_MAPPED,
|
|
ERROR_PRINT_MONITOR_ALREADY_INSTALLED, IDS_NOT_MAPPED,
|
|
ERROR_INVALID_PRINT_MONITOR, IDS_NOT_MAPPED,
|
|
ERROR_PRINT_MONITOR_IN_USE, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_HAS_JOBS_QUEUED, IDS_NOT_MAPPED,
|
|
ERROR_SUCCESS_REBOOT_REQUIRED, IDS_NOT_MAPPED,
|
|
ERROR_SUCCESS_RESTART_REQUIRED, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_NOT_FOUND, IDS_NOT_MAPPED,
|
|
|
|
//
|
|
// Category 2 - Print Subsystem Related Error Codes
|
|
//
|
|
ERROR_OUT_OF_PAPER, IDS_NOT_MAPPED,
|
|
ERROR_PRINTQ_FULL, IDS_NOT_MAPPED,
|
|
ERROR_NO_SPOOL_SPACE, IDS_ERRMAP_NO_SPOOL_SPACE,
|
|
ERROR_PRINT_CANCELLED, IDS_NOT_MAPPED,
|
|
ERROR_REDIR_PAUSED, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_DRIVER_ALREADY_INSTALLED, IDS_NOT_MAPPED,
|
|
ERROR_UNKNOWN_PRINTER_DRIVER, IDS_ERROR_UNKNOWN_DRIVER,
|
|
ERROR_UNKNOWN_PRINTPROCESSOR, IDS_ERRMAP_UNKNOWN_PRINTPROCESSOR,
|
|
ERROR_INVALID_PRINTER_NAME, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_ALREADY_EXISTS, IDS_ERRMAP_PRINTER_ALREADY_EXISTS,
|
|
ERROR_INVALID_PRINTER_COMMAND, IDS_NOT_MAPPED,
|
|
ERROR_ALREADY_WAITING, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_DELETED, IDS_NOT_MAPPED,
|
|
ERROR_INVALID_PRINTER_STATE, IDS_NOT_MAPPED,
|
|
ERROR_BAD_DRIVER, IDS_NOT_MAPPED,
|
|
|
|
//
|
|
// Category 3 - Common Win32/RPC
|
|
//
|
|
RPC_S_SERVER_UNAVAILABLE, IDS_ERRMAP_RPC_S_SERVER_UNAVAILABLE,
|
|
RPC_S_INVALID_NET_ADDR, IDS_NOT_MAPPED,
|
|
ERROR_ACCESS_DENIED, IDS_NOT_MAPPED,
|
|
ERROR_DISK_FULL, IDS_ERRMAP_DISK_FULL,
|
|
ERROR_NOT_READY, IDS_NOT_MAPPED,
|
|
ERROR_DEVICE_NOT_AVAILABLE, IDS_NOT_MAPPED,
|
|
ERROR_WRITE_PROTECT, IDS_NOT_MAPPED,
|
|
ERROR_SHARING_VIOLATION, IDS_NOT_MAPPED,
|
|
ERROR_LOCK_VIOLATION, IDS_NOT_MAPPED,
|
|
ERROR_HANDLE_DISK_FULL, IDS_ERRMAP_DISK_FULL,
|
|
ERROR_NETWORK_BUSY, IDS_NOT_MAPPED,
|
|
ERROR_NETWORK_ACCESS_DENIED, IDS_ERRMAP_NETWORK_ACCESS_DENIED,
|
|
ERROR_NETNAME_DELETED, IDS_NOT_MAPPED,
|
|
ERROR_CANNOT_MAKE, IDS_NOT_MAPPED,
|
|
ERROR_NET_WRITE_FAULT, IDS_ERRMAP_NET_WRITE_FAULT,
|
|
ERROR_INVALID_PASSWORD, IDS_NOT_MAPPED,
|
|
ERROR_NOT_SUPPORTED, IDS_ERRMAP_NOT_SUPPORTED,
|
|
ERROR_OUTOFMEMORY, IDS_ERRMAP_OUTOFMEMORY,
|
|
ERROR_NOT_ENOUGH_MEMORY, IDS_ERRMAP_OUTOFMEMORY,
|
|
ERROR_CANCELLED, IDS_NOT_MAPPED,
|
|
ERROR_BAD_DRIVER, IDS_NOT_MAPPED,
|
|
ERROR_DRIVE_LOCKED, IDS_NOT_MAPPED,
|
|
ERROR_DEV_NOT_EXIST, IDS_NOT_MAPPED,
|
|
ERROR_OPEN_FAILED, IDS_NOT_MAPPED,
|
|
ERROR_DEVICE_DOOR_OPEN, IDS_NOT_MAPPED,
|
|
ERROR_BAD_DEVICE, IDS_NOT_MAPPED,
|
|
ERROR_INVALID_PROFILE, IDS_NOT_MAPPED,
|
|
ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE, IDS_NOT_MAPPED,
|
|
ERROR_PROFILE_NOT_FOUND, IDS_NOT_MAPPED,
|
|
ERROR_DEVICE_NOT_AVAILABLE, IDS_NOT_MAPPED,
|
|
ERROR_NO_MEDIA_IN_DRIVE, IDS_NOT_MAPPED,
|
|
ERROR_UNRECOGNIZED_MEDIA, IDS_NOT_MAPPED,
|
|
ERROR_MEDIA_NOT_AVAILABLE, IDS_NOT_MAPPED,
|
|
ERROR_UNKNOWN_PORT, IDS_NOT_MAPPED,
|
|
ERROR_FILE_CORRUPT, IDS_ERRMAP_FILE_CORRUPT,
|
|
ERROR_DISK_CORRUPT, IDS_NOT_MAPPED,
|
|
ERROR_ALREADY_EXISTS, IDS_NOT_MAPPED,
|
|
ERROR_KM_DRIVER_BLOCKED, IDS_NOT_MAPPED,
|
|
ERROR_PRINTER_DRIVER_BLOCKED, IDS_PRINTER_DRIVER_BLOCKED,
|
|
ERROR_REQ_NOT_ACCEP, IDS_NOT_MAPPED,
|
|
|
|
// end of the table
|
|
0, 0
|
|
|
|
}; // gGlobalErrorMapTable
|
|
|
|
inline static HRESULT CreateError()
|
|
{
|
|
DWORD dw = GetLastError();
|
|
if (ERROR_SUCCESS == dw) return E_FAIL;
|
|
return HRESULT_FROM_WIN32(dw);
|
|
}
|
|
|
|
LPTSTR
|
|
pszStrCat(
|
|
IN OUT LPTSTR pszDest,
|
|
OUT LPCTSTR pszSource, OPTIONAL
|
|
IN OUT UINT& cchDest
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies pszSource to pszDest iff there is enough space in cchDest.
|
|
|
|
Arguments:
|
|
|
|
pszDest - Destination buffer
|
|
|
|
pszSource - Source string, may be NULL (no action taken)
|
|
|
|
cchDest - char count size of pszDest, on return, space remaining
|
|
|
|
Return Value:
|
|
|
|
LPTSTR - pointer to remaining space
|
|
NULL - out of space.
|
|
|
|
--*/
|
|
|
|
{
|
|
if( !pszSource ){
|
|
return pszDest;
|
|
}
|
|
|
|
UINT cchSource = lstrlen( pszSource );
|
|
|
|
//
|
|
// Fail if dest can't hold source (equal case doesn't hold NULL term)
|
|
// OR dest string is NULL.
|
|
//
|
|
if( !pszDest || cchDest <= cchSource + 1 ){
|
|
return pszDest;
|
|
}
|
|
|
|
lstrcpy( pszDest, pszSource );
|
|
cchDest -= cchSource;
|
|
|
|
return pszDest + cchSource;
|
|
}
|
|
|
|
|
|
INT
|
|
iMessage(
|
|
IN HWND hwnd,
|
|
IN UINT idsTitle,
|
|
IN UINT idsMessage,
|
|
IN UINT uType,
|
|
IN DWORD dwLastError,
|
|
IN const PMSG_ERRMAP pMsgErrMap,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Formats error message.
|
|
|
|
Arguments:
|
|
|
|
See Internal_Message for details
|
|
|
|
Return Value:
|
|
|
|
returns value from MessageBox on sucess
|
|
and zero on failure
|
|
|
|
--*/
|
|
{
|
|
va_list valist;
|
|
va_start(valist, pMsgErrMap);
|
|
|
|
INT iRetval = 0;
|
|
if( FAILED(Internal_Message(&iRetval,
|
|
ghInst,
|
|
hwnd,
|
|
MAKEINTRESOURCE(idsTitle),
|
|
MAKEINTRESOURCE(idsMessage),
|
|
uType,
|
|
dwLastError,
|
|
pMsgErrMap,
|
|
NULL,
|
|
0,
|
|
valist)) )
|
|
{
|
|
// make sure we return zero in the failure case
|
|
iRetval = 0;
|
|
}
|
|
|
|
va_end(valist);
|
|
return iRetval;
|
|
}
|
|
|
|
INT
|
|
iMessage2(
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszTitle,
|
|
IN LPCTSTR pszMessage,
|
|
IN UINT uType,
|
|
IN DWORD dwLastError,
|
|
IN const PMSG_ERRMAP pMsgErrMap
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Formats error message.
|
|
|
|
Arguments:
|
|
|
|
See Internal_Message for details
|
|
pszTitle and pszMessage can be resource IDs i.e. MAKEINTRESOURCE(id)
|
|
|
|
Return Value:
|
|
|
|
returns value from MessageBox on sucess
|
|
and zero on failure
|
|
|
|
--*/
|
|
{
|
|
va_list valist;
|
|
va_start(valist, pMsgErrMap);
|
|
|
|
INT iRetval = 0;
|
|
if( FAILED(Internal_Message(&iRetval,
|
|
ghInst,
|
|
hwnd,
|
|
pszTitle,
|
|
pszMessage,
|
|
uType,
|
|
dwLastError,
|
|
pMsgErrMap,
|
|
NULL,
|
|
0,
|
|
valist)) )
|
|
{
|
|
// make sure we return zero in the failure case
|
|
iRetval = 0;
|
|
}
|
|
|
|
va_end(valist);
|
|
return iRetval;
|
|
}
|
|
|
|
INT
|
|
iMessageEx(
|
|
IN HWND hwnd,
|
|
IN UINT idsTitle,
|
|
IN UINT idsMessage,
|
|
IN UINT uType,
|
|
IN DWORD dwLastError,
|
|
IN const PMSG_ERRMAP pMsgErrMap,
|
|
IN UINT idMessage,
|
|
IN const PMSG_HLPMAP pHlpErrMap,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Formats error message.
|
|
|
|
Arguments:
|
|
|
|
See Internal_Message for details
|
|
|
|
Return Value:
|
|
|
|
returns value from MessageBox on sucess
|
|
and zero on failure
|
|
|
|
--*/
|
|
{
|
|
va_list valist;
|
|
va_start(valist, pHlpErrMap);
|
|
|
|
INT iRetval = 0;
|
|
if( FAILED(Internal_Message(&iRetval,
|
|
ghInst,
|
|
hwnd,
|
|
MAKEINTRESOURCE(idsTitle),
|
|
MAKEINTRESOURCE(idsMessage),
|
|
uType,
|
|
dwLastError,
|
|
pMsgErrMap,
|
|
idMessage,
|
|
pHlpErrMap,
|
|
valist)) )
|
|
{
|
|
// make sure we return zero in the failure case
|
|
iRetval = 0;
|
|
}
|
|
|
|
va_end(valist);
|
|
return iRetval;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
Internal_Message(
|
|
OUT INT *piResult,
|
|
IN HINSTANCE hModule,
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszTitle,
|
|
IN LPCTSTR pszMessage,
|
|
IN UINT uType,
|
|
IN DWORD dwLastError,
|
|
IN const PMSG_ERRMAP pMsgErrMap,
|
|
IN UINT idHlpMessage,
|
|
IN const PMSG_HLPMAP pHlpErrMap,
|
|
IN va_list valist
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Formats error message.
|
|
|
|
Arguments:
|
|
|
|
piResult - the message box return value (on success)
|
|
|
|
hModule - module where to load the resources from
|
|
|
|
hwnd - Parent windows. This only be NULL if there is a synchronous
|
|
error (an error that occurs immediately after a user action).
|
|
If it is NULL, then we set it to foreground.
|
|
|
|
pszTitle - Title of message box. Can be a resource ID i.e. MAKEINTRESOURCE(id)
|
|
|
|
pszMessage - Message text. May have inserts. Can be a resource ID too.
|
|
|
|
uType - Type of message box. See MessageBox api.
|
|
|
|
dwLastError - 0 indicates don't cat error string onto end of message text
|
|
kMsgGetLastError: Use GetLastError(). Other: format to LastError
|
|
text.
|
|
|
|
pMsgErrMap - Translate some error messages into friendlier text.
|
|
May be NULL.
|
|
|
|
idMessage - Help message ids to look for in the help message map.
|
|
|
|
pHlpErrMap - Pointer to error message map where look, If a match
|
|
is found in this map then the help button will be
|
|
displayed on the message box. May be MULL
|
|
|
|
... extra parameters to idsMessage follow.
|
|
|
|
Return Value:
|
|
|
|
S_OK on success and COM error on failure
|
|
|
|
--*/
|
|
|
|
{
|
|
TStatusB bStatus;
|
|
TString strMappedMessage;
|
|
TString strMsgTemplate;
|
|
TString strMessage;
|
|
TString strTitle;
|
|
INT iResult = 0;
|
|
BOOL bFormatNeeded = FALSE;
|
|
MSG_HLPMAP *pHelpMapEntry = NULL;
|
|
MSG_ERRMAP *pErrMapEntry = NULL;
|
|
UINT idsTitle = IDS_NOT_MAPPED;
|
|
UINT idsMessage = IDS_NOT_MAPPED;
|
|
HRESULT hr = S_OK;
|
|
|
|
if( NULL == hModule )
|
|
{
|
|
hModule = ghInst;
|
|
}
|
|
|
|
HINSTANCE hInstTitle = hModule,
|
|
hInstMessage = hModule;
|
|
|
|
if( NULL == pszTitle )
|
|
{
|
|
pszTitle = MAKEINTRESOURCE(IDS_PRINTERS_TITLE);
|
|
hInstTitle = ghInst;
|
|
}
|
|
|
|
if( NULL == pszMessage )
|
|
{
|
|
pszMessage = MAKEINTRESOURCE(IDS_ERR_GENERIC);
|
|
hInstMessage = ghInst;
|
|
}
|
|
|
|
// first load the title and format strings and
|
|
// then format the string with any following aguments.
|
|
|
|
if( SUCCEEDED(hr) && IS_INTRESOURCE(pszTitle) )
|
|
{
|
|
idsTitle = MAKERESOURCEINT(pszTitle);
|
|
bStatus DBGCHK = strTitle.bLoadString(hInstTitle, idsTitle);
|
|
pszTitle = strTitle;
|
|
|
|
if( !bStatus )
|
|
{
|
|
hr = CreateError();
|
|
}
|
|
}
|
|
|
|
if( SUCCEEDED(hr) && IS_INTRESOURCE(pszMessage) )
|
|
{
|
|
idsMessage = MAKERESOURCEINT(pszMessage);
|
|
bStatus DBGCHK = strMsgTemplate.bLoadString(hInstMessage, idsMessage);
|
|
pszMessage = strMsgTemplate;
|
|
|
|
if( !bStatus )
|
|
{
|
|
hr = CreateError();
|
|
}
|
|
}
|
|
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
bStatus DBGCHK = strMessage.bvFormat(pszMessage, valist);
|
|
|
|
if( !bStatus )
|
|
{
|
|
hr = CreateError();
|
|
}
|
|
}
|
|
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
// check to see if last error format is needed
|
|
switch( dwLastError )
|
|
{
|
|
case kMsgGetLastError:
|
|
|
|
//
|
|
// Get the last error.
|
|
//
|
|
dwLastError = GetLastError();
|
|
|
|
//
|
|
// If for some reason there wasn't an error code, don't
|
|
// append the error string.
|
|
//
|
|
bFormatNeeded = !!dwLastError;
|
|
break;
|
|
|
|
case kMsgNone:
|
|
|
|
//
|
|
// No format message needed.
|
|
//
|
|
bFormatNeeded = FALSE;
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Format needed, use provided error value.
|
|
//
|
|
bFormatNeeded = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( bFormatNeeded )
|
|
{
|
|
//
|
|
// If there was a help message map passed then look up the id in this
|
|
// help message map, note this call does not use the last error for finding a match
|
|
//
|
|
if( bLookupHelpMessageMap(pHlpErrMap, idHlpMessage, &pHelpMapEntry) )
|
|
{
|
|
//
|
|
// Extract the message string from the resource file.
|
|
//
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, pHelpMapEntry->uIdMessage);
|
|
|
|
//
|
|
// Indicate the message box should have the help button on it.
|
|
//
|
|
uType |= MB_HELP;
|
|
}
|
|
|
|
//
|
|
// If there was not a remapped message then lookup this error value
|
|
// to see if this message has help remapped to it.
|
|
//
|
|
else if( bLookupHelpMessageMap( gMsgHelpTable, dwLastError, &pHelpMapEntry ) )
|
|
{
|
|
//
|
|
// Extract the message string from the resource file.
|
|
//
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, pHelpMapEntry->uIdMessage);
|
|
|
|
//
|
|
// Indicate the message box should have the help button on it.
|
|
//
|
|
uType |= MB_HELP;
|
|
}
|
|
|
|
//
|
|
// Check if this last error has a remapped message in the provided message map.
|
|
//
|
|
else if( bLookupErrorMessageMap( pMsgErrMap, dwLastError, &pErrMapEntry ) )
|
|
{
|
|
//
|
|
// Extract the message string from the resource file.
|
|
//
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, pErrMapEntry->idsString);
|
|
}
|
|
|
|
//
|
|
// Check if this last error is a known error or the error code is pretty
|
|
// useless for the end users (like "Invalid Handle"), so we need to re-map
|
|
// the text to a generic error message.
|
|
//
|
|
else if( bLookupErrorMessageMap( gGlobalErrorMapTable, dwLastError, &pErrMapEntry ) )
|
|
{
|
|
if( CMsgBoxCounter::GetMsg() )
|
|
{
|
|
// we have a message ID set based on the context where command
|
|
// gets executed - use this message ID instead the defaults
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, CMsgBoxCounter::GetMsg());
|
|
}
|
|
else if( IDS_NOT_MAPPED == pErrMapEntry->idsString )
|
|
{
|
|
//
|
|
// The error text, which is coming from the GetLastError/FormatMessage
|
|
// APIs is good enough for this error, so we are going to use it. Just get
|
|
// the error string from the FormatMessage API.
|
|
//
|
|
TResult result(dwLastError);
|
|
if( VALID_OBJ(result) )
|
|
{
|
|
bStatus DBGCHK = result.bGetErrorString(strMappedMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This error message is re-mapped to a better text. - Just
|
|
// load the re-mapped message string from the resource file.
|
|
//
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, pErrMapEntry->idsString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( IDS_ERR_GENERIC != idsMessage )
|
|
{
|
|
//
|
|
// This error code is unknown or useless to be displayed
|
|
// to the end user. Just load the generic error text string
|
|
// in this case.
|
|
//
|
|
bStatus DBGCHK = strMappedMessage.bLoadString(ghInst, IDS_ERR_GENERIC);
|
|
}
|
|
}
|
|
|
|
if( !bStatus )
|
|
{
|
|
hr = CreateError();
|
|
}
|
|
|
|
if( SUCCEEDED(hr) && !strMappedMessage.bEmpty() )
|
|
{
|
|
//
|
|
// Tack on the mapped, help or error string, with a two space separator.
|
|
//
|
|
bStatus DBGCHK = strMessage.bCat(TEXT(" ")) &&
|
|
strMessage.bCat(strMappedMessage);
|
|
|
|
if( !bStatus )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if succeeded - show up the message box
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
if( FAILED(GetCurrentThreadLastPopup(&hwnd)) )
|
|
{
|
|
// if the parent is going to be NULL then push in foreground
|
|
uType |= MB_SETFOREGROUND;
|
|
}
|
|
|
|
// display the message box.
|
|
iResult = PrintUIMessageBox(hwnd, strMessage, pszTitle, uType, UtilHelpCallback, pHelpMapEntry);
|
|
|
|
// log this messsage into the message box counter
|
|
CMsgBoxCounter::LogMessage(uType);
|
|
}
|
|
}
|
|
|
|
if( SUCCEEDED(hr) && piResult )
|
|
{
|
|
*piResult = iResult;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
UtilHelpCallback(
|
|
IN HWND hwnd,
|
|
IN PVOID pVoid
|
|
)
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
UtilHelpCallback
|
|
|
|
Routine Description:
|
|
|
|
This routine is the called back that is called when a
|
|
message box is displayed with a help button and the user
|
|
clicks on the help button.
|
|
|
|
Arguments:
|
|
|
|
hwnd - handle to windows that recieved the WM_HELP message.
|
|
pVoid - pointer to the user data passsed in the call to
|
|
PrintUIMessageBox. The client can store any value
|
|
in this paramter.
|
|
|
|
Return Value:
|
|
|
|
TRUE callback was successful, FALSE some error occurred.
|
|
|
|
--*/
|
|
|
|
{
|
|
DBGMSG( DBG_TRACE, ( "UtilHelpCallback\n") );
|
|
|
|
//
|
|
// Get a usable pointer to the help map entry.
|
|
//
|
|
MSG_HLPMAP *pHelpMapEntry = reinterpret_cast<MSG_HLPMAP *>( pVoid );
|
|
|
|
|
|
if (pHelpMapEntry)
|
|
{
|
|
//
|
|
// Invoke troubleshooter for this topic
|
|
//
|
|
DWORD_PTR dwRet = (DWORD_PTR)ShellExecute(hwnd, gszOpen,
|
|
TEXT("helpctr.exe"),
|
|
pHelpMapEntry->pszHelpFile,
|
|
NULL,
|
|
SW_SHOWNORMAL);
|
|
return dwRet > 32;
|
|
}
|
|
else
|
|
{
|
|
DBGMSG( DBG_ERROR, ( "UtilHelpCallback (pVoid == NULL)\n") );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
vShowResourceError(
|
|
HWND hwnd
|
|
)
|
|
{
|
|
//
|
|
// Show up the generic error message here.
|
|
//
|
|
vShowUnexpectedError(hwnd, IDS_PRINTERS_TITLE);
|
|
}
|
|
|
|
VOID
|
|
vShowUnexpectedError(
|
|
HWND hwnd,
|
|
UINT idsTitle
|
|
)
|
|
{
|
|
iMessage( hwnd,
|
|
idsTitle,
|
|
IDS_ERR_GENERIC,
|
|
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
|
|
kMsgGetLastError,
|
|
NULL );
|
|
}
|
|
|
|
VOID
|
|
vPrinterSplitFullName(
|
|
IN LPTSTR pszScratch,
|
|
IN LPCTSTR pszFullName,
|
|
IN LPCTSTR *ppszServer,
|
|
IN LPCTSTR *ppszPrinter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Splits a fully qualified printer connection name into server and
|
|
printer name parts.
|
|
|
|
Arguments:
|
|
|
|
pszScratch - Scratch buffer used to store output strings. Must
|
|
be MAXNAMELENBUFFER in size.
|
|
|
|
pszFullName - Input name of a printer. If it is a printer
|
|
connection (\\server\printer), then we will split it. If
|
|
it is a true local printer (not a masq) then the server is
|
|
szNULL.
|
|
|
|
ppszServer - Receives pointer to the server string. If it is a
|
|
local printer, szNULL is returned.
|
|
|
|
ppszPrinter - Receives a pointer to the printer string. OPTIONAL
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
LPTSTR pszPrinter;
|
|
|
|
lstrcpyn(pszScratch, pszFullName, kPrinterBufMax);
|
|
|
|
if (pszFullName[0] != TEXT('\\') || pszFullName[1] != TEXT('\\'))
|
|
{
|
|
//
|
|
// Set *ppszServer to szNULL since it's the local machine.
|
|
//
|
|
*ppszServer = gszNULL;
|
|
pszPrinter = pszScratch;
|
|
}
|
|
else
|
|
{
|
|
*ppszServer = pszScratch;
|
|
pszPrinter = _tcschr(*ppszServer + 2, TEXT('\\'));
|
|
|
|
if (!pszPrinter)
|
|
{
|
|
//
|
|
// We've encountered a printer called "\\server"
|
|
// (only two backslashes in the string). We'll treat
|
|
// it as a local printer. We should never hit this,
|
|
// but the spooler doesn't enforce this. We won't
|
|
// format the string. Server is local, so set to szNULL.
|
|
//
|
|
pszPrinter = pszScratch;
|
|
*ppszServer = gszNULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We found the third backslash; null terminate our
|
|
// copy and set bRemote TRUE to format the string.
|
|
//
|
|
*pszPrinter++ = 0;
|
|
}
|
|
}
|
|
|
|
if (ppszPrinter)
|
|
{
|
|
*ppszPrinter = pszPrinter;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
bBuildFullPrinterName(
|
|
IN LPCTSTR pszServer,
|
|
IN LPCTSTR pszPrinterName,
|
|
IN TString &strFullName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Builds a fully qualified printer name from a server name
|
|
and a printer name.
|
|
|
|
Arguments:
|
|
|
|
pszServer - Pointer to server name, if this parameter is null
|
|
the machine name is used. If this parameter is non
|
|
null it is assumed it is a server name of the form
|
|
\\server including the leading wacks.
|
|
|
|
pszPrinterName - Pointer to printer name. This parameter must be a
|
|
a valid string.
|
|
|
|
strFullName - Reference where to return full printer name.
|
|
|
|
Return Value:
|
|
|
|
TRUE strFullName contains a full printer name, FALSE error.
|
|
|
|
--*/
|
|
{
|
|
SPLASSERT( pszPrinterName );
|
|
|
|
TStatusB bStatus;
|
|
bStatus DBGNOCHK = TRUE;
|
|
|
|
bStatus DBGCHK = strFullName.bUpdate( NULL );
|
|
|
|
//
|
|
// If the printer name is already fully qualified then do
|
|
// not prepend the server name.
|
|
//
|
|
if( bStatus && *(pszPrinterName+0) != TEXT('\\') && *(pszPrinterName+1) != TEXT('\\') )
|
|
{
|
|
//
|
|
// If the server name is null, get the current machine name.
|
|
//
|
|
if( !pszServer || !*pszServer )
|
|
{
|
|
bStatus DBGCHK = bGetMachineName( strFullName, FALSE );
|
|
}
|
|
else
|
|
{
|
|
bStatus DBGCHK = strFullName.bUpdate( pszServer );
|
|
}
|
|
|
|
//
|
|
// Append the wack separator.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
bStatus DBGCHK = strFullName.bCat( gszWack );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Append the printer name or copy the already fully qualified printer name.
|
|
//
|
|
if( bStatus )
|
|
{
|
|
bStatus DBGCHK = strFullName.bCat( pszPrinterName );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
bGetMachineName
|
|
|
|
Routine Description:
|
|
|
|
Get the machine name if the local machine.
|
|
|
|
Arguments:
|
|
|
|
String to return machine name.
|
|
Flag TRUE do not add leading slashes, FALSE add leading slashes.
|
|
|
|
Return Value:
|
|
|
|
TRUE machine name returned.
|
|
|
|
--*/
|
|
BOOL
|
|
bGetMachineName(
|
|
IN OUT TString &strMachineName,
|
|
IN BOOL bNoLeadingSlashes
|
|
)
|
|
{
|
|
TCHAR szBuffer[2 + MAX_COMPUTERNAME_LENGTH + 1];
|
|
DWORD dwBufferSize;
|
|
BOOL bStatus = FALSE;
|
|
DWORD dwSizeAdjust = 0;
|
|
|
|
//
|
|
// Prepend with the wack wack.
|
|
//
|
|
if( !bNoLeadingSlashes ){
|
|
szBuffer[0] = TEXT( '\\' );
|
|
szBuffer[1] = TEXT( '\\' );
|
|
dwSizeAdjust = 2;
|
|
}
|
|
|
|
//
|
|
// Get the computer name.
|
|
//
|
|
dwBufferSize = COUNTOF( szBuffer ) - dwSizeAdjust;
|
|
if( GetComputerName( szBuffer+dwSizeAdjust, &dwBufferSize ) ){
|
|
bStatus = strMachineName.bUpdate( szBuffer );
|
|
}
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
NewFriendlyName
|
|
|
|
Routine Description:
|
|
|
|
Create a new (and unique) friendly name
|
|
|
|
Arguments:
|
|
|
|
pszServerName - print server name
|
|
lpBaseName - base printer name
|
|
lpNewName - new printer name is base name is not unique
|
|
|
|
pwInstance - [in,out],
|
|
|
|
if NULL (this is by default) then:
|
|
[in] - assume instance equals to zero
|
|
[out] - <NA> (don't care)
|
|
|
|
if not NULL then:
|
|
[in] - instance to start from
|
|
[out] - instance choosen
|
|
|
|
Return Value:
|
|
|
|
TRUE if lpFriendlyName recevies new unique name, FALSE if not
|
|
|
|
--*/
|
|
BOOL
|
|
NewFriendlyName(
|
|
IN LPCTSTR pszServerName,
|
|
IN LPCTSTR lpBaseName,
|
|
IN LPTSTR lpNewName,
|
|
IN OUT WORD *pwInstance
|
|
)
|
|
{
|
|
TCHAR szTestName[kPrinterBufMax];
|
|
WORD wCount = 0;
|
|
DWORD cPrinterInfo2 = 0;
|
|
DWORD cbPrinterInfo2 = 0;
|
|
PRINTER_INFO_2 *pPrinterInfo2 = NULL;
|
|
BOOL bStatus = FALSE;
|
|
TStatusB bEnumStatus;
|
|
|
|
if( pwInstance ){
|
|
wCount = *pwInstance;
|
|
}
|
|
|
|
//
|
|
// Enumerate the current printers.
|
|
//
|
|
bEnumStatus DBGCHK = VDataRefresh::bEnumPrinters(
|
|
PRINTER_ENUM_NAME,
|
|
(LPTSTR)pszServerName,
|
|
2,
|
|
(PVOID *)&pPrinterInfo2,
|
|
&cbPrinterInfo2,
|
|
&cPrinterInfo2 );
|
|
//
|
|
// Failure enumerating printers.
|
|
//
|
|
if( !bEnumStatus ){
|
|
DBGMSG( DBG_WARN, ( "Error enumerating printers.\n" ) );
|
|
bStatus = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Set upper limit of 1000 tries, just to avoid hanging forever
|
|
//
|
|
bStatus = FALSE;
|
|
for( ; wCount < 1000; wCount++ ){
|
|
|
|
if( CreateUniqueName( szTestName, COUNTOF(szTestName), lpBaseName, wCount )){
|
|
|
|
LPCTSTR pszName;
|
|
BOOL bFound = FALSE;
|
|
|
|
for ( UINT i = 0; i < cPrinterInfo2; i++ ){
|
|
|
|
pszName = pPrinterInfo2[i].pPrinterName;
|
|
|
|
//
|
|
// Strip the server name if not the local machine.
|
|
//
|
|
if( pszServerName ){
|
|
|
|
if( pszName[0] == TEXT( '\\' ) &&
|
|
pszName[1] == TEXT( '\\' ) ){
|
|
|
|
pszName = _tcschr( &pszName[2], TEXT( '\\' ) );
|
|
|
|
if( !pszName ){
|
|
pszName = pPrinterInfo2[i].pPrinterName;
|
|
} else {
|
|
pszName += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If name matches indicate found and continue trying to
|
|
// create a unique name.
|
|
//
|
|
if( !lstrcmpi( szTestName, pszName ) ){
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Check if there is a printer share name that matches and
|
|
// if so continue trying to create a unique name.
|
|
//
|
|
if( pPrinterInfo2[i].pShareName &&
|
|
pPrinterInfo2[i].pShareName[0] &&
|
|
!lstrcmpi( szTestName, pPrinterInfo2[i].pShareName ) ){
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If a unique name was found and this was not the
|
|
// first time trough the loop copy the new unique name
|
|
// to the provided buffer.
|
|
//
|
|
if( bFound == FALSE ) {
|
|
if( wCount != 0 ){
|
|
lstrcpyn( lpNewName, szTestName, kPrinterBufMax );
|
|
bStatus = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Insure we clean up.
|
|
//
|
|
Cleanup:
|
|
|
|
if( pPrinterInfo2 ){
|
|
|
|
DBGMSG( DBG_TRACE, ( "Releaseing printer info 2 memory.\n" ) );
|
|
FreeMem( pPrinterInfo2 );
|
|
}
|
|
|
|
if( pwInstance ){
|
|
*pwInstance = wCount;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
CreateUniqueName
|
|
|
|
Routine Description:
|
|
|
|
Create a unique friendly name for this printer. If wInstance
|
|
is 0, just copy the name over. Otherwise, play some games
|
|
with truncating the name so it will fit.
|
|
|
|
Arguments:
|
|
|
|
lpDest - destination buffer
|
|
cchMaxChars - max number of chars in lpDest
|
|
lpBaseName - base printer name
|
|
wInstance - the instance number
|
|
|
|
Return Value:
|
|
|
|
TRUE if we created a name, FALSE if something went wrong
|
|
|
|
Note:
|
|
|
|
This code is from msprint2.dll! we should match their naming scheme.
|
|
|
|
--*/
|
|
BOOL
|
|
CreateUniqueName(
|
|
IN LPTSTR lpDest,
|
|
IN UINT cchMaxChars,
|
|
IN LPCTSTR lpBaseName,
|
|
IN WORD wInstance
|
|
)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
if (wInstance)
|
|
{
|
|
// We want to provide a fully localizable way to create a
|
|
// unique friendly name for each instance. We start with
|
|
// a single string from the resource, and call wsprintf
|
|
// twice, getting something like this:
|
|
//
|
|
// "%%s (Copy %u)" From resource
|
|
// "%s (Copy 2)" After first wsprintf
|
|
// "Foobar Laser (Copy 2)" After second wsprintf
|
|
//
|
|
// We can't make a single wsprintf call, since it has no
|
|
// concept of limiting the string size. We truncate the
|
|
// model name (in a DBCS-aware fashion) to the appropriate
|
|
// size, so the whole string fits in kPrinterBufMax bytes. This
|
|
// may cause some name truncation, but only in cases where
|
|
// the model name is extremely long.
|
|
|
|
CAutoPtrArray<TCHAR> spszFormat1 = new TCHAR[kPrinterBufMax];
|
|
CAutoPtrArray<TCHAR> spszFormat2 = new TCHAR[kPrinterBufMax];
|
|
|
|
if (spszFormat1 && spszFormat2)
|
|
{
|
|
if (LoadString(ghInst, IDS_PRTPROP_UNIQUE_FORMAT, spszFormat1, kPrinterBufMax))
|
|
{
|
|
// wFormatLength is length of format string before inserting
|
|
// the model name. Subtract 2 to remove the "%s", and add
|
|
// 1 to compensate for the terminating NULL, which is
|
|
// counted in the total buffer length, but not the string length
|
|
|
|
wnsprintf(spszFormat2, kPrinterBufMax, spszFormat1, wInstance);
|
|
wnsprintf(lpDest, cchMaxChars, spszFormat2, lpBaseName);
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// some of the allocations failed
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if wInstance is zero then just copy lpBaseName to lpDest
|
|
lstrcpyn(lpDest, lpBaseName, cchMaxChars);
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
bSplitPath
|
|
|
|
Routine Description:
|
|
|
|
splits a file path in to the path and file component.
|
|
|
|
Arguments:
|
|
|
|
pszScratch - pointer to sratch buffer, must be minimum max path.
|
|
ppszFile - pointer where to return file pointer, may be null.
|
|
ppszPath - pointer where to return path pointer, may be null.
|
|
ppszExt - pointer where to return ext pointer, may be null.
|
|
pszFull - pointer to fully qualified path\file
|
|
|
|
Return Value:
|
|
|
|
TRUE file and path part split.
|
|
|
|
--*/
|
|
BOOL
|
|
bSplitPath(
|
|
IN LPTSTR pszScratch,
|
|
IN LPCTSTR *ppszFile,
|
|
IN LPCTSTR *ppszPath,
|
|
IN LPCTSTR *ppszExt,
|
|
IN LPCTSTR pszFull
|
|
)
|
|
{
|
|
SPLASSERT( pszScratch );
|
|
SPLASSERT( pszFull );
|
|
|
|
BOOL bStatus = FALSE;
|
|
|
|
if( ppszFile )
|
|
*ppszFile = NULL;
|
|
|
|
if( ppszPath )
|
|
*ppszPath = NULL;
|
|
|
|
if( ppszExt )
|
|
*ppszExt = NULL;
|
|
|
|
if( pszScratch && pszFull )
|
|
{
|
|
_tcscpy( pszScratch, pszFull );
|
|
|
|
//
|
|
// Full is of the form d:\test
|
|
//
|
|
LPTSTR pszFile = _tcsrchr( pszScratch, TEXT('\\') );
|
|
|
|
//
|
|
// Full is of the form d:test
|
|
//
|
|
if( !pszFile )
|
|
{
|
|
pszFile = _tcsrchr( pszScratch, TEXT(':') );
|
|
}
|
|
|
|
if( pszFile )
|
|
{
|
|
*pszFile++ = NULL;
|
|
|
|
//
|
|
// Locate the file extension.
|
|
//
|
|
if( ppszExt )
|
|
{
|
|
LPTSTR pszExt = _tcsrchr( pszFile, TEXT('.') );
|
|
|
|
if( pszExt )
|
|
{
|
|
*ppszExt = pszExt + 1;
|
|
}
|
|
}
|
|
|
|
if( ppszFile )
|
|
*ppszFile = pszFile;
|
|
|
|
if( ppszPath )
|
|
*ppszPath = pszScratch;
|
|
}
|
|
|
|
//
|
|
// Success.
|
|
//
|
|
bStatus = TRUE;
|
|
}
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
bCopyMultizString
|
|
|
|
Routine Description:
|
|
|
|
Copies a multiz string.
|
|
|
|
Arguments:
|
|
|
|
ppszCopy - pointer where to return multiz string copy.
|
|
pszMultizString - pointer to multiz string.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE copy multiz string failed, out of memory etc.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
bCopyMultizString(
|
|
IN LPTSTR *ppszMultizCopy,
|
|
IN LPCTSTR pszMultizString
|
|
)
|
|
{
|
|
SPLASSERT( ppszMultizCopy );
|
|
|
|
BOOL bStatus = TRUE;
|
|
|
|
if( pszMultizString )
|
|
{
|
|
//
|
|
// Calculate the length of the multiz string.
|
|
//
|
|
for( LPCTSTR psz = pszMultizString; psz && *psz; psz += _tcslen( psz ) + 1 );
|
|
|
|
UINT uSize = (UINT)(psz - pszMultizString) + 1;
|
|
|
|
if( uSize )
|
|
{
|
|
//
|
|
// Alocate the new multiz string.
|
|
//
|
|
*ppszMultizCopy = new TCHAR[uSize];
|
|
|
|
if( *ppszMultizCopy )
|
|
{
|
|
CopyMemory( *ppszMultizCopy, pszMultizString, uSize * sizeof( TCHAR ) );
|
|
}
|
|
else
|
|
{
|
|
bStatus = FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ppszMultizCopy = NULL;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name:
|
|
|
|
vStripTrailWhiteSpace
|
|
|
|
Routine Description:
|
|
|
|
Strips trailing white space in a single forward scan.
|
|
|
|
Arguments:
|
|
|
|
pszString - Pointer to a null terminated string.
|
|
|
|
Return Value:
|
|
|
|
Nothing.
|
|
|
|
Notes:
|
|
|
|
The string is modified in place.
|
|
|
|
--*/
|
|
VOID
|
|
vStripTrailWhiteSpace(
|
|
IN LPTSTR pszString
|
|
)
|
|
{
|
|
for( LPTSTR pBlank = NULL; pszString && *pszString; ++pszString )
|
|
{
|
|
if( *pszString == TEXT(' ') )
|
|
pBlank = pBlank == NULL ? pszString : pBlank;
|
|
else
|
|
pBlank = NULL;
|
|
}
|
|
if( pBlank )
|
|
{
|
|
*pBlank = 0;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bTrimString
|
|
|
|
Routine Description:
|
|
|
|
Trim the string pszTrimMe of any leading or trailing
|
|
characters that are in pszTrimChars.
|
|
|
|
Return Value:
|
|
|
|
TRUE if anything was stripped
|
|
|
|
--*/
|
|
BOOL
|
|
bTrimString(
|
|
IN OUT LPTSTR pszTrimMe,
|
|
IN LPCTSTR pszTrimChars
|
|
)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
LPTSTR psz;
|
|
LPTSTR pszStartMeat;
|
|
LPTSTR pszMark = NULL;
|
|
|
|
SPLASSERT(pszTrimMe);
|
|
SPLASSERT(pszTrimChars);
|
|
|
|
if (pszTrimMe)
|
|
{
|
|
//
|
|
// Trim leading characters.
|
|
//
|
|
psz = pszTrimMe;
|
|
|
|
while (*psz && _tcschr(pszTrimChars, *psz))
|
|
psz++;
|
|
|
|
pszStartMeat = psz;
|
|
|
|
//
|
|
// Trim trailing characters.
|
|
//
|
|
while (*psz)
|
|
{
|
|
if (_tcschr(pszTrimChars, *psz))
|
|
{
|
|
if (!pszMark)
|
|
{
|
|
pszMark = psz;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pszMark = NULL;
|
|
}
|
|
|
|
psz++;
|
|
}
|
|
|
|
//
|
|
// Any trailing characters to clip?
|
|
//
|
|
if (pszMark)
|
|
{
|
|
*pszMark = '\0';
|
|
bRet = TRUE;
|
|
}
|
|
|
|
//
|
|
// Relocate stripped string.
|
|
//
|
|
if (pszStartMeat > pszTrimMe)
|
|
{
|
|
//
|
|
// (+ 1) for null terminator.
|
|
//
|
|
MoveMemory(pszTrimMe, pszStartMeat, (_tcslen(pszStartMeat) + 1) * sizeof(TCHAR));
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
SPLASSERT(pszStartMeat == pszTrimMe);
|
|
}
|
|
|
|
SPLASSERT(pszTrimMe);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bIsRemote
|
|
|
|
Routine Description:
|
|
|
|
Determines if the specified name is a
|
|
remote machine or local machine name.
|
|
|
|
Arguments:
|
|
|
|
pszString - Pointer to string which contains the machine name.
|
|
|
|
Return Value:
|
|
|
|
TRUE machine name is a remote machine name, FALSE local machine name.
|
|
|
|
--*/
|
|
BOOL
|
|
bIsRemote(
|
|
IN LPCTSTR pszName
|
|
)
|
|
{
|
|
BOOL bRetval = FALSE;
|
|
|
|
//
|
|
// Null pointer or null string is assumed to be
|
|
// the local machine. (Spooler's definition)
|
|
//
|
|
if( !pszName || !*pszName )
|
|
{
|
|
return bRetval;
|
|
}
|
|
|
|
//
|
|
// Get the local machines name.
|
|
//
|
|
TString strLocalName;
|
|
if( !bGetMachineName( strLocalName, TRUE ) )
|
|
{
|
|
DBGMSG( DBG_ERROR, ("bIsRemote::bGetMachineName Failed!") );
|
|
return bRetval;
|
|
}
|
|
|
|
//
|
|
// If the provided name has leading '\\' then compare with
|
|
// '\\' else point to just after the '\\' and compare.
|
|
//
|
|
if( *(pszName+0) == TEXT('\\') && *(pszName+1) == TEXT('\\') )
|
|
{
|
|
pszName += 2;
|
|
}
|
|
|
|
//
|
|
// If the machine names are different then the provided
|
|
// name is assumed to be a remote machine.
|
|
//
|
|
if( _tcsicmp( pszName, strLocalName ) )
|
|
{
|
|
bRetval = TRUE;
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
BOOL
|
|
bLookupErrorMessageMap(
|
|
IN const PMSG_ERRMAP pMsgErrMap,
|
|
IN DWORD dwLastError,
|
|
IN OUT MSG_ERRMAP **ppErrMapEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bLookupErrorMessageMap
|
|
|
|
Routine Description:
|
|
|
|
Scanns the error message map for a matching
|
|
last error. If the message is found in the map
|
|
the string is returned in the specified string
|
|
mapped message object.
|
|
|
|
Arguments:
|
|
|
|
pMsgErrMap - pointer to error message map
|
|
dwLastError - last error to look for in error message map
|
|
ppErrMapEntry - pointer to error map entry where match was found
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
|
|
//
|
|
// If there is a message map, use it.
|
|
//
|
|
if( pMsgErrMap )
|
|
{
|
|
for( UINT i = 0; pMsgErrMap[i].dwError; i++ )
|
|
{
|
|
//
|
|
// If we have a matching error, then return a pointer to this entry.
|
|
//
|
|
if( dwLastError == pMsgErrMap[i].dwError )
|
|
{
|
|
*ppErrMapEntry = &pMsgErrMap[i];
|
|
bStatus = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
bLookupHelpMessageMap(
|
|
IN const PMSG_HLPMAP pMsgHlpMap,
|
|
IN DWORD dwLastError,
|
|
IN OUT MSG_HLPMAP **ppHelpMapEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
bLookupHelpMessageMap
|
|
|
|
Routine Description:
|
|
|
|
Scans the error message map for a matching
|
|
last error. If the message is found in the map
|
|
the string is returned in the specified string
|
|
object.
|
|
|
|
Arguments:
|
|
|
|
pMsgHlpMap - pointer to help error message map
|
|
dwLastError - last error to look for in error message map
|
|
ppHelpMapEntry - pointer to help map entry where match was found
|
|
|
|
Return Value:
|
|
|
|
TRUE success match found, FALSE error occurred.
|
|
|
|
--*/
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
|
|
//
|
|
// If there is a message map, use it.
|
|
//
|
|
if( pMsgHlpMap )
|
|
{
|
|
for( UINT i = 0; pMsgHlpMap[i].dwError; i++ )
|
|
{
|
|
//
|
|
// If we have a matching error, then return a pointer to this entry.
|
|
//
|
|
if( dwLastError == pMsgHlpMap[i].dwError )
|
|
{
|
|
*ppHelpMapEntry = &pMsgHlpMap[i];
|
|
bStatus = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
bGoodLastError(
|
|
IN DWORD dwLastError
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Checks if this is a good last error - i.e. has
|
|
a good real message associated with it.
|
|
|
|
Arguments:
|
|
|
|
dwLastError - the last error to check for
|
|
|
|
Return Value:
|
|
|
|
TRUE if good, FALSE if not good
|
|
|
|
--*/
|
|
{
|
|
MSG_ERRMAP *pErrMapEntry = NULL;
|
|
return bLookupErrorMessageMap( gGlobalErrorMapTable, dwLastError, &pErrMapEntry );
|
|
}
|
|
|
|
BOOL
|
|
StringA2W(
|
|
IN OUT LPWSTR *ppResult,
|
|
IN LPCSTR pString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert an ansi string to a wide string returning
|
|
a pointer to a newly allocated string.
|
|
|
|
Arguments:
|
|
|
|
ppResult - pointer to where to return pointer to new wide string.
|
|
pString - pointer to ansi string.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
{
|
|
SPLASSERT( ppResult || pString );
|
|
|
|
BOOL bReturn = FALSE;
|
|
|
|
INT iLen = ( strlen( pString ) + 1 ) * sizeof( WCHAR );
|
|
|
|
*ppResult = reinterpret_cast<LPWSTR>( AllocMem( iLen ) );
|
|
|
|
if( *ppResult )
|
|
{
|
|
if( MultiByteToWideChar( CP_ACP, 0, pString, -1, *ppResult, iLen ) )
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
FreeMem( *ppResult );
|
|
*ppResult = NULL;
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
StringW2A(
|
|
IN OUT LPSTR *ppResult,
|
|
IN LPCWSTR pString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert a wide string to and ansi string returning
|
|
a pointer to a newly allocated string.
|
|
|
|
Arguments:
|
|
|
|
ppResult - pointer to where to return pointer to new ansi string.
|
|
pString - pointer to wide string.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
{
|
|
SPLASSERT( ppResult || pString );
|
|
|
|
BOOL bReturn = FALSE;
|
|
|
|
INT iLen = ( wcslen( pString ) + 1 ) * sizeof( CHAR );
|
|
|
|
*ppResult = reinterpret_cast<LPSTR>( AllocMem( iLen ) );
|
|
|
|
if( *ppResult )
|
|
{
|
|
if( WideCharToMultiByte( CP_ACP, 0, pString, -1, *ppResult, iLen, NULL, NULL ) )
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
FreeMem( *ppResult );
|
|
*ppResult = NULL;
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Centers a dialog relative to hwndContext
|
|
|
|
Arguments:
|
|
|
|
hwndToCenter - window handle of dialog to center
|
|
hwndContext - window handle of window to center with respect to
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
VOID
|
|
CenterDialog(
|
|
IN HWND hwndToCenter,
|
|
IN HWND hwndContext
|
|
)
|
|
{
|
|
POINT point;
|
|
RECT rcContext, rcWindow;
|
|
LONG x, y, w, h;
|
|
LONG sx = GetSystemMetrics(SM_CXSCREEN);
|
|
LONG sy = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
point.x = point.y = 0;
|
|
if (hwndContext)
|
|
{
|
|
ClientToScreen(hwndContext, &point);
|
|
GetClientRect (hwndContext, &rcContext);
|
|
}
|
|
else
|
|
{
|
|
rcContext.top = rcContext.left = 0;
|
|
rcContext.right = sx;
|
|
rcContext.bottom = sy;
|
|
}
|
|
GetWindowRect (hwndToCenter, &rcWindow);
|
|
|
|
w = rcWindow.right - rcWindow.left + 1;
|
|
h = rcWindow.bottom - rcWindow.top + 1;
|
|
x = point.x + ((rcContext.right - rcContext.left + 1 - w) / 2);
|
|
y = point.y + ((rcContext.bottom - rcContext.top + 1 - h) / 2);
|
|
|
|
if (x + w > sx)
|
|
{
|
|
x = sx - w;
|
|
}
|
|
else if (x < 0)
|
|
{
|
|
x = 0;
|
|
}
|
|
|
|
if (y + h > sy)
|
|
{
|
|
y = sy - h;
|
|
}
|
|
else if (y < 0)
|
|
{
|
|
y = 0;
|
|
}
|
|
|
|
MoveWindow(hwndToCenter, x, y, w, h, FALSE);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name:
|
|
|
|
GetDomainName
|
|
|
|
Routine Description:
|
|
|
|
Returns the DNS domain name where the current computer is located.
|
|
|
|
Arguments:
|
|
|
|
pstrDomainName - pointer to a string refrence where to return the domain name.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
GetDomainName(
|
|
OUT TString &strDomainName
|
|
)
|
|
{
|
|
static TString *g_pstrDomainName = NULL;
|
|
|
|
TStatusB bStatus;
|
|
|
|
bStatus DBGNOCHK = FALSE;
|
|
|
|
CCSLock::Locker CSL( *gpCritSec );
|
|
|
|
if( !g_pstrDomainName )
|
|
{
|
|
g_pstrDomainName = new TString;
|
|
|
|
if( VALID_PTR( g_pstrDomainName ) )
|
|
{
|
|
typedef DWORD (WINAPI *pfDsRoleGetPrimaryDomainInformation)( LPCTSTR, DSROLE_PRIMARY_DOMAIN_INFO_LEVEL, PBYTE * );
|
|
typedef VOID (WINAPI *pfDsRoleFreeMemory)( PVOID );
|
|
|
|
TLibrary Lib( gszNetApiLibrary );
|
|
|
|
//
|
|
// Check if the netapi library was loaded.
|
|
//
|
|
bStatus DBGNOCHK = VALID_OBJ( Lib );
|
|
|
|
if (bStatus)
|
|
{
|
|
pfDsRoleGetPrimaryDomainInformation pfGetPrimrayDomainInformation = reinterpret_cast<pfDsRoleGetPrimaryDomainInformation>( Lib.pfnGetProc( "DsRoleGetPrimaryDomainInformation" ) );
|
|
pfDsRoleFreeMemory pfFreeMemory = reinterpret_cast<pfDsRoleFreeMemory>( Lib.pfnGetProc( "DsRoleFreeMemory" ) );
|
|
|
|
if( pfGetPrimrayDomainInformation && pfFreeMemory )
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pDsRole = NULL;
|
|
|
|
dwStatus = pfGetPrimrayDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE *)&pDsRole);
|
|
|
|
if (dwStatus == ERROR_SUCCESS)
|
|
{
|
|
bStatus DBGCHK = g_pstrDomainName->bUpdate( pDsRole->DomainNameDns );
|
|
|
|
if( bStatus )
|
|
{
|
|
bStatus DBGCHK = strDomainName.bUpdate( *g_pstrDomainName );
|
|
}
|
|
}
|
|
|
|
if (pDsRole)
|
|
{
|
|
pfFreeMemory((PVOID) pDsRole);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStatus DBGCHK = strDomainName.bUpdate( *g_pstrDomainName );
|
|
}
|
|
|
|
DBGMSG( DBG_TRACE, ( "GetDomainName " TSTR "\n", DBGSTR((LPCTSTR)*g_pstrDomainName) ) );
|
|
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Name:
|
|
|
|
AreWeOnADomain
|
|
|
|
Routine Description:
|
|
|
|
Returns whether we are on a domain.
|
|
|
|
Arguments:
|
|
|
|
pbOnDomain - If TRUE, we are on a domain.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
BOOL
|
|
AreWeOnADomain(
|
|
OUT BOOL *pbOnDomain
|
|
)
|
|
{
|
|
typedef DWORD (WINAPI *pfDsRoleGetPrimaryDomainInformation)( LPCTSTR, DSROLE_PRIMARY_DOMAIN_INFO_LEVEL, PBYTE * );
|
|
typedef VOID (WINAPI *pfDsRoleFreeMemory)( PVOID );
|
|
|
|
BOOL bOnDomain = FALSE;
|
|
TStatusB bStatus;
|
|
|
|
TLibrary Lib(gszNetApiLibrary);
|
|
|
|
//
|
|
// Check if the netapi library was loaded.
|
|
//
|
|
bStatus DBGNOCHK = VALID_OBJ( Lib );
|
|
|
|
if (bStatus)
|
|
{
|
|
pfDsRoleGetPrimaryDomainInformation pfGetPrimrayDomainInformation = NULL;
|
|
pfDsRoleFreeMemory pfFreeMemory = NULL;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pDsRole = NULL;
|
|
|
|
pfGetPrimrayDomainInformation = reinterpret_cast<pfDsRoleGetPrimaryDomainInformation>(Lib.pfnGetProc("DsRoleGetPrimaryDomainInformation"));
|
|
pfFreeMemory = reinterpret_cast<pfDsRoleFreeMemory>(Lib.pfnGetProc("DsRoleFreeMemory"));
|
|
|
|
bStatus DBGCHK = pfGetPrimrayDomainInformation && pfFreeMemory;
|
|
|
|
if (bStatus)
|
|
{
|
|
DWORD dwStatus = pfGetPrimrayDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE *)&pDsRole);
|
|
|
|
if (dwStatus)
|
|
{
|
|
SetLastError(dwStatus);
|
|
bStatus DBGCHK = FALSE;
|
|
}
|
|
}
|
|
|
|
if (bStatus)
|
|
{
|
|
bOnDomain = pDsRole->MachineRole == DsRole_RoleMemberWorkstation ||
|
|
pDsRole->MachineRole == DsRole_RoleMemberServer ||
|
|
pDsRole->MachineRole == DsRole_RoleBackupDomainController ||
|
|
pDsRole->MachineRole == DsRole_RolePrimaryDomainController;
|
|
}
|
|
|
|
if (pDsRole)
|
|
{
|
|
pfFreeMemory(pDsRole);
|
|
}
|
|
}
|
|
|
|
*pbOnDomain = bOnDomain;
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
ConstructPrinterFriendlyName(
|
|
IN LPCTSTR pszFullPrinter,
|
|
IN OUT LPTSTR pszPrinterBuffer,
|
|
IN OUT UINT *pcchSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns printer name formatted like "printer on server." if the provided
|
|
printer name is fully qualified, else it just returns the passed in
|
|
printer name.
|
|
|
|
Arguments:
|
|
|
|
pszPrinter - pointer to printer name, if fully qualified the
|
|
name is formatted to printer on server, if not a
|
|
fully qualified name then the printer name is not
|
|
altered.
|
|
pszPrinterBuffer - Output buffer to receive the printer name. May be
|
|
NULL of the caller want only the size of the buffer
|
|
returned.
|
|
pcchSize - pointer to a variable that specifies the size
|
|
in characters of pszPrinterBuffer includeing the
|
|
null terminator.
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE error occurred.
|
|
|
|
--*/
|
|
{
|
|
LPCTSTR pszServer;
|
|
LPCTSTR pszPrinter;
|
|
LPCTSTR pszFriendly;
|
|
TString strPrinter;
|
|
TStatusB bStatus;
|
|
TCHAR szScratch[kPrinterBufMax];
|
|
|
|
//
|
|
// Validate the printer name and buffer pointer size.
|
|
//
|
|
if( pszFullPrinter && pcchSize )
|
|
{
|
|
//
|
|
// Split the printer name into its components.
|
|
//
|
|
vPrinterSplitFullName( szScratch, pszFullPrinter, &pszServer, &pszPrinter );
|
|
|
|
//
|
|
// If this printer has a server name component then construct a
|
|
// 'printer on server' friendly name.
|
|
//
|
|
if( pszServer && *pszServer )
|
|
{
|
|
//
|
|
// Strip the leading slashes.
|
|
//
|
|
if( *(pszServer+0) == _T('\\') && *(pszServer+1) == _T('\\') )
|
|
{
|
|
pszServer = pszServer + 2;
|
|
}
|
|
|
|
bStatus DBGCHK = bConstructMessageString( ghInst, strPrinter, IDS_DSPTEMPLATE_WITH_ON, pszPrinter, pszServer );
|
|
|
|
if( bStatus )
|
|
{
|
|
pszFriendly = strPrinter;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Just use the current printer name if it is not fully qualified.
|
|
//
|
|
bStatus DBGNOCHK = TRUE;
|
|
pszFriendly = pszFullPrinter;
|
|
}
|
|
|
|
if( bStatus )
|
|
{
|
|
UINT uFriendlySize = _tcslen( pszFriendly );
|
|
|
|
//
|
|
// If a buffer was provided then check if it is large enough to
|
|
// hold the friendly name. If it is large enough then copy the
|
|
// friendly name into it.
|
|
//
|
|
if( pszPrinterBuffer && ( *pcchSize > uFriendlySize ) )
|
|
{
|
|
_tcscpy( pszPrinterBuffer, pszFriendly );
|
|
}
|
|
else
|
|
{
|
|
bStatus DBGNOCHK = FALSE;
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
}
|
|
|
|
//
|
|
// Return the friendly name size.
|
|
//
|
|
*pcchSize = uFriendlySize + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStatus DBGNOCHK = FALSE;
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
WINAPIV
|
|
bConstructMessageString(
|
|
IN HINSTANCE hInst,
|
|
IN TString &strString,
|
|
IN INT iResId,
|
|
IN ...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine formats the specified string using a format string.
|
|
The format string is extracted from the resouce file using the
|
|
passed in resouce id. The format is of the form required by
|
|
FormatMessage API. See FormatMessage for more details.
|
|
|
|
Arguments:
|
|
|
|
hInst - Instance handle where resource is loaded.
|
|
strString - Place to return resultant formatted string,
|
|
iResId - Format string resource id.
|
|
.. - Variable number of arguments
|
|
|
|
Return Value:
|
|
|
|
TRUE success, FALSE if error occurred.
|
|
|
|
--*/
|
|
{
|
|
LPTSTR pszRet = NULL;
|
|
DWORD dwBytes = 0;
|
|
TString strRes;
|
|
TStatusB bStatus;
|
|
va_list pArgs;
|
|
|
|
//
|
|
// Load the resource string.
|
|
//
|
|
bStatus DBGCHK = strRes.bLoadString( hInst, iResId );
|
|
|
|
if( bStatus )
|
|
{
|
|
va_start( pArgs, iResId );
|
|
|
|
//
|
|
// Format the message.
|
|
//
|
|
dwBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
|
|
strRes,
|
|
0,
|
|
0,
|
|
(LPTSTR)&pszRet,
|
|
0,
|
|
&pArgs );
|
|
va_end( pArgs );
|
|
|
|
//
|
|
// If the number of bytes is non zero the API formatted the
|
|
// string.
|
|
//
|
|
if( dwBytes )
|
|
{
|
|
//
|
|
// Update the return string object.
|
|
//
|
|
bStatus DBGCHK = strString.bUpdate( pszRet );
|
|
|
|
//
|
|
// Release the formated string.
|
|
//
|
|
if( pszRet )
|
|
{
|
|
LocalFree(pszRet);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStatus DBGNOCHK = FALSE;
|
|
}
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
bIsLocalPrinterNameValid(
|
|
IN LPCTSTR pszPrinter
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine checks if the specified local printer name contains
|
|
any illegal characters. Note the spooler also inforces the illegal
|
|
characters but doing the check in the UI code is more efficent and
|
|
nicer to the user, rather than having to call add printer with a
|
|
printer name that is invalid.
|
|
|
|
Arguments:
|
|
|
|
pszPrinter - pointer to local printer name
|
|
|
|
Return Value:
|
|
|
|
TRUE printer name is valid, FALSE name contains illegal character
|
|
|
|
--*/
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
|
|
//
|
|
// Check if the name has any illegal characters.
|
|
//
|
|
for( LPCTSTR p = pszPrinter; p && *p; p++ )
|
|
{
|
|
if( *p == TEXT( ',' ) || *p == TEXT( '!' ) || *p == TEXT( '\\' ) )
|
|
{
|
|
bRetval = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
BOOL
|
|
CheckRestrictions(
|
|
IN HWND hwnd,
|
|
IN RESTRICTIONS rest
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Verify the resrtictions of the explorer policies
|
|
|
|
Arguments:
|
|
|
|
hwnd - Handle to the parent window
|
|
rest - Restriction to check.
|
|
|
|
Return Value:
|
|
|
|
TRUE - Restriction apply
|
|
FALSE - Not restrcited
|
|
|
|
--*/
|
|
{
|
|
if (SHRestricted(rest))
|
|
{
|
|
iMessage( hwnd,
|
|
IDS_RESTRICTIONSTITLE,
|
|
IDS_RESTRICTIONS,
|
|
MB_OK|MB_ICONSTOP,
|
|
kMsgNone,
|
|
NULL );
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
VOID
|
|
vAdjustHeaderColumns(
|
|
IN HWND hwndLV,
|
|
IN UINT uColumnsCount,
|
|
IN UINT uPercentages[]
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adjusts the columns to a certan percentages
|
|
in a list view
|
|
|
|
Arguments:
|
|
|
|
hwndLV - Handle to a list view control
|
|
uColumnsCount - Number of columns
|
|
uPercentages - The percentage of the total width
|
|
each column will take. 100 == SUM(uPercentages)
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Calculate the header column width.
|
|
//
|
|
RECT rc;
|
|
DWORD Interval = 20; // why not
|
|
|
|
if( GetClientRect( hwndLV, &rc ))
|
|
{
|
|
Interval = rc.right;
|
|
}
|
|
|
|
for( UINT iCol = 0; iCol < uColumnsCount; ++iCol )
|
|
{
|
|
ListView_SetColumnWidth( hwndLV, iCol, (Interval * uPercentages[iCol]) / 100 );
|
|
}
|
|
}
|
|
|
|
VOID
|
|
LoadPrinterIcons(
|
|
IN LPCTSTR pszPrinterName,
|
|
OUT HICON *phLargeIcon,
|
|
OUT HICON *phSmallIcon
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a printer icon with the requested size.
|
|
|
|
Arguments:
|
|
|
|
IN pszPrinterName - the printer name of the printer we want icon for
|
|
OUT phLargeIcon - where to put the large icon
|
|
OUT phSmallIcon - where to put the small icon
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
// invoke shell to do the right thing
|
|
Printer_LoadIcons(pszPrinterName, phLargeIcon, phSmallIcon);
|
|
}
|
|
|
|
BOOL
|
|
CommandConfirmationPurge(
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszPrinterName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dispalys confirmation message box for the purge command.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
TRUE user wants to execute command, FALSE cancel.
|
|
|
|
--*/
|
|
{
|
|
TCHAR szText[kStrMax+kPrinterBufMax] = {0};
|
|
UINT nSize = COUNTOF( szText );
|
|
|
|
//
|
|
// Build the printer status string.
|
|
//
|
|
ConstructPrinterFriendlyName(pszPrinterName, szText, &nSize);
|
|
|
|
return iMessage( hwnd,
|
|
IDS_PRINTERS_TITLE,
|
|
IDS_PRINTER_SUREPURGE,
|
|
MB_YESNO|MB_ICONQUESTION,
|
|
kMsgNone,
|
|
NULL,
|
|
szText ) == IDYES;
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Functions specific for the RTL (right-to-left) locales.
|
|
For more information about how this function works
|
|
contact SamerA.
|
|
|
|
********************************************************************/
|
|
|
|
BOOL
|
|
IsRTLLocale(
|
|
LCID iLCID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check if a particular locale is RTL (right-to-left)
|
|
locale
|
|
|
|
Arguments:
|
|
|
|
iLCID - Locale to check
|
|
|
|
Return Value:
|
|
|
|
TRUE - The locale is RTL locale
|
|
FALSE - Oterwise
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Length of font signature string
|
|
//
|
|
#define MAX_FONTSIGNATURE 16
|
|
|
|
WORD wLCIDFontSignature[MAX_FONTSIGNATURE];
|
|
BOOL bRet = FALSE;
|
|
|
|
//
|
|
// Verify that this is an RTL (BiDi) locale. Call GetLocaleInfo with
|
|
// LOCALE_FONTSIGNATURE which always gives back 16 WORDs.
|
|
//
|
|
if( GetLocaleInfo( iLCID,
|
|
LOCALE_FONTSIGNATURE,
|
|
(LPTSTR )&wLCIDFontSignature,
|
|
(sizeof(wLCIDFontSignature)/sizeof(wLCIDFontSignature[0]))))
|
|
{
|
|
//
|
|
// Verify the bits show a BiDi UI locale.
|
|
//
|
|
if( wLCIDFontSignature[7] & 0x0800 )
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
DWORD
|
|
dwDateFormatFlags(
|
|
HWND hWnd
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Build appropriate flags for GetDateFormat(...) API
|
|
depending on the current locale. Check if it is an
|
|
RTL locale.
|
|
|
|
Arguments:
|
|
|
|
hWnd - Window where the text will be drawn
|
|
|
|
Return Value:
|
|
|
|
The appropriate flags to be passed to
|
|
GetDateFormat(...)
|
|
|
|
--*/
|
|
{
|
|
DWORD dwFlags = 0;
|
|
|
|
//
|
|
// Check if the default locale is RTL locale
|
|
//
|
|
if( IsRTLLocale( GetUserDefaultLCID( ) ) )
|
|
{
|
|
//
|
|
// Check if this is a RTL (right-to-left) mirrored window
|
|
// or normal LTR window
|
|
//
|
|
if( GetWindowLong( hWnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL )
|
|
{
|
|
dwFlags |= DATE_RTLREADING;
|
|
}
|
|
else
|
|
{
|
|
dwFlags |= DATE_LTRREADING;
|
|
}
|
|
}
|
|
|
|
return dwFlags;
|
|
}
|
|
|
|
BOOL
|
|
bMatchTemplate(
|
|
IN LPCTSTR pszTemplate,
|
|
IN LPCTSTR pszText
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Simple template matching routine
|
|
|
|
Arguments:
|
|
|
|
pszTemplate - pointer to a simple template string
|
|
pszText - pointer to a text to match against the template
|
|
|
|
Return Value:
|
|
|
|
TRUE matched, FALSE not matched
|
|
|
|
--*/
|
|
{
|
|
int iLen = lstrlen(pszTemplate);
|
|
if( iLen != lstrlen(pszText) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
TString strText, strTemplate;
|
|
if( strText.bUpdate(pszText) &&
|
|
strTemplate.bUpdate(pszTemplate) )
|
|
{
|
|
// convert to uppercase prior the matching
|
|
strText.vToUpper();
|
|
strTemplate.vToUpper();
|
|
|
|
for( int i = 0; i < iLen; i++ )
|
|
{
|
|
if( TEXT('?') == strTemplate[i] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( strTemplate[i] != strText[i] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// failed to allocate the strings
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
bIsFaxPort(
|
|
IN LPCTSTR pszName,
|
|
IN LPCTSTR pszMonitor
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determins if this port is a fax port. A fax
|
|
port is a port managed by the fax port monitor.
|
|
|
|
Arguments:
|
|
|
|
pszName - pointer to port name.
|
|
pszMonitor - pointer to port monitor.
|
|
|
|
Return Value:
|
|
|
|
TRUE port is a fax port, FALSE port is not a fax port.
|
|
|
|
--*/
|
|
{
|
|
// the monitor name can be null on downlevel servers.
|
|
return ((pszName && 0 == lstrcmp(pszName, FAX_MONITOR_PORT_NAME)) ||
|
|
(pszMonitor && 0 == lstrcmp(pszMonitor, FAX_MONITOR_NAME)));
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
shows up an appropriate error message based on the last error code
|
|
(if spcified) this function is exported from printui to shell, so
|
|
shell error messages can be consistent with us.
|
|
|
|
Arguments:
|
|
|
|
piResult - the result from MessageBox
|
|
hModule - module who contains the test resources
|
|
hwnd - parent window
|
|
pszTitle - msg title (uID or text)
|
|
pszMessage - msg itself or msg context (uID or text)
|
|
uType - msg type
|
|
iLastError - the last error (-1 means don't append the last error text)
|
|
|
|
Return Value:
|
|
|
|
S_OK on success or COM error otherwise
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
ShowErrorMessageSC(
|
|
OUT INT *piResult,
|
|
IN HINSTANCE hModule,
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszTitle,
|
|
IN LPCTSTR pszMessage,
|
|
IN UINT uType,
|
|
IN DWORD dwCode
|
|
)
|
|
{
|
|
return Internal_Message(piResult, hModule, hwnd, pszTitle, pszMessage,
|
|
uType, dwCode, NULL, NULL, 0, NULL);
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
shows up an appropriate error message based on the last error code
|
|
(if spcified) this function is exported from printui to shell, so
|
|
shell error messages can be consistent with us.
|
|
|
|
Arguments:
|
|
|
|
piResult - the result from MessageBox
|
|
hModule - module who contains the test resources
|
|
hwnd - parent window
|
|
pszTitle - msg title (uID or text)
|
|
pszMessage - msg itself or msg context (uID or text)
|
|
uType - msg type
|
|
iLastError - the last error (-1 means don't append the last error text)
|
|
|
|
Return Value:
|
|
|
|
S_OK on success or COM error otherwise
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
ShowErrorMessageHR(
|
|
OUT INT *piResult,
|
|
IN HINSTANCE hModule,
|
|
IN HWND hwnd,
|
|
IN LPCTSTR pszTitle,
|
|
IN LPCTSTR pszMessage,
|
|
IN UINT uType,
|
|
IN HRESULT hr
|
|
)
|
|
{
|
|
return Internal_Message(piResult, hModule, hwnd, pszTitle, pszMessage,
|
|
uType, SCODE_CODE(GetScode(hr)), NULL, NULL, 0, NULL);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
abbreviates text by adding ellipses if text is longer than cchMaxChars
|
|
|
|
Arguments:
|
|
|
|
pszText - [in] text to abbreviate
|
|
cchMaxChars - [in] max characters of the output (abbreviated) text
|
|
pstrAbbreviatedText - [out] the abbreviated text
|
|
|
|
Return Value:
|
|
|
|
S_OK on success or COM error otherwise
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
AbbreviateText(
|
|
IN LPCTSTR pszText,
|
|
IN UINT cchMaxChars,
|
|
OUT TString *pstrAbbreviatedText
|
|
)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
if( pszText && cchMaxChars && pstrAbbreviatedText )
|
|
{
|
|
TStatusB bStatus;
|
|
if( lstrlen(pszText) <= cchMaxChars )
|
|
{
|
|
// the text fits in the buffer, just copy it
|
|
bStatus DBGCHK = pstrAbbreviatedText->bUpdate(pszText);
|
|
hr = bStatus ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
// the text doesn't fit in the buffer, add ellipses
|
|
TString strEllipses;
|
|
bStatus DBGCHK = strEllipses.bLoadString(ghInst, IDS_TEXT_ELLIPSES);
|
|
|
|
if( bStatus && strEllipses.uLen() < cchMaxChars )
|
|
{
|
|
TCHAR szBuffer[255];
|
|
lstrcpyn(szBuffer, pszText, min(cchMaxChars - strEllipses.uLen(), ARRAYSIZE(szBuffer)));
|
|
|
|
bStatus DBGCHK = pstrAbbreviatedText->bFormat(TEXT("%s%s"), szBuffer, static_cast<LPCTSTR>(strEllipses));
|
|
hr = bStatus ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
// generate proper HRESULT from Win32 last error
|
|
hr = CreateHRFromWin32();
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
MoveWindowWrap
|
|
|
|
Routine Description:
|
|
|
|
Move specific window by given offset.
|
|
|
|
Arguments:
|
|
|
|
hWnd -- window handle
|
|
deltaX -- horizonal offset
|
|
deltaY -- vertical offset
|
|
|
|
Return Value:
|
|
|
|
Return value by MoveWindow().
|
|
|
|
--*/
|
|
BOOL
|
|
MoveWindowWrap(
|
|
HWND hwnd,
|
|
int deltaX,
|
|
int deltaY
|
|
)
|
|
{
|
|
RECT rect;
|
|
|
|
GetWindowRect(hwnd, &rect);
|
|
MapWindowPoints(HWND_DESKTOP, GetParent(hwnd), (LPPOINT)&rect, 2);
|
|
return MoveWindow(hwnd, rect.left + deltaX, rect.top + deltaY,
|
|
rect.right - rect.left, rect.bottom - rect.top, TRUE);
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsColorPrinter
|
|
|
|
Routine Description:
|
|
|
|
Checks if a printer supports color
|
|
|
|
Arguments:
|
|
|
|
pszPrinter - printer name
|
|
pbColor - pointer to bool
|
|
|
|
Return Value:
|
|
|
|
S_OK - the function succeded and pbColor can be used
|
|
anything else - the function failed
|
|
|
|
--*/
|
|
HRESULT
|
|
IsColorPrinter(
|
|
IN LPCWSTR pszPrinter,
|
|
IN OUT LPBOOL pbColor
|
|
)
|
|
{
|
|
TStatusH hStatus;
|
|
|
|
hStatus DBGNOCHK = E_INVALIDARG;
|
|
|
|
if (pszPrinter && pbColor)
|
|
{
|
|
hStatus DBGNOCHK = E_FAIL;
|
|
|
|
//
|
|
// Create the printer data access class.
|
|
//
|
|
TPrinterDataAccess Data(pszPrinter,
|
|
TPrinterDataAccess::kResourcePrinter,
|
|
TPrinterDataAccess::kAccessRead);
|
|
|
|
//
|
|
// Relax the return type checking, BOOL are not REG_DWORD but REG_BINARY
|
|
//
|
|
Data.RelaxReturnTypeCheck(TRUE);
|
|
|
|
//
|
|
// Initialize the data class.
|
|
//
|
|
if (Data.Init())
|
|
{
|
|
hStatus DBGCHK = Data.Get(SPLDS_DRIVER_KEY, SPLDS_PRINT_COLOR, *pbColor);
|
|
}
|
|
}
|
|
|
|
return hStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsGuestAccessMode
|
|
|
|
Routine Description:
|
|
|
|
Checks if guest access mode is enabled for the local machine.
|
|
|
|
Arguments:
|
|
|
|
pbGuestAccessMode - [out] TRUE if guest access mode is enabled
|
|
for the local machine and FALSE otherwise.
|
|
|
|
Return Value:
|
|
|
|
S_OK if succeded and OLE error otherwise.
|
|
|
|
History:
|
|
|
|
Lazar Ivanov (LazarI), Mar-19-2001 - created.
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
IsGuestAccessMode(
|
|
OUT BOOL *pbGuestAccessMode
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (pbGuestAccessMode)
|
|
{
|
|
if (GetCurrentPlatform() == kPlatform_IA64)
|
|
{
|
|
//
|
|
// Guest mode is always off for IA64 machine since we don't have
|
|
// homenetworking wizard for IA64 machine
|
|
//
|
|
*pbGuestAccessMode = FALSE;
|
|
}
|
|
else if (IsOS(OS_PERSONAL))
|
|
{
|
|
//
|
|
// Guest mode is always on for Personal.
|
|
//
|
|
*pbGuestAccessMode = TRUE;
|
|
}
|
|
else if (IsOS(OS_PROFESSIONAL) && !IsOS(OS_DOMAINMEMBER))
|
|
{
|
|
//
|
|
// Professional, not in a domain. Check the "ForceGuest" value
|
|
// in the registry.
|
|
//
|
|
LONG errCode;
|
|
CAutoHandleHKEY shKey;
|
|
DWORD dwValue = 0;
|
|
DWORD dwValueSize = sizeof(dwValue);
|
|
|
|
errCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\CurrentControlSet\\Control\\LSA"),
|
|
0, KEY_QUERY_VALUE, &shKey);
|
|
|
|
if (errCode == ERROR_SUCCESS)
|
|
{
|
|
errCode = RegQueryValueEx(shKey, TEXT("ForceGuest"), NULL, NULL,
|
|
(LPBYTE)&dwValue, &dwValueSize);
|
|
|
|
if (errCode == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Declare success here.
|
|
//
|
|
*pbGuestAccessMode = (1 == dwValue);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(errCode);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(errCode);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Not in guest mode.
|
|
//
|
|
*pbGuestAccessMode = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsGuestEnabledForNetworkAccess
|
|
|
|
Routine Description:
|
|
|
|
Checks if the Guest account is enabled for network access.
|
|
|
|
Arguments:
|
|
|
|
pbGuestEnabledForNetworkAccess - [out] TRUE if the Guest
|
|
account is enabled for network access and FALSE otherwise.
|
|
|
|
Return Value:
|
|
|
|
S_OK if succeded and OLE error otherwise.
|
|
|
|
History:
|
|
|
|
Lazar Ivanov (LazarI), Mar-19-2001 - created.
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
IsGuestEnabledForNetworkAccess(
|
|
OUT BOOL *pbGuestEnabledForNetworkAccess
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (pbGuestEnabledForNetworkAccess)
|
|
{
|
|
CRefPtrCOM<ILocalMachine> spLM;
|
|
VARIANT_BOOL vbEnabled = VARIANT_FALSE;
|
|
|
|
//
|
|
// Get pointer to ILocalMachine to check ILM_GUEST_NETWORK_LOGON
|
|
//
|
|
if (SUCCEEDED(hr = CoCreateInstance(CLSID_ShellLocalMachine, NULL,
|
|
CLSCTX_INPROC_SERVER, IID_ILocalMachine, (void**)&spLM)) &&
|
|
SUCCEEDED(hr = spLM->get_isGuestEnabled(ILM_GUEST_NETWORK_LOGON, &vbEnabled)))
|
|
{
|
|
//
|
|
// Declare success here.
|
|
//
|
|
*pbGuestEnabledForNetworkAccess = (VARIANT_TRUE == vbEnabled);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsSharingEnabled
|
|
|
|
Routine Description:
|
|
|
|
Checks if sharing is enabled or we should launch the home
|
|
networking wizard to enable sharing before allowing the
|
|
users to share out printers.
|
|
|
|
Arguments:
|
|
|
|
pbSharingEnabled - [out] TRUE if sharing is enabled and
|
|
FALSE otherwise (in which case we should launch HNW)
|
|
|
|
Return Value:
|
|
|
|
S_OK if succeded and OLE error otherwise.
|
|
|
|
History:
|
|
|
|
Lazar Ivanov (LazarI), Mar-19-2001 - created.
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
IsSharingEnabled(
|
|
OUT BOOL *pbSharingEnabled
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (pbSharingEnabled)
|
|
{
|
|
BOOL bGuestAccessMode = FALSE;
|
|
BOOL bGuestEnabledForNetworkAccess = FALSE;
|
|
|
|
//
|
|
// First get the values of bGuestAccessMode & bGuestEnabledForNetworkAccess
|
|
//
|
|
if (SUCCEEDED(hr = IsGuestAccessMode(&bGuestAccessMode)) &&
|
|
SUCCEEDED(hr = IsGuestEnabledForNetworkAccess(&bGuestEnabledForNetworkAccess)))
|
|
{
|
|
//
|
|
// Sharing is enabled *only* if not in guest mode OR the guest account is
|
|
// enabled for network access.
|
|
//
|
|
*pbSharingEnabled = (!bGuestAccessMode || bGuestEnabledForNetworkAccess);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
LaunchHomeNetworkingWizard
|
|
|
|
Routine Description:
|
|
|
|
Launches the home networking wizard
|
|
|
|
Arguments:
|
|
|
|
hwnd - [in] window handle to show the wizard modally against
|
|
pbRebootRequired - [out] TRUE if the user made a change which
|
|
requires to reboot the system.
|
|
|
|
Return Value:
|
|
|
|
S_OK if succeded and OLE error otherwise.
|
|
|
|
History:
|
|
|
|
Lazar Ivanov (LazarI), Mar-19-2001 - created.
|
|
|
|
--*/
|
|
|
|
HRESULT
|
|
LaunchHomeNetworkingWizard(
|
|
IN HWND hwnd,
|
|
OUT BOOL *pbRebootRequired
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (hwnd && pbRebootRequired)
|
|
{
|
|
CRefPtrCOM<IHomeNetworkWizard> spHNW;
|
|
|
|
//
|
|
// Get pointer to IHomeNetworkWizard, get the top level owner of hwnd
|
|
// and then show the wizard.
|
|
//
|
|
if (SUCCEEDED(hr = CoCreateInstance(CLSID_HomeNetworkWizard, NULL,
|
|
CLSCTX_INPROC_SERVER, IID_IHomeNetworkWizard, (void**)&spHNW)) &&
|
|
SUCCEEDED(hr = GetCurrentThreadLastPopup(&hwnd)) &&
|
|
SUCCEEDED(hr = spHNW->ShowWizard(hwnd, pbRebootRequired)))
|
|
{
|
|
//
|
|
// Declare success here.
|
|
//
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsRedirectedPort
|
|
|
|
Routine Description:
|
|
|
|
Determines if the specified port name is a redirected port.
|
|
|
|
Arguments:
|
|
|
|
pszPortName - Port name.
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT value.
|
|
|
|
--*/
|
|
HRESULT
|
|
IsRedirectedPort(
|
|
IN LPCTSTR pszPortName,
|
|
OUT BOOL *pbIsRedirected
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!pszPortName || lstrlen(pszPortName) < 2)
|
|
{
|
|
*pbIsRedirected = FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pbIsRedirected = (*(pszPortName+0) == TEXT('\\')) && (*(pszPortName+1) == TEXT('\\'));
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
DisplayMessageFromOtherResourceDll
|
|
|
|
Routine Description:
|
|
|
|
This displays a message where the message comes from another resource DLL, the
|
|
title comes from printui.
|
|
|
|
Arguments:
|
|
|
|
hwnd - Parent window for this window.
|
|
idsTitle - The res id of the title to display
|
|
pszMessageDll - The message DLL to load and display.
|
|
idsMessage - The res id of the message
|
|
uType - The type of message box to display.
|
|
... - Arguments formatted by idsMessage
|
|
|
|
Return Value:
|
|
|
|
returns value from MessageBox on sucess
|
|
and zero on failure
|
|
|
|
--*/
|
|
INT
|
|
DisplayMessageFromOtherResourceDll(
|
|
IN HWND hwnd,
|
|
IN UINT idsTitle,
|
|
IN PCWSTR pszMessageDll,
|
|
IN UINT idsMessage,
|
|
IN UINT uType,
|
|
...
|
|
)
|
|
{
|
|
HMODULE hMessage = NULL;
|
|
TString strTitle;
|
|
INT iRet = TRUE;
|
|
|
|
if (pszMessageDll)
|
|
{
|
|
iRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
|
|
iRet = FALSE;
|
|
}
|
|
|
|
|
|
if (iRet)
|
|
{
|
|
iRet = (hMessage = LoadLibraryEx(pszMessageDll, NULL, LOAD_LIBRARY_AS_DATAFILE)) != NULL;
|
|
}
|
|
|
|
if (iRet)
|
|
{
|
|
iRet = strTitle.bLoadString(ghInst, idsTitle);
|
|
}
|
|
|
|
if (iRet)
|
|
{
|
|
va_list valist;
|
|
va_start(valist, uType);
|
|
|
|
if(FAILED(Internal_Message(&iRet,
|
|
hMessage,
|
|
hwnd,
|
|
strTitle,
|
|
MAKEINTRESOURCE(idsMessage),
|
|
uType,
|
|
ERROR_SUCCESS,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
valist)) )
|
|
{
|
|
// make sure we return zero in the failure case
|
|
iRet = 0;
|
|
}
|
|
|
|
va_end(valist);
|
|
}
|
|
|
|
|
|
if (hMessage)
|
|
{
|
|
FreeLibrary(hMessage);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|