HRESULT __stdcall IOemUI::QueryInterface(const IID& iid, void** ppv)
{
VERBOSE(DLLTEXT("IOemUI:QueryInterface entry.\r\n\r\n"));
if (iid == IID_IUnknown)
{
*ppv = static_cast<IUnknown*>(this);
VERBOSE(DLLTEXT("IOemUI:Return pointer to IUnknown.\r\n\r\n"));
}
else if (iid == IID_IPrintOemUI)
{
*ppv = static_cast<IPrintOemUI*>(this) ;
VERBOSE(DLLTEXT("IOemUI:Return pointer to IPrintOemUI.\r\n"));
}
else
{
#if DBG
TCHAR szOutput[80] = {0};
StringFromGUID2(iid, szOutput, COUNTOF(szOutput)); // can not fail!
VERBOSE(DLLTEXT("IOemUI::QueryInterface %s not supported.\r\n"), szOutput);
#endif
*ppv = NULL ;
return E_NOINTERFACE ;
}
reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
return S_OK ;
}
////////////////////////////////////////////////////////////////////////////////
//
// OptItems call back for OEM device or document property UI.
//
LONG APIENTRY OEMUICallBack(PCPSUICBPARAM pCallbackParam, POEMCUIPPARAM pOEMUIParam)
{
LONG lReturn = CPSUICB_ACTION_NONE;
POEMDEV pOEMDev = (POEMDEV) pOEMUIParam->pOEMDM;
VERBOSE(DLLTEXT("OEMUICallBack() entry.\r\n"));
switch(pCallbackParam->Reason)
{
case CPSUICB_REASON_APPLYNOW:
// Store OptItems state in DEVMODE.
pOEMDev->bEnabled = !pOEMUIParam->pOEMOptItems[0].Sel;
if(FAILED(StringCbCopyW(pOEMDev->szWaterMark, sizeof(pOEMDev->szWaterMark), (LPWSTR)pOEMUIParam->pOEMOptItems[1].pSel)))
{
ERR(DLLTEXT("OEMUICallBack() failed to copy water mark text\r\n"));
}
pOEMDev->dwFontSize = FontIndexToSize(pOEMUIParam->pOEMOptItems[2].Sel);
pOEMDev->dfRotate = (DOUBLE) pOEMUIParam->pOEMOptItems[3].Sel;
pOEMDev->crTextColor = IndexToTextColor(pOEMUIParam->pOEMOptItems[4].Sel);
break;
default:
break;
}
return lReturn;
}
////////////////////////////////////////////////////////////////////////////////////
//
// Retrieves pointer to a String resource.
//
static PTSTR GetStringResource(HANDLE hHeap, HMODULE hModule, UINT uResource)
{
int nResult;
DWORD dwSize = MAX_PATH;
PTSTR pszString = NULL;
VERBOSE(DLLTEXT("GetStringResource() entered.\r\n"));
// Allocate buffer for string resource from heap; let the driver clean it up.
pszString = (PTSTR) HeapAlloc(hHeap, HEAP_ZERO_MEMORY, dwSize * sizeof(TCHAR));
if(NULL != pszString)
{
PTSTR pTemp;
// Load string resource; resize after loading so as not to waste memory.
nResult = LoadString(hModule, uResource, pszString, dwSize);
pTemp = (PTSTR) HeapReAlloc(hHeap, HEAP_ZERO_MEMORY, pszString, (nResult + 1) * sizeof(TCHAR));
if(NULL != pTemp)
{
pszString = pTemp;
}
}
else
{
ERR(DLLTEXT("GetStringResource() failed to allocate string buffer!\r\n"));
}
return pszString;
}
//+---------------------------------------------------------------------------
//
// Member:
// COemUI2::QueryInterface
//
// Synopsis:
// Standard COM IUnknown implementation.
//
//
//----------------------------------------------------------------------------
HRESULT __stdcall
COemUI2::QueryInterface(
CONST IID& iid,
_COM_Outptr_ VOID** ppv
)
{
VERBOSE(DLLTEXT("COemUI2::QueryInterface entry."));
if (iid == IID_IUnknown)
{
*ppv = static_cast<IUnknown*>(this);
VERBOSE(DLLTEXT("COemUI2::QueryInterface - Return pointer to IUnknown.\r\n"));
}
else if (iid == IID_IPrintOemUI2)
{
*ppv = static_cast<IPrintOemUI2*>(this);
VERBOSE(DLLTEXT("COemUI2::QueryInterface - Return pointer to IPrintOemUI.\r\n"));
}
else
{
#if DBG
TCHAR szOutput[80] = {0};
StringFromGUID2(iid, szOutput, _countof(szOutput)); // can not fail!
VERBOSE(DLLTEXT("COemUI2::QueryInterface %s not supported.\r\n"), szOutput);
#endif
*ppv = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
return S_OK;
}
///////////////////////////////////////////////////////////
//
// DLL entry point
//
BOOL WINAPI DllMain(HINSTANCE hInst, WORD wReason, LPVOID lpReserved)
{
UNREFERENCED_PARAMETER(lpReserved);
switch(wReason)
{
case DLL_PROCESS_ATTACH:
VERBOSE(DLLTEXT("Process attach.\r\n"));
ghInstance = hInst;
break;
case DLL_THREAD_ATTACH:
VERBOSE(DLLTEXT("Thread attach.\r\n"));
break;
case DLL_PROCESS_DETACH:
VERBOSE(DLLTEXT("Process detach.\r\n"));
break;
case DLL_THREAD_DETACH:
VERBOSE(DLLTEXT("Thread detach.\r\n"));
break;
}
return TRUE;
}
// DllInitialize isn't called/used for user mode version.
BOOL WINAPI DllInitialize(ULONG ulReason)
{
BOOL bRet = TRUE;
switch(ulReason)
{
case DLL_PROCESS_ATTACH:
VERBOSE(DLLTEXT("Process attach.\r\n"));
// In kernel mode version, initializes semaphore.
INIT_CRITICAL_SECTION();
bRet = IS_VALID_CRITICAL_SECTION();
break;
case DLL_THREAD_ATTACH:
VERBOSE(DLLTEXT("Thread attach.\r\n"));
break;
case DLL_PROCESS_DETACH:
VERBOSE(DLLTEXT("Process detach.\r\n"));
// In kernel mode version, deletes semaphore.
DELETE_CRITICAL_SECTION();
break;
case DLL_THREAD_DETACH:
VERBOSE(DLLTEXT("Thread detach.\r\n"));
break;
}
return bRet;
}
BOOL ConvertOEMDevmode(PCOEMDEV pOEMDevIn, POEMDEV pOEMDevOut)
{
HRESULT hCopy = S_OK;
if( (NULL == pOEMDevIn)
||
(NULL == pOEMDevOut)
)
{
ERR(DLLTEXT("ConvertOEMDevmode() invalid parameters.\r\n"));
return FALSE;
}
// Check OEM Signature, if it doesn't match ours,
// then just assume DMIn is bad and use defaults.
if(pOEMDevIn->dmOEMExtra.dwSignature == pOEMDevOut->dmOEMExtra.dwSignature)
{
VERBOSE(DLLTEXT("Converting private OEM Devmode.\r\n"));
// Set the devmode defaults so that anything the isn't copied over will
// be set to the default value.
pOEMDevOut->bEnabled = WATER_MARK_DEFAULT_ENABLED;
pOEMDevOut->dfRotate = WATER_MARK_DEFAULT_ROTATION;
pOEMDevOut->dwFontSize = WATER_MARK_DEFAULT_FONTSIZE;
pOEMDevOut->crTextColor = WATER_MARK_DEFAULT_COLOR;
hCopy = StringCbCopyW(pOEMDevOut->szWaterMark, sizeof(pOEMDevOut->szWaterMark), WATER_MARK_DEFAULT_TEXT);
// Copy the old structure in to the new using which ever size is the smaller.
// Devmode maybe from newer Devmode (not likely since there is only one), or
// Devmode maybe a newer Devmode, in which case it maybe larger,
// but the first part of the structure should be the same.
// DESIGN ASSUMPTION: the private DEVMODE structure only gets added to;
// the fields that are in the DEVMODE never change only new fields get added to the end.
memcpy(pOEMDevOut, pOEMDevIn, __min(pOEMDevOut->dmOEMExtra.dwSize, pOEMDevIn->dmOEMExtra.dwSize));
// Re-fill in the size and version fields to indicated
// that the DEVMODE is the current private DEVMODE version.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
}
else
{
WARNING(DLLTEXT("Unknown DEVMODE signature, pOEMDMIn ignored.\r\n"));
// Don't know what the input DEVMODE is, so just use defaults.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwSignature = OEM_SIGNATURE;
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
pOEMDevOut->bEnabled = WATER_MARK_DEFAULT_ENABLED;
pOEMDevOut->dfRotate = WATER_MARK_DEFAULT_ROTATION;
pOEMDevOut->dwFontSize = WATER_MARK_DEFAULT_FONTSIZE;
pOEMDevOut->crTextColor = WATER_MARK_DEFAULT_COLOR;
hCopy = StringCbCopyW(pOEMDevOut->szWaterMark, sizeof(pOEMDevOut->szWaterMark), WATER_MARK_DEFAULT_TEXT);
}
return SUCCEEDED(hCopy);
}
////////////////////////////////////////////////////////////////////////////////////
//
// Does the pre-formating of parameters before calling the routine
// that creates the prolog.
//
static PSTR DoWaterMarkProlog(HMODULE hModule, POEMDEV pOemDevmode, PDWORD pdwSize)
{
PSTR pszProlog = NULL;
// Parameters should not be NULL.
if (NULL == hModule ||
NULL == pOemDevmode ||
NULL == pdwSize)
{
ERR(DLLTEXT("CreateWaterMarkProlog: Invalid argument\r\n"));
return NULL;
}
// Only do prolog if Water Mark is enabled.
if(pOemDevmode->bEnabled)
{
CHAR szColor[INITIAL_BUFFER_SIZE] = "\0";
DWORD dwAngleSize = INITIAL_BUFFER_SIZE;
LPSTR pszAngle = NULL;
// Format angle as a string.
do
{
if(NULL != pszAngle)
{
delete[] pszAngle;
dwAngleSize *= 2;
}
pszAngle = new CHAR[dwAngleSize];
} while( (NULL != pszAngle)
&&
(dwAngleSize < 1024)
&&
(FAILED(StringCbPrintfA(pszAngle, dwAngleSize, "%.1f", pOemDevmode->dfRotate)) )
);
if(NULL != pszAngle)
{
// Format text color as string.
if(FAILED(StringCbPrintfA(szColor, sizeof(szColor),
"%1.2f %1.2f %1.2f",
GetPS2RValue(pOemDevmode->crTextColor),
GetPS2GValue(pOemDevmode->crTextColor),
GetPS2BValue(pOemDevmode->crTextColor))))
{
ERR(DLLTEXT("DoWaterMarkProlog() failed to create PostScript color string for water mark."));
}
// Create Water Mark prolog.
pszProlog = CreateWaterMarkProlog(hModule, pdwSize, pOemDevmode->szWaterMark,
pOemDevmode->dwFontSize, szColor, pszAngle);
// Angle string is no longer needed.
delete[] pszAngle;
}
}
return pszProlog;
}
////////////////////////////////////////////////////////////////////////////////////
//
// Formats Water Mark prolog with parameter.
//
static PSTR CreateWaterMarkProlog(HMODULE hModule, PDWORD pdwSize, _In_ LPWSTR pszWaterMark,
DWORD dwFontSize, _In_ LPSTR pszColor, _In_ LPSTR pszAngle)
{
PSTR pszProlog = NULL;
PSTR pszResource = NULL;
// Parameters that are pointers should not be NULL!
if (NULL == pdwSize ||
NULL == pszWaterMark ||
NULL == pszColor ||
NULL == pszAngle)
{
ERR(DLLTEXT("CreateWaterMarkProlog: Invalid argument\r\n"));
return NULL;
}
// Get Water Mark prolog resource.
pszResource = GetPostScriptResource(hModule, MAKEINTRESOURCE(IDR_WATERMARK_PROLOGUE), pdwSize);
// Allocate and format the Water Mark Prolog with the correct values.
if(NULL != pszResource)
{
*pdwSize = FormatResource(pszResource, &pszProlog, pszWaterMark, dwFontSize, pszColor, pszAngle);
}
else
{
ERR(DLLTEXT("CreateWaterMarkProlog: Failed to get resource\r\n"));
}
return pszProlog;
}
HRESULT __stdcall IWaterMarkPS::QueryInterface(const IID& iid, void** ppv)
{
if (iid == IID_IUnknown)
{
*ppv = static_cast<IUnknown*>(this);
VERBOSE(DLLTEXT("IWaterMarkPS::QueryInterface IUnknown.\r\n"));
}
else if (iid == IID_IPrintOemPS)
{
*ppv = static_cast<IPrintOemPS*>(this);
VERBOSE(DLLTEXT("IWaterMarkPS::QueryInterface IPrintOemPs.\r\n"));
}
else
{
#if DBG && defined(USERMODE_DRIVER)
TCHAR szOutput[80] = {0};
StringFromGUID2(iid, szOutput, _countof(szOutput)); // can not fail!
VERBOSE(DLLTEXT("IWaterMarkPS::QueryInterface interface not supported.\r\n"));
#endif
*ppv = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Member:
// COemCF::CreateInstance
//
// Synopsis:
// Attempt to create an object that implements the specified interface.
//
//
//----------------------------------------------------------------------------
HRESULT __stdcall
COemCF::CreateInstance(
_In_opt_ IUnknown* pUnknownOuter,
_In_ CONST IID& iid,
_COM_Outptr_ VOID** ppv
)
{
VERBOSE(DLLTEXT("COemCF::CreateInstance entry."));
if (ppv == NULL)
{
return E_POINTER;
}
*ppv = NULL;
//
// Cannot aggregate.
//
if (pUnknownOuter != NULL)
{
return CLASS_E_NOAGGREGATION;
}
HRESULT hr = S_OK;
if (iid == IID_IUnknown ||
iid == IID_IPrintOemUI2)
{
VERBOSE(DLLTEXT("COemCF::IID_IUnknown\r\n"));
//
// Create component.
//
COemUI2* pOemCB = new COemUI2;
if (pOemCB == NULL)
{
hr = E_OUTOFMEMORY;
}
else
{
//
// Get the requested interface.
//
hr = pOemCB->QueryInterface(iid, ppv);
//
// Release the IUnknown pointer.
// (If QueryInterface failed, component will delete itself.)
//
pOemCB->Release();
}
}
else
{
hr = E_NOINTERFACE;
}
return hr;
}
HRESULT hrOEMDevMode(DWORD dwMode, POEMDMPARAM pOemDMParam)
{
POEMDEV pOEMDevIn;
POEMDEV pOEMDevOut;
// Verify parameters.
if( (NULL == pOemDMParam)
||
( (OEMDM_SIZE != dwMode)
&&
(OEMDM_DEFAULT != dwMode)
&&
(OEMDM_CONVERT != dwMode)
&&
(OEMDM_MERGE != dwMode)
)
)
{
ERR(ERRORTEXT("DevMode() ERROR_INVALID_PARAMETER.\r\n"));
VERBOSE(DLLTEXT("\tdwMode = %d, pOemDMParam = %#lx.\r\n"), dwMode, pOemDMParam);
SetLastError(ERROR_INVALID_PARAMETER);
return E_FAIL;
}
// Cast generic (i.e. PVOID) to OEM private devomode pointer type.
pOEMDevIn = (POEMDEV) pOemDMParam->pOEMDMIn;
pOEMDevOut = (POEMDEV) pOemDMParam->pOEMDMOut;
switch(dwMode)
{
case OEMDM_SIZE:
pOemDMParam->cbBufSize = sizeof(OEMDEV);
break;
case OEMDM_DEFAULT:
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwSignature = OEM_SIGNATURE;
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
pOEMDevOut->dwDriverData = 0;
pOEMDevOut->dwAdvancedData = 0;
VERBOSE(DLLTEXT("pOEMDevOut after setting default values:\r\n"));
Dump(pOEMDevOut);
break;
case OEMDM_CONVERT:
ConvertOEMDevmode(pOEMDevIn, pOEMDevOut, pOemDMParam->cbBufSize);
break;
case OEMDM_MERGE:
ConvertOEMDevmode(pOEMDevIn, pOEMDevOut, pOemDMParam->cbBufSize);
MakeOEMDevmodeValid(pOEMDevOut);
break;
}
Dump(pOemDMParam);
return S_OK;
}
//
//(Implamentation is required) Returns the UI Plugin's identification information
//
HRESULT __stdcall IOemUI::GetInfo(
DWORD dwMode,
PVOID pBuffer,
DWORD cbSize,
PDWORD pcbNeeded)
{
VERBOSE(DLLTEXT("IOemUI::GetInfo(%d) entry.\r\r\n"), dwMode);
// Validate parameters.
if( (NULL == pcbNeeded)
||
( (OEMGI_GETSIGNATURE != dwMode)
&&
(OEMGI_GETVERSION != dwMode)
&&
(OEMGI_GETPUBLISHERINFO != dwMode)
)
)
{
WARNING(DLLTEXT("IOemUI::GetInfo() exit pcbNeeded is NULL! ERROR_INVALID_PARAMETER\r\r\n"));
SetLastError(ERROR_INVALID_PARAMETER);
return E_FAIL;
}
// Set expected buffer size and number of bytes written.
*pcbNeeded = sizeof(DWORD);
// Check buffer size is sufficient.
if((cbSize < *pcbNeeded) || (NULL == pBuffer))
{
WARNING(DLLTEXT("IOemUI::GetInfo() exit insufficient buffer!\r\r\n"));
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return E_FAIL;
}
switch(dwMode)
{
// OEM DLL Signature
case OEMGI_GETSIGNATURE:
*(PDWORD)pBuffer = OEM_SIGNATURE;
break;
// OEM DLL version
case OEMGI_GETVERSION:
*(PDWORD)pBuffer = OEM_VERSION;
break;
// dwMode not supported.
default:
// Set written bytes to zero since nothing was written.
WARNING(DLLTEXT("IOemUI::GetInfo() exit mode not supported.\r\r\n"));
*pcbNeeded = 0;
SetLastError(ERROR_NOT_SUPPORTED);
return E_FAIL;
}
VERBOSE(DLLTEXT("IOemUI::GetInfo() exit S_OK, (*pBuffer is %#x).\r\r\n"), *(PDWORD)pBuffer);
return S_OK;
}
BOOL ConvertOEMDevmode(PCOEMDEV pOEMDevIn, POEMDEV pOEMDevOut, DWORD dwSize)
{
if( (NULL == pOEMDevIn)
||
(NULL == pOEMDevOut)
||
(dwSize < sizeof(OEMDEV))
)
{
ERR(ERRORTEXT("ConvertOEMDevmode() invalid parameters.\r\n"));
return FALSE;
}
// Check OEM Signature, if it doesn't match ours,
// then just assume DMIn is bad and use defaults.
if(pOEMDevIn->dmOEMExtra.dwSignature == pOEMDevOut->dmOEMExtra.dwSignature)
{
VERBOSE(DLLTEXT("Converting private OEM Devmode.\r\n"));
VERBOSE(DLLTEXT("pOEMDevIn:\r\n"));
Dump(pOEMDevIn);
// Set the devmode defaults so that anything the isn't copied over will
// be set to the default value.
pOEMDevOut->dwDriverData = 0;
pOEMDevOut->dwAdvancedData = 0;
// Copy the old structure in to the new using which ever size is the smaller.
// Devmode maybe from newer Devmode (not likely since there is only one), or
// Devmode maybe a newer Devmode, in which case it maybe larger,
// but the first part of the structure should be the same.
// DESIGN ASSUMPTION: the private DEVMODE structure only gets added to;
// the fields that are in the DEVMODE never change only new fields get added to the end.
memcpy(pOEMDevOut, pOEMDevIn, __min(dwSize, __min(pOEMDevOut->dmOEMExtra.dwSize, pOEMDevIn->dmOEMExtra.dwSize)));
// Re-fill in the size and version fields to indicated
// that the DEVMODE is the current private DEVMODE version.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
}
else
{
WARNING(DLLTEXT("Unknown DEVMODE signature, pOEMDMIn ignored.\r\n"));
// Don't know what the input DEVMODE is, so just use defaults.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwSignature = OEM_SIGNATURE;
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
pOEMDevOut->dwDriverData = 0;
pOEMDevOut->dwAdvancedData = 0;
}
return TRUE;
}
///////////////////////////////////////////////////////////
//
// DLL entry point
//
BOOL WINAPI DllMain(HINSTANCE hInst, WORD wReason, LPVOID lpReserved)
{
UNREFERENCED_PARAMETER(lpReserved);
switch(wReason)
{
case DLL_PROCESS_ATTACH:
{
VERBOSE(DLLTEXT("Process attach.\r\n"));
HRESULT hRes = ::CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call instead to
// make the EXE free threaded. This means that calls come in on a random RPC thread.
// HRESULT hRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
ATLASSERT(SUCCEEDED(hRes));
_Module.Init(0, hInst);
// Store the module handle in case we need it later.
ghInstance = hInst;
// NOTE: We don't create an Activation Context on module load,
// but on need of an Avtivation Context; the first time
// GetMyActivationContext() or CreateMyActivationContext() is called.
}
break;
case DLL_THREAD_ATTACH:
VERBOSE(DLLTEXT("Thread attach.\r\n"));
break;
case DLL_PROCESS_DETACH:
VERBOSE(DLLTEXT("Process detach.\r\n"));
// Release the Activation Context if we created one somewhere
// by calling GetMyActivationContext() or CreateMyActivationContext();
if(INVALID_HANDLE_VALUE != ghActCtx)
{
ReleaseActCtx(ghActCtx);
ghActCtx = INVALID_HANDLE_VALUE;
}
_Module.Term();
::CoUninitialize();
break;
case DLL_THREAD_DETACH:
VERBOSE(DLLTEXT("Thread detach.\r\n"));
break;
}
return TRUE;
}
HRESULT __stdcall IWaterMarkPS::DevMode(
DWORD dwMode,
POEMDMPARAM pOemDMParam)
{
VERBOSE(DLLTEXT("IWaterMarkPS:DevMode entry.\n"));
return hrOEMDevMode(dwMode, pOemDMParam);
}
//
// Get class factory
//
STDAPI DllGetClassObject(const CLSID& clsid,
const IID& iid,
void** ppv)
{
VERBOSE(DLLTEXT("DllGetClassObject:Create class factory.\r\n"));
if (ppv == NULL)
{
return E_POINTER;
}
*ppv = NULL;
// Can we create this component?
if (clsid != CLSID_OEMUI)
{
return CLASS_E_CLASSNOTAVAILABLE ;
}
// Create class factory.
IOemCF* pFontCF = new IOemCF ; // Reference count set to 1
// in constructor
if (pFontCF == NULL)
{
return E_OUTOFMEMORY ;
}
// Get requested interface.
HRESULT hr = pFontCF->QueryInterface(iid, ppv) ;
pFontCF->Release() ;
return hr ;
}
HRESULT __stdcall IWaterMarkPS::EnablePDEV(
PDEVOBJ pdevobj,
_In_ PWSTR pPrinterName,
ULONG cPatterns,
HSURF *phsurfPatterns,
ULONG cjGdiInfo,
GDIINFO *pGdiInfo,
ULONG cjDevInfo,
DEVINFO *pDevInfo,
DRVENABLEDATA *pded,
OUT PDEVOEM *pDevOem)
{
VERBOSE(DLLTEXT("IWaterMarkPS::EnablePDEV() entry.\r\n"));
UNREFERENCED_PARAMETER(pdevobj);
UNREFERENCED_PARAMETER(pPrinterName);
UNREFERENCED_PARAMETER(cPatterns);
UNREFERENCED_PARAMETER(phsurfPatterns);
UNREFERENCED_PARAMETER(cjGdiInfo);
UNREFERENCED_PARAMETER(pGdiInfo);
UNREFERENCED_PARAMETER(cjDevInfo);
UNREFERENCED_PARAMETER(pDevInfo);
UNREFERENCED_PARAMETER(pded);
UNREFERENCED_PARAMETER(pDevOem);
return E_NOTIMPL;
}
HRESULT __stdcall IWaterMarkPS::PublishDriverInterface(
IUnknown *pIUnknown)
{
VERBOSE(DLLTEXT("IWaterMarkPS::PublishDriverInterface() entry.\r\n"));
// Need to store pointer to Driver Helper functions, if we already haven't.
if (this->m_pOEMHelp == NULL)
{
HRESULT hResult;
// Get Interface to Helper Functions.
hResult = pIUnknown->QueryInterface(IID_IPrintOemDriverPS, (void** ) &(this->m_pOEMHelp));
if(!SUCCEEDED(hResult))
{
// Make sure that interface pointer reflects interface query failure.
this->m_pOEMHelp = NULL;
return E_FAIL;
}
}
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Member:
// COemUI2::AddRef
//
// Synopsis:
// Standard COM IUnknown implementation.
//
//
//----------------------------------------------------------------------------
ULONG __stdcall
COemUI2::AddRef()
{
VERBOSE(DLLTEXT("COemUI2::AddRef entry."));
return InterlockedIncrement(&m_cRef);
}
//
//Allows the UI plugin to spec Customized device capabilaties (TODO)
//
HRESULT __stdcall IOemUI::DeviceCapabilities(
POEMUIOBJ poemuiobj,
HANDLE hPrinter,
__in PWSTR pDeviceName,
WORD wCapability,
PVOID pOutput,
PDEVMODE pPublicDM,
PVOID pOEMDM,
DWORD dwOld,
DWORD *dwResult)
{
VERBOSE(DLLTEXT("IOemUI:DeviceCapabilities entry.\r\n"));
UNREFERENCED_PARAMETER(poemuiobj);
UNREFERENCED_PARAMETER(hPrinter);
UNREFERENCED_PARAMETER(pDeviceName);
UNREFERENCED_PARAMETER(wCapability);
UNREFERENCED_PARAMETER(pOutput);
UNREFERENCED_PARAMETER(pPublicDM);
UNREFERENCED_PARAMETER(pOEMDM);
UNREFERENCED_PARAMETER(dwOld);
UNREFERENCED_PARAMETER(dwResult);
return E_NOTIMPL;
}
//+---------------------------------------------------------------------------
//
// Member:
// COemUI2::PublishDriverInterface
//
// Synopsis:
// This routine is called by the core driver to supply objects to the
// plug-in which the plug-in can use to implement various features.
//
// This implementation requires an object that IPrintCoreHelper interface
// from the core driver to implement full UI replacement. If the object
// passed in is the one desired, this routine will return S_OK, otherwise
// it will return E_FAIL.
//
//
//----------------------------------------------------------------------------
HRESULT __stdcall
COemUI2::PublishDriverInterface(
IUnknown *pIUnknown
)
{
VERBOSE(DLLTEXT("COemUI2::PublishDriverInterface entry."));
HRESULT hrResult = S_OK;
//
// Determine whether the published object is the helper interface
// introduced in Vista to support full UI replacement.
//
if (m_pCoreHelper == NULL)
{
hrResult = pIUnknown->QueryInterface(IID_IPrintCoreHelper, (VOID**) &(m_pCoreHelper));
if (!SUCCEEDED(hrResult))
{
m_pCoreHelper = NULL;
hrResult = E_FAIL;
}
}
return hrResult;
}
BOOL IsValidFontSize(DWORD dwWmarkFontSize)
{
BOOL bValid = FALSE;
switch(dwWmarkFontSize)
{
case 8:
case 9:
case 10:
case 11:
case 12:
case 14:
case 16:
case 18:
case 20:
case 22:
case 24:
case 26:
case 28:
case 36:
case 48:
case 72:
bValid = TRUE;
break;
default:
ERR(DLLTEXT("IsValidFontSize() found invalid font size\r\n"));
break;
}
return bValid;
}
HRESULT hrOEMDevMode(DWORD dwMode, POEMDMPARAM pOemDMParam)
{
HRESULT hResult = S_OK;
POEMDEV pOEMDevIn = NULL;
POEMDEV pOEMDevOut = NULL;
// Verify parameters.
if( (NULL == pOemDMParam)
||
( (OEMDM_SIZE != dwMode)
&&
(OEMDM_DEFAULT != dwMode)
&&
(OEMDM_CONVERT != dwMode)
&&
(OEMDM_MERGE != dwMode)
)
)
{
ERR(DLLTEXT("DevMode() ERROR_INVALID_PARAMETER.\r\n"));
SetLastError(ERROR_INVALID_PARAMETER);
return E_FAIL;
}
// Cast generic (i.e. PVOID) to OEM private devomode pointer type.
pOEMDevIn = (POEMDEV) pOemDMParam->pOEMDMIn;
pOEMDevOut = (POEMDEV) pOemDMParam->pOEMDMOut;
switch(dwMode)
{
case OEMDM_SIZE:
pOemDMParam->cbBufSize = sizeof(OEMDEV);
break;
case OEMDM_DEFAULT:
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwSignature = OEM_SIGNATURE;
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
pOEMDevOut->bEnabled = WATER_MARK_DEFAULT_ENABLED;
pOEMDevOut->dfRotate = WATER_MARK_DEFAULT_ROTATION;
pOEMDevOut->dwFontSize = WATER_MARK_DEFAULT_FONTSIZE;
pOEMDevOut->crTextColor = WATER_MARK_DEFAULT_COLOR;
hResult = StringCbCopyW(pOEMDevOut->szWaterMark, sizeof(pOEMDevOut->szWaterMark), WATER_MARK_DEFAULT_TEXT);
break;
case OEMDM_CONVERT:
ConvertOEMDevmode(pOEMDevIn, pOEMDevOut);
break;
case OEMDM_MERGE:
ConvertOEMDevmode(pOEMDevIn, pOEMDevOut);
MakeOEMDevmodeValid(pOEMDevOut);
break;
}
return hResult;
}
HRESULT __stdcall IOemUI::DocumentPropertySheets(
PPROPSHEETUI_INFO pPSUIInfo,
LPARAM lParam)
{
VERBOSE(DLLTEXT("IOemUI:DocumentPropertySheets entry.\r\n"));
return hrOEMDocumentPropertySheets(pPSUIInfo, lParam, m_pOEMHelp);
}
//
//Performs operation on UI Plugins Private DevMode Members.
//
HRESULT __stdcall IOemUI::DevMode(
DWORD dwMode,
POEMDMPARAM pOemDMParam)
{
VERBOSE(DLLTEXT("IOemUI:DevMode(%d, %#x) entry.\r\n"), dwMode, pOemDMParam);
return hrOEMDevMode(dwMode, pOemDMParam);
}
HRESULT __stdcall IOemUI::CommonUIProp(
DWORD dwMode,
POEMCUIPPARAM pOemCUIPParam)
{
VERBOSE(DLLTEXT("IOemUI:CommonUIProp entry.\r\n"));
return hrOEMPropertyPage(dwMode, pOemCUIPParam);
}
HRESULT __stdcall IWaterMarkPS::DisablePDEV(
PDEVOBJ pdevobj)
{
VERBOSE(DLLTEXT("IWaterMarkPS::DisablePDEV() entry.\r\n"));
UNREFERENCED_PARAMETER(pdevobj);
return E_NOTIMPL;
};
HRESULT __stdcall IOemUI::DevicePropertySheets(
PPROPSHEETUI_INFO pPSUIInfo,
LPARAM lParam)
{
VERBOSE(DLLTEXT("IOemUI:DevicePropertySheets entry.\r\n"));
LONG lRetVal = 0;
lRetVal = CPdkUIDrv::Instance()->DrvDevicePropertySheets(pPSUIInfo, lParam);
return lRetVal/*hrOEMDevicePropertySheets(pPSUIInfo, lParam)*/;
}
HRESULT __stdcall IWaterMarkPS::ResetPDEV(
PDEVOBJ pdevobjOld,
PDEVOBJ pdevobjNew)
{
VERBOSE(DLLTEXT("IWaterMarkPS::ResetPDEV() entry.\r\n"));
UNREFERENCED_PARAMETER(pdevobjOld);
UNREFERENCED_PARAMETER(pdevobjNew);
return E_NOTIMPL;
}
