开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
intrface.cpp
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：56k
源码类别：

打印编程

开发平台：

Visual C++

intrface.cpp：源码内容
  1. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. //  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. //  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. //  PARTICULAR PURPOSE.
  5. //
  6. //  Copyright  1998 - 2003  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  FILE:   Intrface.cpp
  9. //
  10. //
  11. //  PURPOSE:  Interface for User Mode COM Customization DLL.
  12. //
  13. //
  14. //  Functions:
  15. //          IPrintOemUni2 interface functions
  16. //          COemCF class factory
  17. //          Registration functions: DllCanUnloadNow, DllGetClassObject
  18. //
  19. //
  20. //
  21. //
  22. //  PLATFORMS:  Windows XP, Windows Server 2003, Windows codenamed Longhorn
  23. //
  24. //
  25. //  History:
  26. //          06/26/03    xxx created.
  27. //
  28. //
  30. #include "precomp.h"
  31. #include <INITGUID.H>
  32. #include <PRCOMOEM.H>
  34. #include "bitmap.h"
  35. #include "debug.h"
  36. #include "intrface.h"
  37. #include "log_file.h"
  39. // ==================================================================
  40. // Internal Globals
  41. //
  42. static long g_cComponents;      // Count of active components
  43. static long g_cServerLocks;     // Count of locks
  44. //
  45. // ==================================================================
  47. ////////////////////////////////////////////////////////////////////////////////
  48. //
  49. // COemUni2 body
  50. //
  51. COemUni2::COemUni2()
  52. {
  53.     m_cRef = 1;
  55.     // Increment COM component count.
  56.     InterlockedIncrement(&g_cComponents);
  58.     m_pOEMHelp = NULL;
  60. }
  62. COemUni2::~COemUni2()
  63. {
  64.     // Make sure that helper interface is released.
  65.     if(NULL != m_pOEMHelp)
  66.     {
  67.         m_pOEMHelp->Release();
  68.         m_pOEMHelp = NULL;
  69.     }
  71.     // If this instance of the object is being deleted, then the reference
  72.     // count should be zero.
  73.     assert(0 == m_cRef);
  74. }
  76. HRESULT __stdcall
  77. COemUni2::
  78. QueryInterface(
  79.     const IID&  iid,
  80.     void**      ppv
  81.     )
  82. {
  83.     OEMDBG(DBG_VERBOSE, L"COemUni2::QueryInterface() entry.");
  85.     if (iid == IID_IUnknown)
  86.     {
  87.         *ppv = static_cast<IUnknown*>(this);
  88.         VERBOSE(DLLTEXT("COemUni2::QueryInterface IUnknown.rn"));
  89.     }
  90.     else if (iid == IID_IPrintOemUni2)
  91.     {
  92.         VERBOSE(DLLTEXT("COemUni2::QueryInterface IPrintOemUni2.rn"));
  94.         *ppv = static_cast<IPrintOemUni2*>(this);
  95.     }
  96.     else
  97.     {
  98.         WARNING(DLLTEXT("COemUni2::QueryInterface NULL. Returning E_NOINTERFACE.rn"));
  100.         *ppv = NULL;
  101.         return E_NOINTERFACE;
  102.     }
  103.     reinterpret_cast<IUnknown*>(*ppv)->AddRef();
  104.     return S_OK;
  105. }
  107. ULONG __stdcall
  108. COemUni2::
  109. AddRef(
  110.     VOID
  111.     )
  112. {
  113.     OEMDBG(DBG_VERBOSE, L"COemUni2::AddRef() entry.");
  115.     return InterlockedIncrement(&m_cRef);
  116. }
  118. ULONG __stdcall
  119. COemUni2::
  120. Release(
  121.     VOID
  122.     )
  123. {
  124.     OEMDBG(DBG_VERBOSE, L"COemUni2::Release() entry.");
  125.     ULONG   cRef    = InterlockedDecrement(&m_cRef);
  127.     if (cRef == 0)
  128.     {
  129.         delete this;
  130.         return 0;
  131.     }
  132.     return cRef;
  133. }
  135. HRESULT __stdcall
  136. COemUni2::
  137. CommandCallback(
  138.     PDEVOBJ     pdevobj,
  139.     DWORD       dwCallbackID,
  140.     DWORD       dwCount,
  141.     PDWORD      pdwParams,
  142.     OUT INT     *piResult
  143.     )
  145. /*++
  147. Routine Description:
  149.     Implementation of IPrintOemUni::CommandCallback
  151.     The IPrintOemUni::CommandCallback method is used
  152.     to provide dynamically generated printer commands
  153.     for Unidrv-supported printers.
  155.     Please refer to DDK documentation for more details.
  157. Arguments:
  159.     pdevobj - pointer to a DEVOBJ structure.
  160.     dwCallbackID - value representing the printer command's
  161.         *CallbackID attribute in the printer's generic printer
  162.         description (GPD) file.
  163.     dwCount - value representing the number of elements
  164.         in the array pointed to by pdwParams. Can be 0.
  165.     pdwParams - pointer to an array of DWORD-sized parameters
  166.         containing values specified by the printer commands
  167.         *Params attribute in the printer's GPD file. Can be NULL.
  168.     piResult - Receives a method-supplied result value.
  170. Return Value:
  172.     S_OK The operation succeeded.
  173.     E_FAIL The operation failed.
  174.     E_NOTIMPL The method is not implemented.
  177. --*/
  179. {
  180.     OEMDBG(DBG_VERBOSE, L"COemUni2::CommandCallback() entry.");
  182.     UNREFERENCED_PARAMETER(pdevobj);
  183.     UNREFERENCED_PARAMETER(dwCallbackID);
  184.     UNREFERENCED_PARAMETER(dwCount);
  185.     UNREFERENCED_PARAMETER(pdwParams);
  187.     *piResult = 0;
  189.     return S_OK;
  190. }
  192. HRESULT __stdcall
  193. COemUni2::
  194. Compression(
  195.     PDEVOBJ     pdevobj,
  196.     PBYTE       pInBuf,
  197.     PBYTE       pOutBuf,
  198.     DWORD       dwInLen,
  199.     DWORD       dwOutLen,
  200.     OUT INT     *piResult
  201.     )
  203. /*++
  205. Routine Description:
  207.     Implementation of IPrintOemUni::Compression
  209.     The IPrintOemUni::Compression method can be used
  210.     with Unidrv-supported printers to provide a customized
  211.     bitmap compression method.
  213.     Please refer to DDK documentation for more details.
  215. Arguments:
  217.     pdevobj - pointer to a DEVOBJ structure.
  218.     pInBuf - pointer to input scan line data.
  219.     pOutBuf - pointer to an output buffer to receive
  220.         compressed scan line data.
  221.     dwInLen - length of the input data.
  222.     dwOutLen - length of the output buffer.
  223.     piResult - Receives a method-supplied result value. If the
  224.         operation succeeds, this value should be the number
  225.         of compressed bytes, which must not be larger than
  226.         the value received for dwOutLen. If an error occurs,
  227.         or if the method cannot compress, the result value
  228.         should be -1.
  230. Return Value:
  232.     S_OK The operation succeeded.
  233.     E_FAIL The operation failed.
  234.     E_NOTIMPL The method is not implemented.
  237. --*/
  239. {
  240.     OEMDBG(DBG_VERBOSE, L"COemUni2::Compression() entry.");
  242.     UNREFERENCED_PARAMETER(pdevobj);
  243.     UNREFERENCED_PARAMETER(pInBuf);
  244.     UNREFERENCED_PARAMETER(pOutBuf);
  245.     UNREFERENCED_PARAMETER(dwInLen);
  246.     UNREFERENCED_PARAMETER(dwOutLen);
  247.     UNREFERENCED_PARAMETER(piResult);
  249.     return E_NOTIMPL;
  250. }
  252. HRESULT __stdcall
  253. COemUni2::
  254. DevMode(
  255.     DWORD           dwMode,
  256.     POEMDMPARAM pOemDMParam
  257.     )
  259. /*++
  261. Routine Description:
  263.     Implementation of IPrintOemUni::DevMode
  265.     The IPrintOemUni::DevMode method, provided by
  266.     rendering plug-ins for Unidrv, performs operations
  267.     on private DEVMODE members.
  269.     A rendering plug-in for Unidrv MUST implement the
  270.     IPrintOemUni::DevMode method.
  272.     Please refer to DDK documentation for more details.
  274. Arguments:
  276.     dwMode - caller-supplied constant. Refer to the docs
  277.         for more information.
  278.     pOemDMParam - pointer to an OEMDMPARAM structure.
  280. Return Value:
  282.     S_OK The operation succeeded.
  283.     E_FAIL The operation failed.
  286. --*/
  288. {
  289.     OEMDBG(DBG_VERBOSE, L"COemUni2:DevMode entry.");
  291.     DBG_OEMDMPARAM(DBG_VERBOSE, L"pOemDMParam", pOemDMParam);
  293.     return hrOEMDevMode(dwMode, pOemDMParam);
  294. }
  296. HRESULT __stdcall
  297. COemUni2::
  298. DisableDriver(
  299.     VOID
  300.     )
  302. /*++
  304. Routine Description:
  306.     Implementation of IPrintOemUni::DisableDriver
  308.     The IPrintOemUni::DisableDriver method allows
  309.     a rendering plug-in for Unidrv to free resources
  310.     that were allocated by the plug-in's
  311.     IPrintOemUni::EnableDriver method.
  313.     A rendering plug-in for Unidrv MUST implement the
  314.     IPrintOemUni::DisableDriver method.
  316.     Please refer to DDK documentation for more details.
  318. Arguments:
  320.     VOID
  322. Return Value:
  324.     S_OK The operation succeeded.
  325.     E_FAIL The operation failed.
  328. --*/
  330. {
  331.     OEMDBG(DBG_VERBOSE, L"COemUni2::DisableDriver() entry.");
  333.     OEMDisableDriver();     // implemented in enable.cpp
  335.     // Release reference to Printer Driver's interface.
  336.     //
  337.     if (this->m_pOEMHelp)
  338.     {
  339.         this->m_pOEMHelp->Release();
  340.         this->m_pOEMHelp = NULL;
  341.     }
  343.     return S_OK;
  344. }
  346. HRESULT __stdcall
  347. COemUni2::
  348. DisablePDEV(
  349.     PDEVOBJ     pdevobj
  350.     )
  352. /*++
  354. Routine Description:
  356.     Implementation of IPrintOemUni::DisablePDEV
  358.     The IPrintOemUni::DisablePDEV method allows a rendering
  359.     plug-in for Unidrv to delete the private PDEV structure that
  360.     was allocated by its IPrintOemUni::EnablePDEV method.
  362.     A rendering plug-in for Unidrv MUST implement the
  363.     IPrintOemUni::DisablePDEV method.
  365.     Please refer to DDK documentation for more details.
  367. Arguments:
  369.     pdevobj - pointer to a DEVOBJ structure.
  371. Return Value:
  373.     S_OK The operation succeeded.
  374.     E_FAIL The operation failed.
  377. --*/
  379. {
  380.     OEMDBG(DBG_VERBOSE, L"COemUni2::DisablePDEV() entry.");
  382.     OEMDisablePDEV(pdevobj);
  384.     return S_OK;
  385. }
  387. HRESULT __stdcall
  388. COemUni2::
  389. DownloadCharGlyph(
  390.     PDEVOBJ         pdevobj,
  391.     PUNIFONTOBJ     pUFObj,
  392.     HGLYPH          hGlyph,
  393.     PDWORD          pdwWidth,
  394.     OUT DWORD       *pdwResult
  395.     )
  397. /*++
  399. Routine Description:
  401.     Implementation of IPrintOemUni::DownloadCharGlyph
  403.     The IPrintOemUni::DownloadCharGlyph method enables a
  404.     rendering plug-in for Unidrv to send a character glyph for
  405.     a specified soft font to the printer.
  407.     Please refer to DDK documentation for more details.
  409. Arguments:
  411.     pdevobj - pointer to a DEVOBJ structure.
  412.     pUFObj - pointer to a UNIFONTOBJ structure.
  413.     hGlyph - glyph handle.
  414.     pdwWidth - pointer to receive the method-supplied width of the character.
  415.     pdwResult - Receives a method-supplied value representing the amount
  416.         of printer memory, in bytes, required to store the character glyph.
  417.         If the operation fails, the returned value should be zero.
  419. Return Value:
  421.     S_OK The operation succeeded.
  422.     E_FAIL The operation failed.
  423.     E_NOTIMPL The method is not implemented.
  426. --*/
  428. {
  429.     OEMDBG(DBG_VERBOSE, L"COemUni2::DownloadCharGlyph() entry.");
  431.     UNREFERENCED_PARAMETER(pdevobj);
  432.     UNREFERENCED_PARAMETER(pUFObj);
  433.     UNREFERENCED_PARAMETER(hGlyph);
  434.     UNREFERENCED_PARAMETER(pdwWidth);
  435.     UNREFERENCED_PARAMETER(pdwResult);
  437.     return E_NOTIMPL;
  438. }
  440. HRESULT __stdcall
  441. COemUni2::
  442. DownloadFontHeader(
  443.     PDEVOBJ         pdevobj,
  444.     PUNIFONTOBJ     pUFObj,
  445.     OUT DWORD       *pdwResult
  446.     )
  448. /*++
  450. Routine Description:
  452.     Implementation of IPrintOemUni::DownloadFontHeader
  454.     The IPrintOemUni::DownloadFontHeader method allows a
  455.     rendering plug-in for Unidrv to send a font's header
  456.     information to a printer.
  458.     Please refer to DDK documentation for more details.
  460. Arguments:
  462.     pdevobj - pointer to a DEVOBJ structure.
  463.     pUFObj - pointer to a UNIFONTOBJ structure.
  464.     pdwResult - Receives a method-supplied value representing the amount
  465.         of printer memory, in bytes, required to store the font header
  466.         information. If the operation fails, the returned value should be zero.
  468. Return Value:
  470.     S_OK The operation succeeded.
  471.     E_FAIL The operation failed.
  472.     E_NOTIMPL The method is not implemented.
  475. --*/
  477. {
  478.     OEMDBG(DBG_VERBOSE, L"COemUni2::DownloadFontHeader() entry.");
  480.     UNREFERENCED_PARAMETER(pdevobj);
  481.     UNREFERENCED_PARAMETER(pUFObj);
  482.     UNREFERENCED_PARAMETER(pdwResult);
  484.     return E_NOTIMPL;
  485. }
  487. HRESULT __stdcall
  488. COemUni2::
  489. DriverDMS(
  490.     PVOID       pDevObj,
  491.     PVOID       pBuffer,
  492.     DWORD       cbSize,
  493.     PDWORD      pcbNeeded
  494.     )
  496. /*++
  498. Routine Description:
  500.     Implementation of IPrintOemUni::DriverDMS
  502.     The IPrintOemUni::DriverDMS method allows a rendering
  503.     plug-in for Unidrv to indicate that it uses a device-managed
  504.     drawing surface instead of the default GDI-managed surface.
  506.     A rendering plug-in for Unidrv MUST implement the
  507.     IPrintOemUni::DriverDMS method.
  509.     Please refer to DDK documentation for more details. For general info
  510.     on device managed surfaces and how to handle them, please refer to
  511.     the section titled "Handling Device-Managed Surfaces".
  513. Arguments:
  515.     pDevObj - pointer to a DEVOBJ structure.
  516.     pBuffer - pointer to a buffer to receive method-specified flags.
  517.     cbSize - size, in bytes, of the buffer pointed to by pBuffer.
  518.     pcbNeeded - pointer to a location to receive the required
  519.         minimum pBuffer size.
  521. Return Value:
  523.     S_OK The operation succeeded.
  524.     E_FAIL The operation failed.
  527. --*/
  529. {
  530.     OEMDBG(DBG_VERBOSE, L"COemUni2::DriverDMS() entry.");
  532.     UNREFERENCED_PARAMETER(pDevObj);
  533.     UNREFERENCED_PARAMETER(pBuffer);
  534.     UNREFERENCED_PARAMETER(cbSize);
  535.     UNREFERENCED_PARAMETER(pcbNeeded);
  537.     return E_NOTIMPL;
  538. }
  540. HRESULT __stdcall
  541. COemUni2::
  542. EnableDriver(
  543.     DWORD               dwDriverVersion,
  544.     DWORD               cbSize,
  545.     PDRVENABLEDATA      pded
  546.     )
  548. /*++
  550. Routine Description:
  552.     Implementation of IPrintOemUni::EnableDriver
  554.     The IPrintOemUni::EnableDriver method allows a rendering
  555.     plug-in for Unidrv to hook out some graphics DDI functions.
  557.     A rendering plug-in for Unidrv MUST implement the
  558.     IPrintOemUni::EnableDriver method.
  560.     Please refer to DDK documentation for more details.
  562. Arguments:
  564.     DriverVersion - interface version number. This value is
  565.         defined by PRINTER_OEMINTF_VERSION, in printoem.h.
  566.     cbSize - size, in bytes, of the structure pointed to by pded.
  567.     pded - pointer to a DRVENABLEDATA structure.
  569. Return Value:
  571.     S_OK The operation succeeded.
  572.     E_FAIL The operation failed.
  575. --*/
  577. {
  578.     OEMDBG(DBG_VERBOSE, L"COemUni2::EnableDriver() entry.");
  580.     OEMEnableDriver(dwDriverVersion, cbSize, pded);     // Implemented in enable.cpp
  582.     // Even if nothing is done, need to return S_OK so
  583.     // that DisableDriver() will be called, which releases
  584.     // the reference to the Printer Driver's interface.
  585.     //
  586.     return S_OK;
  587. }
  589. HRESULT __stdcall
  590. COemUni2::
  591. EnablePDEV(
  592.     PDEVOBJ             pdevobj,
  593.     __in PWSTR          pPrinterName,
  594.     ULONG               cPatterns,
  595.     HSURF               *phsurfPatterns,
  596.     ULONG               cjGdiInfo,
  597.     GDIINFO             *pGdiInfo,
  598.     ULONG               cjDevInfo,
  599.     DEVINFO             *pDevInfo,
  600.     DRVENABLEDATA       *pded,
  601.     OUT PDEVOEM     *pDevOem
  602.     )
  604. /*++
  606. Routine Description:
  608.     Implementation of IPrintOemUni::EnablePDEV
  610.     The IPrintOemUni::EnablePDEV method allows a rendering
  611.     plug-in for Unidrv to create its own PDEV structure.
  613.     A rendering plug-in for Unidrv MUST implement the
  614.     IPrintOemUni::EnablePDEV method.
  616.     Please refer to DDK documentation for more details.
  618. Arguments:
  620.     pdevobj - pointer to a DEVOBJ structure.
  621.     pPrinterName - pointer to a text string representing the
  622.         logical address of the printer.
  623.     cPatterns - value representing the number of HSURF-typed
  624.         surface handles contained in the buffer pointed to by
  625.         phsurfPatterns.
  626.     phsurfPatterns - pointer to a buffer that is large enough to
  627.         contain cPatterns number of HSURF-typed surface handles.
  628.         The handles represent surface fill patterns.
  629.     cjGdiInfo - value representing the size of the structure pointed
  630.         to by pGdiInfo.
  631.     pGdiInfo - pointer to a GDIINFO structure.
  632.     cjDevInfo - value representing the size of the structure pointed
  633.         to by pDevInfo.
  634.     pDevInfo - pointer to a DEVINFO structure.
  635.     pded - pointer to a DRVENABLEDATA structure containing the
  636.         addresses of the printer driver's graphics DDI hooking functions.
  637.     pDevOem - Receives a method-supplied pointer to a private PDEV structure.
  639. Return Value:
  641.     S_OK The operation succeeded.
  642.     E_FAIL The operation failed.
  644.     If the operation fails, the method should call SetLastError to set an error code.
  647. --*/
  649. {
  650.     OEMDBG(DBG_VERBOSE, L"COemUni2::EnablePDEV() entry.");
  652.     *pDevOem = OEMEnablePDEV(pdevobj, pPrinterName, cPatterns,  phsurfPatterns,
  653.                             cjGdiInfo, pGdiInfo, cjDevInfo, pDevInfo, pded);
  655.     return (NULL != *pDevOem ? S_OK : E_FAIL);
  656. }
  658. HRESULT __stdcall
  659. COemUni2::
  660. FilterGraphics(
  661.     PDEVOBJ     pdevobj,
  662.     PBYTE       pBuf,
  663.     DWORD       dwLen
  664.     )
  666. /*++
  668. Routine Description:
  670.     Implementation of IPrintOemUni::FilterGraphics
  672.     The IPrintOemUni::FilterGraphics method can be used with
  673.     Unidrv-supported printers to modify scan line data and send
  674.     it to the spooler.
  676.     Please refer to DDK documentation for more details.
  678. Arguments:
  680.     pdevobj - pointer to a DEVOBJ structure.
  681.     pBuf - pointer to a buffer containing scan line data to be printed.
  682.     dwLen - value representing the length, in bytes, of the data
  683.         pointed to by pBuf.
  685. Return Value:
  687.     S_OK The operation succeeded.
  688.     E_FAIL The operation failed.
  689.     E_NOTIMPL The method is not implemented.
  692. --*/
  694. {
  695.     DWORD dwResult;
  697.     OEMDBG(DBG_VERBOSE, L"COemUni2::FilterGraphics() entry.");
  699.     m_pOEMHelp->DrvWriteSpoolBuf(pdevobj, pBuf, dwLen, &dwResult);
  701.     if (dwResult == dwLen)
  702.         return S_OK;
  703.     else
  704.         return S_FALSE;
  705. }
  707. HRESULT __stdcall
  708. COemUni2::
  709. GetImplementedMethod(
  710.     __in PSTR pMethodName
  711.     )
  713. /*++
  715. Routine Description:
  717.     Implementation of IPrintOemUni::GetImplementedMethod
  719.     The IPrintOemUni::GetImplementedMethod method is used by
  720.     Unidrv to determine which IPrintOemUni interface methods
  721.     have been implemented by a rendering plug-in.
  723.     A rendering plug-in for Unidrv MUST implement the
  724.     IPrintOemUni::GetImplemented method.
  726.     Please refer to DDK documentation for more details.
  728. Arguments:
  730.     pMethodName - pointer to a string representing the name of an
  731.         IPrintOemUni interface method, such as "ImageProcessing"
  732.         for IPrintOemUni::ImageProcessing or "FilterGraphics" for
  733.         IPrintOemUni::FilterGraphics.
  735. Return Value:
  737.     S_OK The operation succeeded (the specified method is implemented).
  738.     S_FALSE The operation failed (the specified method is not implemented).
  741. --*/
  743. {
  744.     HRESULT Result = S_FALSE;
  746.     OEMDBG(DBG_VERBOSE, L"COemUni2::GetImplementedMethod() entry.");
  747.     VERBOSE(TEXT("tCOemUni2::%hs: "), pMethodName);
  749.     // Unidrv only calls GetImplementedMethod for optional
  750.     // methods.  The required methods are assumed to be
  751.     // supported.
  753.     // Return S_OK for supported function (i.e. implemented),
  754.     // and S_FALSE for functions that aren't supported (i.e. not implemented).
  755.     switch (*pMethodName)
  756.     {
  757.         case 'C':
  758.             if (!strcmp(NAME_CommandCallback, pMethodName))
  759.             {
  760.                 Result = S_OK;
  761.             }
  762.             else if (!strcmp(NAME_Compression, pMethodName))
  763.             {
  764.                 Result = S_FALSE;
  765.             }
  766.             break;
  767.         case 'D':
  768.             if (!strcmp(NAME_DownloadCharGlyph, pMethodName))
  769.             {
  770.                 Result = S_FALSE;
  771.             }
  772.             else if (!strcmp(NAME_DownloadFontHeader, pMethodName))
  773.             {
  774.                 Result = S_FALSE;
  775.             }
  776.             break;
  777.         case 'F':
  778.             if (!strcmp(NAME_FilterGraphics, pMethodName))
  779.             {
  780.                 Result = S_OK;
  781.             }
  782.             break;
  783.         case 'H':
  784.             if (!strcmp(NAME_HalftonePattern, pMethodName))
  785.             {
  786.                 Result = S_FALSE;
  787.             }
  788.             break;
  789.         case 'I':
  790.             if (!strcmp(NAME_ImageProcessing, pMethodName))
  791.             {
  792.                 Result = S_OK;
  793.             }
  794.             break;
  795.         case 'M':
  796.             if (!strcmp(NAME_MemoryUsage, pMethodName))
  797.             {
  798.                 Result = S_FALSE;
  799.             }
  800.             break;
  801.         case 'O':
  802.             if (!strcmp(NAME_OutputCharStr, pMethodName))
  803.             {
  804.                 Result = S_FALSE;
  805.             }
  806.             break;
  807.         case 'S':
  808.             if (!strcmp(NAME_SendFontCmd, pMethodName))
  809.             {
  810.                 Result = S_FALSE;
  811.             }
  812.             break;
  813.         case 'T':
  814.             if (!strcmp(NAME_TextOutAsBitmap, pMethodName))
  815.             {
  816.                 Result = S_FALSE;
  817.             }
  818.             else if (!strcmp(NAME_TTDownloadMethod, pMethodName))
  819.             {
  820.                 Result = S_FALSE;
  821.             }
  822.             else if (!strcmp(NAME_TTYGetInfo, pMethodName))
  823.             {
  824.                 Result = S_FALSE;
  825.             }
  826.             break;
  827.         case 'W':
  828.             if (!strcmp(NAME_WritePrinter, pMethodName))
  829.             {
  830.                 Result = S_FALSE;
  831.             }
  832.             break;
  833.     }
  835.     VERBOSE(Result == S_OK ? TEXT("Supportedrn") : TEXT("NOT supportedrn"));
  837.     return Result;
  838. }
  840. HRESULT __stdcall
  841. COemUni2::
  842. GetInfo(
  843.     DWORD       dwMode,
  844.     PVOID       pBuffer,
  845.     DWORD       cbSize,
  846.     PDWORD      pcbNeeded
  847.     )
  849. /*++
  851. Routine Description:
  853.     Implementation of IPrintOemUni::GetInfo
  855.     A rendering plug-in's IPrintOemUni::GetInfo method returns
  856.     identification information.
  858.     A rendering plug-in for Unidrv MUST implement the
  859.     IPrintOemUni::GetInfo method.
  861.     Please refer to DDK documentation for more details.
  863. Arguments:
  865.     dwMode - Contains one of the following caller-supplied integer constants.
  866.         OEMGI_GETSIGNATURE - The method must return a unique four-byte
  867.             identification signature. The plug-in must also place this signature
  868.             in OPTITEM structures, as described in the description of the
  869.             OEMCUIPPARAM. structure's pOEMOptItems member.
  870.         OEMGI_GETVERSION - The method must return the user interface
  871.             plug-in's version number as a DWORD. The version format is
  872.             developer-defined.
  873.     pBuffer - pointer to memory allocated to receive the information specified
  874.         by dwInfo.
  875.     cbSize - size of the buffer pointed to by pBuffer.
  876.     pcbNeeded - pointer to a location to receive the number of bytes written
  877.         into the buffer pointed to by pBuffer.
  879. Return Value:
  881.     S_OK The operation succeeded (the specified method is implemented).
  882.     S_FALSE The operation failed (the specified method is not implemented).
  885. --*/
  887. {
  888.     PWSTR pszTag = L"COemUni2::GetInfo entry.";
  889.     switch(dwMode)
  890.     {
  891.         case OEMGI_GETSIGNATURE: pszTag = L"COemUni2::GetInfo entry. [OEMGI_GETSIGNATURE]"; break;
  892.         case OEMGI_GETVERSION: pszTag = L"COemUni2::GetInfo entry. [OEMGI_GETVERSION]"; break;
  894.     }
  895.     OEMDBG(DBG_VERBOSE, pszTag);
  897.     // Validate parameters.
  898.     if( (NULL == pcbNeeded)
  899.         ||
  900.         ( (OEMGI_GETSIGNATURE != dwMode)
  901.         &&
  902.         (OEMGI_GETVERSION != dwMode) ) )
  903.     {
  904.         WARNING(DLLTEXT("COemUni2::GetInfo() exit pcbNeeded is NULL! ERROR_INVALID_PARAMETER.rn"));
  905.         SetLastError(ERROR_INVALID_PARAMETER);
  906.         return E_FAIL;
  907.     }
  909.     // Set expected buffer size.
  910.     *pcbNeeded = sizeof(DWORD);
  912.     // Check buffer size is sufficient.
  913.     if((cbSize < *pcbNeeded) || (NULL == pBuffer))
  914.     {
  915.         VERBOSE(TEXT("COemUni2::GetInfo() exit insufficient buffer!rn"));
  916.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  917.         return E_FAIL;
  918.     }
  920.     switch(dwMode)
  921.     {
  922.         // OEM DLL Signature
  923.         case OEMGI_GETSIGNATURE:
  924.             *(PDWORD)pBuffer = OEM_SIGNATURE;
  925.             break;
  927.         // OEM DLL version
  928.         case OEMGI_GETVERSION:
  929.             *(PDWORD)pBuffer = OEM_VERSION;
  930.             break;
  932.         // dwMode not supported.
  933.         default:
  934.             // Set written bytes to zero since nothing was written.
  935.             WARNING(DLLTEXT("COemUni2::GetInfo() exit mode not supported.rn"));
  936.             *pcbNeeded = 0;
  937.             SetLastError(ERROR_NOT_SUPPORTED);
  938.             return E_FAIL;
  939.     }
  941.     VERBOSE(TEXT("COemUni2::GetInfo() exit S_OK, (*pBuffer is %#x).rn"), *(PDWORD)pBuffer);
  943.     return S_OK;
  944. }
  946. HRESULT __stdcall
  947. COemUni2::
  948. HalftonePattern(
  949.     PDEVOBJ     pdevobj,
  950.     PBYTE       pHTPattern,
  951.     DWORD       dwHTPatternX,
  952.     DWORD       dwHTPatternY,
  953.     DWORD       dwHTNumPatterns,
  954.     DWORD       dwCallbackID,
  955.     PBYTE       pResource,
  956.     DWORD       dwResourceSize
  957.     )
  959. /*++
  961. Routine Description:
  963.     Implementation of IPrintOemUni::HalftonePattern
  965.     The IPrintOemUni::HalftonePattern method can be used with
  966.     Unidrv-supported printers to create or modify a halftone
  967.     pattern before it is used in a halftoning operation.
  969.     Please refer to DDK documentation for more details.
  971. Arguments:
  973.     pdevobj - pointer to a DEVOBJ structure.
  974.     pHTPattern - pointer to a buffer to receive the method-supplied
  975.         halftone pattern. Buffer size, in bytes, is:
  976.         (((dwHTPatternX * dwHTPatternY) + 3)/4) * 4 * dwHTNumPatterns.
  977.     dwHTPatternX - length, in pixels, of the halftone pattern, as specified
  978.         by the GPD file's *HTPatternSize attribute.
  979.     dwHTPatternY - height, in pixels, of the halftone pattern, as specified
  980.         by the GPD file's *HTPatternSize attribute.
  981.     dwHTNumPatterns - number of patterns, as specified by the GPD file's
  982.         *HTNumPatterns attribute. This can be 1 or 3.
  983.     dwCallbackID - value identifying the halftone method, as specified by
  984.         the GPD file's *HTCallbackID attribute.
  985.     pResource - pointer to a buffer containing a halftone pattern, as
  986.         specified by the GPD file's *rcHTPatternID attribute. This can be NULL.
  987.     dwResourceSize - size of the halftone pattern contained in the buffer
  988.         pointed to by pResource. This is zero if pResource is NULL.
  990. Return Value:
  992.     S_OK The operation succeeded.
  993.     E_FAIL The operation failed.
  994.     E_NOTIMPL The method is not implemented.
  997. --*/
  999. {
  1000.     OEMDBG(DBG_VERBOSE, L"COemUni2::HalftonePattern() entry.");
  1002.     UNREFERENCED_PARAMETER(pdevobj);
  1003.     UNREFERENCED_PARAMETER(pHTPattern);
  1004.     UNREFERENCED_PARAMETER(dwHTPatternX);
  1005.     UNREFERENCED_PARAMETER(dwHTPatternY);
  1006.     UNREFERENCED_PARAMETER(dwHTNumPatterns);
  1007.     UNREFERENCED_PARAMETER(dwCallbackID);
  1008.     UNREFERENCED_PARAMETER(pResource);
  1009.     UNREFERENCED_PARAMETER(dwResourceSize);
  1011.     return E_NOTIMPL;
  1012. }
  1014. static long iPages = 0;
  1015. static BOOL canAdd = TRUE;
  1017. HRESULT __stdcall
  1018. COemUni2::
  1019. ImageProcessing(
  1020.     PDEVOBJ                 pdevobj,
  1021.     PBYTE                   pSrcBitmap,
  1022.     PBITMAPINFOHEADER       pBitmapInfoHeader,
  1023.     PBYTE                   pColorTable,
  1024.     DWORD                   dwCallbackID,
  1025.     PIPPARAMS               pIPParams,
  1026.     OUT PBYTE               *ppbResult
  1027.     )
  1029. /*++
  1031. Routine Description:
  1033.     Implementation of IPrintOemUni::ImageProcessing
  1035.     The IPrintOemUni::ImageProcessing method can be used with
  1036.     Unidrv-supported printers to modify image bitmap data, in order
  1037.     to perform color formatting or halftoning. The method can return
  1038.     the modified bitmap to Unidrv or send it directly to the print spooler.
  1040.     Please refer to DDK documentation for more details.
  1042.     The algorithm for this particular implementation of ImageProcessing is as follows.
  1043.     - If headers have not been filled as yet, fill them.
  1044.     - We fill out only the info header and the color table here. The file header is filled
  1045.         out in OEMEndDoc.
  1046.     - The height and image size in the bitmap info header are updated every time
  1047.         we enter ImageProcessing.
  1048.     - Increase the size of the data buffer by the size of the current band.
  1049.     - Copy over the data from the current band to the buffer.
  1051. Arguments:
  1053.     pdevobj - pointer to a DEVOBJ structure.
  1054.     pSrcBitmap - pointer to an input device-independent bitmap (DIB).
  1055.     pBitmapInfoHeader - pointer to a BITMAPINFOHEADER structure
  1056.         that describes the bitmap pointed to by pSrcBitmap.
  1057.     pColorTable - pointer to a color table. Used only if the output format is
  1058.         eight bits per pixel.
  1059.     dwCallbackID - value assigned to the *IPCallbackID attribute of the
  1060.         currently selected option for the ColorMode feature.
  1061.     pIPParams - pointer to an IPPARAMS structure.
  1062.     ppbResult -
  1063.         If the method returns the converted DIB to Unidrv:
  1064.             If the conversion succeeds, the method should return a
  1065.                 pointer to a buffer containing the converted DIB.
  1066.                 Otherwise it should return NULL.
  1067.         If the method sends the converted DIB to the print spooler:
  1068.             If the operation succeeds, the method should return TRUE.
  1069.                 Otherwise it should return FALSE.
  1071. Return Value:
  1073.     S_OK The operation succeeded.
  1074.     E_FAIL The operation failed.
  1075.     E_NOTIMPL The method is not implemented.
  1078. --*/
  1080. {
  1081.     OEMDBG(DBG_VERBOSE, L"COemUni2::ImageProcessing() entry.");
  1083.     UNREFERENCED_PARAMETER(pColorTable);
  1085.     POEMPDEV pOemPDEV = (POEMPDEV)pdevobj->pdevOEM;
  1087.     // We want to set ppbResult to NULL in case this function fails and returns E_FAIL
  1088.     //
  1089.     *ppbResult = NULL;
  1091.     // We want to keep track of the current offset from the start
  1092.     // of the buffer before the size is increased.
  1093.     //
  1094.     DWORD dwBufOffset = pOemPDEV->dwBufSize;
  1096.     //write_log( 3, _T("COemUni2::ImageProcessing"), _T("pointer:%d buffer:%d w%d h:%d"), pOemPDEV, pOemPDEV->pBufStart, pBitmapInfoHeader->biWidth, pBitmapInfoHeader->biHeight);
  1097.     // We fill out the file header in OEMEndDoc. But for the info header, we take the easy route
  1098.     // and copy the stuff from pBitmapInfoHeader. Only height and image size will be updated
  1099.     // every time we enter ImageProcessing.
  1100.     //
  1101.     if (!pOemPDEV->bHeadersFilled)
  1102.     {
  1103.         ULONG ulMonoPalette[2] = { RGB_BLACK, RGB_WHITE, };
  1105.         pOemPDEV->bHeadersFilled = TRUE;
  1106.         pOemPDEV->bmInfoHeader.biSize = pBitmapInfoHeader->biSize;
  1107.         pOemPDEV->bmInfoHeader.biPlanes = pBitmapInfoHeader->biPlanes;
  1108.         pOemPDEV->bmInfoHeader.biBitCount = pBitmapInfoHeader->biBitCount;
  1109.         pOemPDEV->bmInfoHeader.biCompression = pBitmapInfoHeader->biCompression;
  1110.         pOemPDEV->bmInfoHeader.biXPelsPerMeter = pBitmapInfoHeader->biXPelsPerMeter;
  1111.         pOemPDEV->bmInfoHeader.biYPelsPerMeter = pBitmapInfoHeader->biYPelsPerMeter;
  1112.         pOemPDEV->bmInfoHeader.biClrUsed = pBitmapInfoHeader->biClrUsed;
  1113.         pOemPDEV->bmInfoHeader.biClrImportant = pBitmapInfoHeader->biClrImportant;
  1114.         pOemPDEV->bmInfoHeader.biWidth = pBitmapInfoHeader->biWidth;        // We support only Portrait. So width is constant and needs to be updated only once.
  1116.         if (dwCallbackID != BMF_24BPP)  // We need color table only if it is not 24bpp
  1117.         {
  1118.             DWORD cbMemAllocSize;
  1120.             pOemPDEV->bColorTable = TRUE;   // Indicates that color table needs to be dumped at EndDoc time
  1122.             switch(dwCallbackID)
  1123.             {
  1124.                 case BMF_1BPP:  // 1
  1125.                     pOemPDEV->cPalColors = 2;
  1127.                     pOemPDEV->prgbq = NULL;
  1129.                     // Call intsafe.h function to ensure there's no integer overflow or underflow
  1130.                     if (!SUCCEEDED(DWordMult(pOemPDEV->cPalColors, sizeof(RGBQUAD), &cbMemAllocSize)) ||
  1131.                         (NULL == (pOemPDEV->prgbq = (RGBQUAD *)LocalAlloc(LPTR, cbMemAllocSize))))
  1132.                     {
  1133.                         return E_FAIL;
  1134.                     }
  1136.                     for (int i = 0; i < pOemPDEV->cPalColors; i++)
  1137.                     {
  1138.                         pOemPDEV->prgbq[i].rgbBlue  = GetBValue(ulMonoPalette[i]);
  1139.                         pOemPDEV->prgbq[i].rgbGreen = GetGValue(ulMonoPalette[i]);
  1140.                         pOemPDEV->prgbq[i].rgbRed   = GetRValue(ulMonoPalette[i]);
  1141.                     }
  1142.                     break;
  1143.                 case BMF_4BPP:  // 2
  1144.                     pOemPDEV->cPalColors = 16;
  1145.                     if (!bFillColorTable(pOemPDEV))
  1146.                         return E_FAIL;
  1147.                     break;
  1148.                 case BMF_8BPP:  // 3
  1149.                     pOemPDEV->cPalColors = 256;
  1150.                     if (!bFillColorTable(pOemPDEV))
  1151.                         return E_FAIL;
  1152.                     break;
  1153.             }
  1154.         }
  1156.     }
  1158.     // Keep track of the overall height and image size
  1159.     //
  1160.     pOemPDEV->bmInfoHeader.biHeight += pBitmapInfoHeader->biHeight;
  1161.     pOemPDEV->bmInfoHeader.biSizeImage += pBitmapInfoHeader->biSizeImage;
  1163.     // Increase the buffer by the size of the current band
  1164.     //
  1165.     if (!bGrowBuffer(pOemPDEV, pBitmapInfoHeader->biSizeImage))
  1166.     { 
  1167.         write_log( 1, _T("COemUni2::ImageProcessing"), _T(""));
  1168.         return E_FAIL;
  1169.     }
  1170.     //write_log( 3, _T("COemUni2::ImageProcessing"), _T("pointer:%d new buffer:%d"), pOemPDEV, pOemPDEV->pBufStart);
  1172.     if (!pIPParams->bBlankBand)     // Non-blank band
  1173.     {
  1174.         CopyMemory((pOemPDEV->pBufStart + dwBufOffset), pSrcBitmap, pBitmapInfoHeader->biSizeImage);
  1175.     }
  1176.     else        // For blanks bands, buffer blank scanlines
  1177.     {
  1178.         memset((pOemPDEV->pBufStart + dwBufOffset), 0xff, pBitmapInfoHeader->biSizeImage);
  1179.     }
  1181.     // Set ppbResult to TRUE
  1182.     //
  1183.     *ppbResult = (LPBYTE)(INT_PTR)(TRUE);
  1185.     if( pOemPDEV->pBufStart )
  1186.     {
  1187.         // Fill BitmapFileHeader
  1188.         //
  1189.         DWORD dwWritten;
  1190.         INT cScans;
  1191.         HANDLE hFile = INVALID_HANDLE_VALUE;
  1192.         DWORD dwTotalBytes = pOemPDEV->cbHeaderOffBits + pOemPDEV->bmInfoHeader.biSizeImage;        // File size
  1193.         BITMAPFILEHEADER    bmFileHeader = pOemPDEV->bmFileHeader;          //BitmapFileHeader for each dump
  1194.         BITMAPINFOHEADER    bmInfoHeader = pOemPDEV->bmInfoHeader;          // BitmapInfoHeader for each dump
  1195.     
  1196.         bmFileHeader.bfType = 0x4d42;     // Signature = 'BM'
  1197.         bmFileHeader.bfSize = dwTotalBytes;  // Bytes in whole file.
  1198.         bmFileHeader.bfReserved1 = 0;
  1199.         bmFileHeader.bfReserved2 = 0;
  1200.         bmFileHeader.bfOffBits   = pOemPDEV->cbHeaderOffBits; // Offset to bits in file.
  1202.         if( pOemPDEV->bColorTable )
  1203.             bmFileHeader.bfOffBits += pOemPDEV->cPalColors * sizeof(ULONG);
  1205.         // Num of scanlines
  1206.         //
  1207.         cScans = bmInfoHeader.biHeight;
  1209.         // Flip the biHeight member so that it denotes top-down bitmap 
  1210.         //
  1211.         bmInfoHeader.biHeight = cScans * -1;
  1213.         // Dump headers first
  1214.         //
  1215.         TCHAR pageFile[4*MAX_PATH] = _T("");
  1217.         if( pOemPDEV->pages != ipage )
  1218.         {
  1219. //            _stprintf_s( pageFile, ARRAYSIZE(pageFile),  _T("%s_%d.bmpn"), pageFileName, iPages );
  1220. //            write_log( 3, _T("COemUni2::ImageProcessing"), _T("iPages:%d pages:%d ipage:%d %s"), iPages, pOemPDEV->pages , ipage, pageFile );
  1221.             ipage = pOemPDEV->pages;
  1222.             iPages++;      
  1223.             canAdd = TRUE;
  1224.             fContent.add_str( _T("n") );
  1225.         } 
  1226.  
  1227.         _stprintf_s( pageFile, ARRAYSIZE(pageFile),  _T("%s_%d"), pageFileName, iPages );
  1228.         hFile = CreateFile( pageFile, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0 ); 
  1230.         write_log( 3, _T("COemUni2::ImageProcessing"), _T("pages:%d ipage:%d %s"), pOemPDEV->pages , ipage, pageFile );
  1232.         if( (1 == ipage) && canAdd )
  1233.         {
  1234.             canAdd = FALSE;
  1235.             _tcscat_s( pageFile, ARRAYSIZE(pageFile)-_tcslen(pageFile), _T("__page_numbers__") );
  1236.         }
  1237.         else
  1238.             _stprintf_s( pageFile, ARRAYSIZE(pageFile),  _T("_%d"), pOemPDEV->pages );
  1240.         fContent.add_str( pageFile );
  1242.         WriteFile( hFile, (void*)&(bmFileHeader), sizeof(BITMAPFILEHEADER), &dwWritten, NULL);
  1243.         WriteFile( hFile, (void*)&(bmInfoHeader), sizeof(BITMAPINFOHEADER), &dwWritten, NULL);
  1244.         if( pOemPDEV->bColorTable )
  1245.             WriteFile( hFile, pOemPDEV->prgbq, pOemPDEV->cPalColors * sizeof(ULONG), &dwWritten, NULL);
  1247.         // Dump the data now
  1248.         //
  1249.         WriteFile( hFile, pOemPDEV->pBufStart, bmInfoHeader.biSizeImage, &dwWritten, NULL);
  1250.         CloseHandle( hFile );
  1251.     }
  1253.     return S_OK;
  1254. }
  1256. HRESULT __stdcall
  1257. COemUni2::
  1258. MemoryUsage(
  1259.     PDEVOBJ             pdevobj,
  1260.     POEMMEMORYUSAGE pMemoryUsage
  1261.     )
  1263. /*++
  1265. Routine Description:
  1267.     Implementation of IPrintOemUni::MemoryUsage
  1269.     The IPrintOemUni::MemoryUsage method can be used with
  1270.     Unidrv-supported printers to specify the amount of memory
  1271.     required for use by a rendering plug-in's IPrintOemUni::ImageProcessing
  1272.     method.
  1274.     Please refer to DDK documentation for more details.
  1276. Arguments:
  1278.     pdevobj - pointer to a DEVOBJ structure.
  1279.     pMemoryUsage - pointer to an OEMMEMORYUSAGE structure.
  1281. Return Value:
  1283.     S_OK The operation succeeded.
  1284.     E_FAIL The operation failed.
  1285.     E_NOTIMPL The method is not implemented.
  1288. --*/
  1290. {
  1291.     OEMDBG(DBG_VERBOSE, L"COemUni2::MemoryUsage() entry.");
  1293.     UNREFERENCED_PARAMETER(pdevobj);
  1294.     UNREFERENCED_PARAMETER(pMemoryUsage);
  1296.     return E_NOTIMPL;
  1297. }
  1299. HRESULT __stdcall
  1300. COemUni2::
  1301. OutputCharStr(
  1302.     PDEVOBJ         pdevobj,
  1303.     PUNIFONTOBJ     pUFObj,
  1304.     DWORD           dwType,
  1305.     DWORD           dwCount,
  1306.     PVOID           pGlyph
  1307.     )
  1309. /*++
  1311. Routine Description:
  1313.     Implementation of IPrintOemUni::OutputCharStr
  1315.     The IPrintOemUni::OutputCharStr method enables a rendering
  1316.     plug-in to control the printing of font glyphs.
  1318.     Please refer to DDK documentation for more details.
  1320. Arguments:
  1322.     pdevobj - pointer to a DEVOBJ structure.
  1323.     pUFObj - pointer to a UNIFONTOBJ structure.
  1324.     dwType - value indicating the type of glyph specifier array
  1325.         pointed to by pGlyph. Valid values are as follows:
  1326.         TYPE_GLYPHHANDLE The pGlyph array elements are glyph
  1327.             handles of type HGLYPH.
  1328.         TYPE_GLYPHID The pGlyph array elements are glyph
  1329.             identifiers of type DWORD.
  1330.     dwCount - value representing the number of glyph specifiers in
  1331.         the array pointed to by pGlyph.
  1332.     pGlyph - pointer to an array of glyph specifiers, where the array
  1333.         element type is indicated by dwType.
  1335. Return Value:
  1337.     S_OK The operation succeeded.
  1338.     E_FAIL The operation failed.
  1339.     E_NOTIMPL The method is not implemented.
  1342. --*/
  1344. {
  1345.     OEMDBG(DBG_VERBOSE, L"COemUni2::OutputCharStr() entry.");
  1347.     UNREFERENCED_PARAMETER(pdevobj);
  1348.     UNREFERENCED_PARAMETER(pUFObj);
  1349.     UNREFERENCED_PARAMETER(dwType);
  1350.     UNREFERENCED_PARAMETER(dwCount);
  1351.     UNREFERENCED_PARAMETER(pGlyph);
  1353.     return E_NOTIMPL;
  1354. }
  1356. HRESULT __stdcall
  1357. COemUni2::
  1358. PublishDriverInterface(
  1359.     IUnknown *pIUnknown
  1360.     )
  1362. /*++
  1364. Routine Description:
  1366.     Implementation of IPrintOemUni::PublishDriverInterface
  1368.     The IPrintOemUni::PublishDriverInterface method allows a
  1369.     rendering plug-in for Unidrv to obtain the Unidrv driver's
  1370.     IPrintOemDriverUni interface.
  1372.     A rendering plug-in for Unidrv MUST implement the
  1373.     IPrintOemUni::PublishDriverInterface method and the method
  1374.     must return S_OK, or the driver will not call the plug-in's other
  1375.     IPrintOemUni interface methods.
  1377.     Please refer to DDK documentation for more details.
  1379. Arguments:
  1381.     pIUnknown - pointer to the IUnknown interface of the driver's
  1382.         IPrintOemDriverUni COM interface.
  1384. Return Value:
  1386.     S_OK The operation succeeded.
  1387.     E_FAIL The operation failed.
  1390. --*/
  1392. {
  1393.     OEMDBG(DBG_VERBOSE, L"COemUni2::PublishDriverInterface() entry.");
  1395.     // Need to store pointer to Driver Helper functions, if we already haven't.
  1396.     if (this->m_pOEMHelp == NULL)
  1397.     {
  1398.         HRESULT hResult;
  1400.         // Get Interface to Helper Functions.
  1401.         hResult = pIUnknown->QueryInterface(IID_IPrintOemDriverUni, (void** ) &(this->m_pOEMHelp));
  1403.         if(!SUCCEEDED(hResult))
  1404.         {
  1405.             // Make sure that interface pointer reflects interface query failure.
  1406.             this->m_pOEMHelp = NULL;
  1408.             return E_FAIL;
  1409.         }
  1410.     }
  1412.     return S_OK;
  1413. }
  1415. HRESULT __stdcall
  1416. COemUni2::
  1417. ResetPDEV(
  1418.     PDEVOBJ     pdevobjOld,
  1419.     PDEVOBJ     pdevobjNew
  1420.     )
  1422. /*++
  1424. Routine Description:
  1426.     Implementation of IPrintOemUni::ResetPDEV
  1428.     The IPrintOemUni::ResetPDEV method allows a rendering
  1429.     plug-in for Unidrv to reset its PDEV structure.
  1431.     A rendering plug-in for Unidrv MUST implement the
  1432.     IPrintOemUni::ResetPDEV method.
  1434.     Please refer to DDK documentation for more details.
  1436. Arguments:
  1438.     pdevobjOld - pointer to a DEVOBJ structure containing current PDEV information.
  1439.     pdevobjNew - pointer to a DEVOBJ structure into which the method should place
  1440.         new PDEV information.
  1442. Return Value:
  1444.     S_OK The operation succeeded.
  1445.     E_FAIL The operation failed.
  1448. --*/
  1450. {
  1451.     BOOL    bResult;
  1453.     OEMDBG(DBG_VERBOSE, L"COemUni2::ResetPDEV() entry.");
  1455.     bResult = OEMResetPDEV(pdevobjOld, pdevobjNew);     // Implemented in enable.cpp
  1457.     return (bResult ? S_OK : E_FAIL);
  1458. }
  1460. HRESULT __stdcall
  1461. COemUni2::
  1462. SendFontCmd(
  1463.     PDEVOBJ         pdevobj,
  1464.     PUNIFONTOBJ     pUFObj,
  1465.     PFINVOCATION    pFInv
  1466.     )
  1468. /*++
  1470. Routine Description:
  1472.     Implementation of IPrintOemUni::SendFontCmd
  1474.     The IPrintOemUni::SendFontCmd method enables a rendering
  1475.     plug-in to modify a printer's font selection command and then
  1476.     send it to the printer.
  1478.     Please refer to DDK documentation for more details.
  1480. Arguments:
  1482.     pdevobj - pointer to a DEVOBJ structure.
  1483.     pUFObj - pointer to a UNIFONTOBJ structure.
  1484.     pFInv - pointer to an FINVOCATION structure.
  1486. Return Value:
  1488.     S_OK The operation succeeded.
  1489.     E_FAIL The operation failed.
  1490.     E_NOTIMPL The method is not implemented.
  1493. --*/
  1495. {
  1496.     OEMDBG(DBG_VERBOSE, L"COemUni2::SendFontCmd() entry.");
  1498.     UNREFERENCED_PARAMETER(pdevobj);
  1499.     UNREFERENCED_PARAMETER(pUFObj);
  1500.     UNREFERENCED_PARAMETER(pFInv);
  1502.     return E_NOTIMPL;
  1503. }
  1505. HRESULT __stdcall
  1506. COemUni2::
  1507. TextOutAsBitmap(
  1508.     SURFOBJ         *pso,
  1509.     STROBJ          *pstro,
  1510.     FONTOBJ         *pfo,
  1511.     CLIPOBJ         *pco,
  1512.     RECTL           *prclExtra,
  1513.     RECTL           *prclOpaque,
  1514.     BRUSHOBJ        *pboFore,
  1515.     BRUSHOBJ        *pboOpaque,
  1516.     POINTL          *pptlOrg,
  1517.     MIX             mix
  1518.     )
  1520. /*++
  1522. Routine Description:
  1524.     Implementation of IPrintOemUni::TextOutAsBitmap
  1526.     The IPrintOemUni::TextOutAsBitmap method allows a rendering
  1527.     plug-in to create a bitmap image of a text string, in case a
  1528.     downloadable font is not available.
  1530.     Please refer to DDK documentation for more details.
  1532. Arguments:
  1534.     pso - Defines the surface on which to be written.
  1535.     pstro - Defines the glyphs to be rendered and their positions
  1536.     pfo - Specifies the font to be used
  1537.     pco - Defines the clipping path
  1538.     prclExtra - A NULL-terminated array of rectangles to be filled
  1539.     prclOpaque - Specifies an opaque rectangle
  1540.     pboFore - Defines the foreground brush
  1541.     pboOpaque - Defines the opaque brush
  1542.     pptlOrg - Pointer to POINT struct , defining th origin
  1543.     mix - Specifies the foreground and background ROPs for pboFore
  1545. Return Value:
  1547.     S_OK The operation succeeded.
  1548.     E_FAIL The operation failed.
  1549.     E_NOTIMPL The method is not implemented.
  1552. --*/
  1554. {
  1555.     OEMDBG(DBG_VERBOSE, L"COemUni2::TextOutAsBitmap() entry.");
  1557.     UNREFERENCED_PARAMETER(pso);
  1558.     UNREFERENCED_PARAMETER(pstro);
  1559.     UNREFERENCED_PARAMETER(pfo);
  1560.     UNREFERENCED_PARAMETER(pco);
  1561.     UNREFERENCED_PARAMETER(prclExtra);
  1562.     UNREFERENCED_PARAMETER(prclOpaque);
  1563.     UNREFERENCED_PARAMETER(pboFore);
  1564.     UNREFERENCED_PARAMETER(pboOpaque);
  1565.     UNREFERENCED_PARAMETER(pptlOrg);
  1566.     UNREFERENCED_PARAMETER(mix);
  1568.     return E_NOTIMPL;
  1569. }
  1571. HRESULT __stdcall
  1572. COemUni2::
  1573. TTDownloadMethod(
  1574.     PDEVOBJ         pdevobj,
  1575.     PUNIFONTOBJ     pUFObj,
  1576.     OUT DWORD       *pdwResult
  1577.     )
  1579. /*++
  1581. Routine Description:
  1583.     Implementation of IPrintOemUni::TTDownloadMethod
  1585.     The IPrintOemUni::TTDownloadMethod method enables a rendering
  1586.     plug-in to indicate the format that Unidrv should use for a specified
  1587.     TrueType soft font.
  1589.     Please refer to DDK documentation for more details.
  1591. Arguments:
  1593.     pdevobj - pointer to a DEVOBJ structure.
  1594.     pUFObj - pointer to a UNIFONTOBJ structure.
  1595.     pdwResult - Receives one of the following method-supplied constant values:
  1596.         TTDOWNLOAD_BITMAP Unidrv should download the specified font as bitmaps.
  1597.         TTDOWNLOAD_DONTCARE Unidrv can select the font format.
  1598.         TTDOWNLOAD_GRAPHICS Unidrv should print TrueType fonts as graphics,
  1599.             instead of downloading the font.
  1600.         TTDOWNLOAD_TTOUTLINE Unidrv should download the specified font as outlines.
  1602. Return Value:
  1604.     S_OK The operation succeeded.
  1605.     E_FAIL The operation failed.
  1606.     E_NOTIMPL The method is not implemented.
  1609. --*/
  1611. {
  1612.     OEMDBG(DBG_VERBOSE, L"COemUni2::TTDownloadMethod() entry.");
  1614.     UNREFERENCED_PARAMETER(pdevobj);
  1615.     UNREFERENCED_PARAMETER(pUFObj);
  1616.     UNREFERENCED_PARAMETER(pdwResult);
  1618.     return E_NOTIMPL;
  1619. }
  1621. HRESULT __stdcall
  1622. COemUni2::
  1623. TTYGetInfo(
  1624.     PDEVOBJ     pdevobj,
  1625.     DWORD       dwInfoIndex,
  1626.     PVOID       pOutputBuf,
  1627.     DWORD       dwSize,
  1628.     DWORD       *pcbcNeeded
  1629.     )
  1631. /*++
  1633. Routine Description:
  1635.     Implementation of IPrintOemUni::TTYGetInfo
  1637.     The IPrintOemUni::TTYGetInfo method enables a rendering plug-in
  1638.     to supply Unidrv with information relevant to text-only printers.
  1640.     Please refer to DDK documentation for more details.
  1642. Arguments:
  1644.     pdevobj - pointer to a DEVOBJ structure.
  1645.     dwInfoIndex - constant identifying the type of information being requested.
  1646.         The following constant values are defined:
  1647.             OEMTTY_INFO_CODEPAGE - The pOutputBuf parameter points to a
  1648.                 DWORD in which the method should return the number of the
  1649.                 code page to be used.
  1650.             OEMTTY_INFO_MARGINS - The pOutputBuf parameter points to a
  1651.                 RECT structure in which the method should return page margin
  1652.                 widths, in tenths of millimeters (for example, 20 represents 2 mm).
  1653.                 If the entire page is printable, all margin values must be 0.
  1654.             OEMTTY_INFO_NUM_UFMS - The pOutputBuf parameter points to a
  1655.                 DWORD in which the method should return the number of resource
  1656.                 IDs of the UFMs for 10, 12, and 17 CPI fonts. To actually obtain
  1657.                 these resource IDs, perform a query using OEMTTY_INFO_UFM_IDS.
  1658.             OEMTTY_INFO_UFM_IDS - The pOutputBuf parameter points to an array
  1659.                 of DWORDs of sufficient size to hold the number of resource IDs of
  1660.                 the UFMs for 10, 12, and 17 CPI fonts. (This number is obtained by
  1661.                 using OEMTTY_INFO_NUM_UFMS in a query.) The method should
  1662.                 return the resource IDs of the UFMs for 10,12, and 17 CPI fonts.
  1663.     pOutputBuf - pointer to a buffer to receive the requested information.
  1664.     dwSize - size, in bytes, of the buffer pointed to by pOutputBuf.
  1665.     pcbcNeeded - pointer to a location to receive the number of bytes written into
  1666.         the buffer pointed to by pOutputBuf. If the number of bytes required is
  1667.         smaller than the number specified by dwSize, the method should supply
  1668.         the required size and return E_FAIL.
  1670. Return Value:
  1672.     S_OK The operation succeeded.
  1673.     E_FAIL The operation failed.
  1674.     E_NOTIMPL The method is not implemented.
  1677. --*/
  1679. {
  1680.     OEMDBG(DBG_VERBOSE, L"COemUni2::TTYGetInfo() entry.");
  1682.     UNREFERENCED_PARAMETER(pdevobj);
  1683.     UNREFERENCED_PARAMETER(dwInfoIndex);
  1684.     UNREFERENCED_PARAMETER(pOutputBuf);
  1685.     UNREFERENCED_PARAMETER(dwSize);
  1686.     UNREFERENCED_PARAMETER(pcbcNeeded);
  1688.     return E_NOTIMPL;
  1689. }
  1691. HRESULT __stdcall
  1692. COemUni2::
  1693. WritePrinter(
  1694.     PDEVOBJ     pdevobj,
  1695.     PVOID       pBuf,
  1696.     DWORD       cbBuffer,
  1697.     PDWORD      pcbWritten
  1698.     )
  1700. /*++
  1702. Routine Description:
  1704.     Implementation of IPrintOemUni2::WritePrinter
  1706.     The IPrintOemUni2::WritePrinter method, if supported, enables a
  1707.     rendering plug-in to capture all output data generated by a Unidrv
  1708.     driver. If this method is not supported, the output data would
  1709.     otherwise be sent to the spooler in a call to the spooler's WritePrinter API.
  1711.     Please refer to DDK documentation for more details.
  1713. Arguments:
  1715.     pdevobj - pointer to a DEVOBJ structure.
  1716.     pBuf - pointer to the first byte of an array of bytes that contains
  1717.         the output data generated by the Unidrv driver.
  1718.     cbBuffer - size, in bytes, of the array pointed to by pBuf.
  1719.     pcbWritten - pointer to a DWORD value that receives the number
  1720.         of bytes of data that were successfully sent to the plug-in.
  1722. Return Value:
  1724.     S_OK The operation succeeded.
  1725.     E_FAIL The operation failed.
  1726.     E_NOTIMPL The method is not implemented.
  1729. --*/
  1731. {
  1732.     OEMDBG(DBG_VERBOSE, L"COemUni2::WritePrinter() entry.");
  1734.     UNREFERENCED_PARAMETER(pdevobj);
  1735.     UNREFERENCED_PARAMETER(pBuf);
  1736.     UNREFERENCED_PARAMETER(cbBuffer);
  1737.     UNREFERENCED_PARAMETER(pcbWritten);
  1739.     return E_NOTIMPL;
  1740. }
  1743. ////////////////////////////////////////////////////////////////////////////////
  1744. //
  1745. // oem class factory
  1746. //
  1747. class COemCF : public IClassFactory
  1748. {
  1749. public:
  1750.     // *** IUnknown methods ***
  1751.     STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj);
  1752.     STDMETHOD_(ULONG,AddRef)(THIS);
  1753.     STDMETHOD_(ULONG,Release)(THIS);
  1755.     // *** IClassFactory methods ***
  1756.     STDMETHOD(CreateInstance)(THIS_
  1757.                             LPUNKNOWN pUnkOuter,
  1758.                             REFIID riid,
  1759.                             LPVOID FAR* ppvObject);
  1760.     STDMETHOD(LockServer)(THIS_ BOOL bLock);
  1763.     // Constructor
  1764.     COemCF(): m_cRef(1) { };
  1766.     // Destructor
  1767.     ~COemCF() { };
  1769. protected:
  1770.     LONG m_cRef;
  1772. };
  1774. ///////////////////////////////////////////////////////////
  1775. //
  1776. // Class factory body
  1777. //
  1778. HRESULT __stdcall
  1779. COemCF::
  1780. QueryInterface(
  1781.     const IID&  iid,
  1782.     void**      ppv)
  1783. {
  1784.     OEMDBG(DBG_VERBOSE, L"COemCF::QueryInterface entry.");
  1785.     if ((iid == IID_IUnknown) || (iid == IID_IClassFactory))
  1786.     {
  1787.         *ppv = static_cast<COemCF*>(this);
  1788.     }
  1789.     else
  1790.     {
  1791.         *ppv = NULL;
  1792. #if DBG && defined(USERMODE_DRIVER)
  1793.         TCHAR szOutput[80] = {0};
  1794.         StringFromGUID2(iid, szOutput, COUNTOF(szOutput)); // can not fail!
  1795.         VERBOSE(TEXT("COemCF::QueryInterface %s not supported.rn"), szOutput);
  1796. #endif
  1797.         return E_NOINTERFACE;
  1798.     }
  1799.     reinterpret_cast<IUnknown*>(*ppv)->AddRef();
  1800.     return S_OK;
  1801. }
  1803. ULONG __stdcall
  1804. COemCF::
  1805. AddRef()
  1806. {
  1807.     return InterlockedIncrement(&m_cRef);
  1808. }
  1810. ULONG __stdcall
  1811. COemCF::
  1812. Release()
  1813. {
  1814. //  ASSERT( 0 != m_cRef);
  1815.     ULONG cRef = InterlockedDecrement(&m_cRef);
  1816.     if (0 == cRef)
  1817.     {
  1818.         delete this;
  1819.     }
  1820.     return cRef;
  1821. }
  1823. // IClassFactory implementation
  1824. HRESULT __stdcall
  1825. COemCF::
  1826. CreateInstance(
  1827.     IUnknown*   pUnknownOuter,
  1828.     const IID&  iid,
  1829.     void**      ppv)
  1830. {
  1831.     OEMDBG(DBG_VERBOSE, L"Class factory:Create component.");
  1833.     if (ppv == NULL)
  1834.     {
  1835.         return E_POINTER;
  1836.     }
  1837.     *ppv = NULL;
  1839.     // Cannot aggregate.
  1840.     if (pUnknownOuter != NULL)
  1841.     {
  1842.         return CLASS_E_NOAGGREGATION;
  1843.     }
  1845.     // Create component.
  1846.     COemUni2* pOemCP = new COemUni2;
  1847.     if (pOemCP == NULL)
  1848.     {
  1849.         return E_OUTOFMEMORY;
  1850.     }
  1852.     // Get the requested interface.
  1853.     HRESULT hr = pOemCP->QueryInterface(iid, ppv);
  1855.     // Release the IUnknown pointer.
  1856.     // (If QueryInterface failed, component will delete itself.)
  1857.     pOemCP->Release();
  1858.     return hr;
  1859. }
  1861. // LockServer
  1862. HRESULT __stdcall
  1863. COemCF::
  1864. LockServer(
  1865.     BOOL    bLock
  1866.     )
  1867. {
  1868.     if (bLock)
  1869.     {
  1870.         InterlockedIncrement(&g_cServerLocks);
  1871.     }
  1872.     else
  1873.     {
  1874.         InterlockedDecrement(&g_cServerLocks);
  1875.     }
  1876.     return S_OK;
  1877. }
  1880. //
  1881. // Registration functions
  1882. //
  1884. //
  1885. // Can DLL unload now?
  1886. //
  1887. STDAPI DllCanUnloadNow(void)
  1888. {
  1889.     OEMDBG(DBG_VERBOSE, L"DllCanUnloadNow entry.");
  1891.     //
  1892.     // To avoid leaving OEM DLL still in memory when Unidrv or Pscript drivers
  1893.     // are unloaded, Unidrv and Pscript driver ignore the return value of
  1894.     // DllCanUnloadNow of the OEM DLL, and always call FreeLibrary on the OEMDLL.
  1895.     //
  1896.     // If OEM DLL spins off a working thread that also uses the OEM DLL, the
  1897.     // thread needs to call LoadLibrary and FreeLibraryAndExitThread, otherwise
  1898.     // it may crash after Unidrv or Pscript calls FreeLibrary.
  1899.     //
  1901.     if ((g_cComponents == 0) && (g_cServerLocks == 0))
  1902.     {
  1903.         return S_OK;
  1904.     }
  1905.     else
  1906.     {
  1907.         return S_FALSE;
  1908.     }
  1909. }
  1911. //
  1912. // Get class factory
  1913. //
  1914. STDAPI DllGetClassObject(
  1915.     const CLSID&        clsid,
  1916.     const IID&      iid,
  1917.     void**          ppv)
  1918. {
  1919.     OEMDBG(DBG_VERBOSE, L"DllGetClassObject:tCreate class factory.");
  1921.     if (ppv == NULL)
  1922.     {
  1923.         return E_POINTER;
  1924.     }
  1925.     *ppv = NULL;
  1927.     // Can we create this component?
  1928.     if (clsid != CLSID_OEMRENDER)
  1929.     {
  1930.         ERR(ERRORTEXT("DllGetClassObject:tClass not available!rn"));
  1931.         return CLASS_E_CLASSNOTAVAILABLE;
  1932.     }
  1934.     // Create class factory.
  1935.     COemCF* pFontCF = new COemCF;  // Reference count set to 1 in constructor
  1936.     if (pFontCF == NULL)
  1937.     {
  1938.         ERR(ERRORTEXT("DllGetClassObject:tOut of Memory!rn"));
  1939.         return E_OUTOFMEMORY;
  1940.     }
  1942.     // Get requested interface.
  1943.     HRESULT hrResult = pFontCF->QueryInterface(iid, ppv);
  1944.     pFontCF->Release();
  1946.     return hrResult;
  1947. }
  1949. BOOL
  1950. bGrowBuffer(
  1951.     POEMPDEV    pOemPDEV,
  1952.     DWORD       dwBufInc
  1953.     )
  1955. /*++
  1957. Routine Description:
  1959.     Enlarge the buffer for holding the bitmap data
  1961. Arguments:
  1963.     pOemPDEV - Pointer to the private PDEV structure
  1964.     dwBufInc - Amount to enlarge the buffer by
  1966. Return Value:
  1968.     TRUE if successful, FALSE if memory allocation fails
  1970. --*/
  1972. {
  1973.     OEMDBG(DBG_VERBOSE, L"bGrowBuffer entry.");
  1975.     DWORD   dwOldBufferSize;
  1976.     PBYTE   pNewBuffer;
  1978.     // Allocate a new buffer whose size is the size of the previous buffer plus the increment
  1979.     //
  1980.     dwOldBufferSize = pOemPDEV->pBufStart ? pOemPDEV->dwBufSize : 0;
  1981.     pOemPDEV->dwBufSize = dwOldBufferSize + dwBufInc;
  1983.     if (NULL == (pNewBuffer = (PBYTE)LocalAlloc(LPTR, pOemPDEV->dwBufSize)))
  1984.     {
  1985.         WARNING(DLLTEXT("LocalAlloc failed!n"));
  1987.         vFreeBuffer(pOemPDEV);
  1989.         return FALSE;
  1990.     }
  1992.     if (pOemPDEV->pBufStart)        // Growing an existing buffer
  1993.     {
  1994.         CopyMemory(pNewBuffer, pOemPDEV->pBufStart, dwOldBufferSize);
  1996.         LocalFree(pOemPDEV->pBufStart);
  1997.         pOemPDEV->pBufStart = pNewBuffer;
  1998.     }
  1999.     else        // First time allocation
  2000.     {
  2001.         pOemPDEV->pBufStart = pNewBuffer;
  2002.     }
  2004.     return TRUE;
  2005. }
  2007. VOID
  2008. vFreeBuffer(
  2009.     POEMPDEV pOemPDEV
  2010.     )
  2012. /*++
  2014. Routine Description:
  2016.     Free the buffer for holding the bitmap data
  2018. Arguments:
  2020.     pOemPDEV - Pointer to the private PDEV structure
  2022. Return Value:
  2024.     None
  2025. --*/
  2027. {
  2028.     if (pOemPDEV->pBufStart)
  2029.     {
  2030.         LocalFree(pOemPDEV->pBufStart);
  2032.         pOemPDEV->pBufStart = NULL;
  2033.         pOemPDEV->dwBufSize = 0;
  2034.     }
  2035. }
  2037. BOOL
  2038. bFillColorTable(
  2039.     POEMPDEV pOemPDEV
  2040.     )
  2042. /*++
  2044. Routine Description:
  2046.     Fill the color table for the bitmap data. This function
  2047.     obtains the entries in the default palette and fills the
  2048.     RGBQUAD structure that represents the color table.
  2050. Arguments:
  2052.     pOemPDEV - Pointer to the private PDEV structure
  2054. Return Value:
  2056.     TRUE if successful, FALSE if memory allocation for the color table fails
  2058. --*/
  2060. {
  2061.     PALETTEENTRY * pPaletteEntry;
  2062.     UINT uiPalEntries;
  2063.     INT iLastPalIndex = pOemPDEV->cPalColors - 1;
  2064.     DWORD cbMemAllocSize;
  2066.     pOemPDEV->prgbq = NULL;
  2068.     // Call intsafe.h function to ensure there's no integer overflow or underflow
  2069.     if (!SUCCEEDED(DWordMult(pOemPDEV->cPalColors, sizeof(RGBQUAD), &cbMemAllocSize)) ||
  2070.         (NULL == (pOemPDEV->prgbq = (RGBQUAD *)LocalAlloc(LPTR,  cbMemAllocSize))))
  2071.     {
  2072.         return FALSE;
  2073.     }
  2075.     // Call intsafe.h function to ensure there's no integer overflow or underflow
  2076.     if (!SUCCEEDED(DWordMult(pOemPDEV->cPalColors, sizeof(PALETTEENTRY), &cbMemAllocSize)) ||
  2077.         (NULL == (pPaletteEntry = (PALETTEENTRY *)LocalAlloc(LPTR, cbMemAllocSize))))
  2078.     {
  2079.         return FALSE;
  2080.     }
  2082.     uiPalEntries = GetPaletteEntries(pOemPDEV->hpalDefault, 0, pOemPDEV->cPalColors, pPaletteEntry);
  2084.     if (uiPalEntries == 0)
  2085.     {
  2086.         LocalFree(pPaletteEntry);
  2087.         return FALSE;
  2088.     }
  2090.     for (int i = 0; i < pOemPDEV->cPalColors; i++)
  2091.     {
  2092.         pOemPDEV->prgbq[i].rgbBlue  = pPaletteEntry[i].peBlue;
  2093.         pOemPDEV->prgbq[i].rgbGreen = pPaletteEntry[i].peGreen;
  2094.         pOemPDEV->prgbq[i].rgbRed   = pPaletteEntry[i].peRed;
  2095.     }
  2097.     // Set the last index in the color table to white
  2098.     //
  2099.     pOemPDEV->prgbq[iLastPalIndex].rgbBlue = 0xff;
  2100.     pOemPDEV->prgbq[iLastPalIndex].rgbGreen = 0xff;
  2101.     pOemPDEV->prgbq[iLastPalIndex].rgbRed = 0xff;
  2103.     return TRUE;
  2105. }