自学教程：C++ DLLTEXT函数代码示例

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 __stdcallCOemUI2::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;}

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;}

//// 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 ;}

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;}