/*
 * Function: IOEMUni::ResetPDEV
 *
 * Purpose: Reset PDEV structure.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::ResetPDEV(
	PDEVOBJ        pdevobjOld,
	PDEVOBJ        pdevobjNew)
{
	TERSE(UNITEXT("IOEMUni::ResetPDEV() entry.\r\n"));

	BOOL bResult = OEMResetPDEV(pdevobjOld, pdevobjNew);

	return (bResult ? S_OK : E_FAIL);
}


// *** NOT implemented methods ***

/*
 * Function: IOEMUni::CommandCallback
 *
 * Purpose: Dynamically generate printer commands for printers.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::CommandCallback(
    PDEVOBJ     pdevobj,
    DWORD       dwCallbackID,
    DWORD       dwCount,
    PDWORD      pdwParams,
    OUT INT     *piResult)
{
	VERBOSE(UNITEXT("IOEMUni::CommandCallback() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::Compression
 *
 * Purpose: Provide a customized bitmap compression method.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::Compression(
    PDEVOBJ     pdevobj,
    PBYTE       pInBuf,
    PBYTE       pOutBuf,
    DWORD       dwInLen,
    DWORD       dwOutLen,
    OUT INT     *piResult)
{
	VERBOSE(UNITEXT("IOEMUni::Compression() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::DownloadCharGlyph
 *
 * Purpose: Send a character glyph for a specified soft font to the printer.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::DownloadCharGlyph(
    PDEVOBJ     pdevobj,
    PUNIFONTOBJ pUFObj,
    HGLYPH      hGlyph,
    PDWORD      pdwWidth,
    OUT DWORD   *pdwResult) 
{
	VERBOSE(UNITEXT("IOEMUni::DownloadCharGlyph() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::DownloadFontHeader
 *
 * Purpose: Send a font's header information to printer.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::DownloadFontHeader(
    PDEVOBJ     pdevobj,
    PUNIFONTOBJ pUFObj,
    OUT DWORD   *pdwResult) 
{
	VERBOSE(UNITEXT("IOEMUni::DownloadFontHeader() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::FilterGraphics
 *
 * Purpose: Modify scan line data and send it to the spooler.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::FilterGraphics(
    PDEVOBJ     pdevobj,
    PBYTE       pBuf,
    DWORD       dwLen)
{
	VERBOSE(UNITEXT("IOEMUni::FilterGraphis() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::HalftonePattern
 *
 * Purpose: Create or modify a halftone pattern before it is used in
 *		   a halftoning operation.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::HalftonePattern(
    PDEVOBJ     pdevobj,
    PBYTE       pHTPattern,
    DWORD       dwHTPatternX,
    DWORD       dwHTPatternY,
    DWORD       dwHTNumPatterns,
    DWORD       dwCallbackID,
    PBYTE       pResource,
    DWORD       dwResourceSize)
{
	VERBOSE(UNITEXT("IOEMUni::HalftonePattern() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::MemoryUsage
 *
 * Purpose: Specify the amount of memory required for use by
 *		    IPrintOemUni::ImageProcessing method.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::MemoryUsage(
    PDEVOBJ         pdevobj,
    POEMMEMORYUSAGE pMemoryUsage)
{
	VERBOSE(UNITEXT("IOEMUni::MemoryUsage() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::OutputCharStr
 *
 * Purpose: Control the printing of font glyphs.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::OutputCharStr(
    PDEVOBJ     pdevobj,
    PUNIFONTOBJ pUFObj,
    DWORD       dwType,
    DWORD       dwCount,
    PVOID       pGlyph) 
{
	VERBOSE(UNITEXT("IOEMUni::OutputCharStr() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::SendFontCmd
 *
 * Purpose: Modify font selection command and then send it to printer.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::SendFontCmd(
    PDEVOBJ      pdevobj,
    PUNIFONTOBJ  pUFObj,
    PFINVOCATION pFInv) 
{
	VERBOSE(UNITEXT("IOEMUni::SendFontCmd() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::TextOutAsBitmap
 *
 * Purpose: Create a bitmap image of a text string, in case a downloadable
 *		    font is not available.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::TextOutAsBitmap(
    SURFOBJ    *pso,
    STROBJ     *NAME_o,
    FONTOBJ    *pfo,
    CLIPOBJ    *pco,
    RECTL      *prclExtra,
    RECTL      *prclOpaque,
    BRUSHOBJ   *pboFore,
    BRUSHOBJ   *pboOpaque,
    POINTL     *pptlOrg,
    MIX         mix)
{
	VERBOSE(UNITEXT("IOEMUni::TextOutAsBitmap() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::TTDownloadMethod
 *
 * Purpose: Indicate the format that Unidrv should use for a specified
 *		    TrueType soft font.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::TTDownloadMethod(
    PDEVOBJ     pdevobj,
    PUNIFONTOBJ pUFObj,
    OUT DWORD   *pdwResult) 
{
	VERBOSE(UNITEXT("IOEMUni::TTDownloadMethod() entry.\r\n"));

	return E_NOTIMPL;
}

/*
 * Function: IOEMUni::TTYGetInfo
 *
 * Purpose: Supply Unidrv with information relevant to text-only printers.
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMUni::TTYGetInfo(
    PDEVOBJ     pdevobj,
    DWORD       dwInfoIndex,
    PVOID       pOutputBuf,
    DWORD       dwSize,
    DWORD       *pcbcNeeded)
{
	VERBOSE(UNITEXT("IOEMUni::TTYGetInfo() entry.\r\n"));

	return E_NOTIMPL;
}


/*
 *  OEM class factory
 */
class IOEMCF : public IClassFactory
{
public:
    // *** IUnknown methods ***
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj);
    STDMETHOD_(ULONG,AddRef)  (THIS);
    STDMETHOD_(ULONG,Release) (THIS);
   
    // *** IClassFactory methods ***
    STDMETHOD(CreateInstance) (THIS_
			LPUNKNOWN pUnkOuter,
			REFIID riid,
			LPVOID FAR* ppvObject
			);

    STDMETHOD(LockServer)     (THIS_
			BOOL bLock
			);


    // Constructor
    IOEMCF(): m_cRef(1) { };
    ~IOEMCF() { };

protected:
    LONG m_cRef;
};


/*
 * Class factory implementation
 */

/*
 * Function: IOEMCF::QueryInterface
 *
 * Purpose: 
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMCF::QueryInterface(const IID& iid, void** ppv)
{
	VERBOSE(UNITEXT("IOEMCF::QueryInterface entry.\r\n"));

    if((iid == IID_IUnknown) || (iid == IID_IClassFactory))
    {
        *ppv = static_cast<IOEMCF*>(this); 
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef();
    return S_OK;
}

/*
 * Function: IOEMCF::AddRef
 *
 * Purpose: Lifetime management.
 *
 * Return: ULONG
 */
ULONG __stdcall IOEMCF::AddRef()
{
	VERBOSE(UNITEXT("IOEMCF::AddRef entry.\r\n"));

    return InterlockedIncrement(&m_cRef);
}

/*
 * Function: IOEMCF::Release
 *
 * Purpose: Lifetime management.
 *
 * Return: ULONG
 */
ULONG __stdcall IOEMCF::Release() 
{
	VERBOSE(UNITEXT("IOEMCF::Release entry.\r\n"));

    if(InterlockedDecrement(&m_cRef) == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

/*
 * Function: IOEMCF::CreateInstance
 *
 * Purpose: 
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMCF::CreateInstance(
	IUnknown* pUnknownOuter,
	const IID& iid,
	void** ppv) 
{
	VERBOSE(UNITEXT("IOEMCF::CreateInstance entry.\r\n"));

    // cannot aggregate
    if(pUnknownOuter != NULL)
        return CLASS_E_NOAGGREGATION;

    // create component
    IOEMUni* pOEMUni = new IOEMUni;
    if(pOEMUni == NULL)
        return E_OUTOFMEMORY;

    // get the requested interface
    HRESULT hr = pOEMUni->QueryInterface(iid, ppv);

    // release the IUnknown pointer
    // (If QueryInterface failed, component will delete itself.)
    pOEMUni->Release();
    return hr;
}

/*
 * Function: IOEMCF::LockServer
 *
 * Purpose: 
 *
 * Return: HRESULT
 */
HRESULT __stdcall IOEMCF::LockServer(
	BOOL bLock) 
{
	VERBOSE(UNITEXT("IOEMCF::LockServer entry.\r\n"));

    if(bLock)
        InterlockedIncrement(&g_cServerLocks); 
    else
        InterlockedDecrement(&g_cServerLocks);

    return S_OK;
}


/*
 *  Registration functions
 */

/*
 * Function: IOEMCF::DllCanUnloadNow
 *
 * Purpose: Can DLL unload now?
 *
 * Return: 
 */
STDAPI DllCanUnloadNow()
{
    VERBOSE(UNITEXT("DllCanUnloadNow entry.\r\n"));

    if((g_cComponents == 0) && (g_cServerLocks == 0))
        return S_OK;
    else
        return S_FALSE;
}

/*
 * Function: IOEMCF::DllGetClassObject
 *
 * Purpose: Get class factory.
 *
 * Return: 
 */
STDAPI DllGetClassObject(
	const CLSID& clsid,
	const IID& iid,
	void** ppv)
{
    VERBOSE(UNITEXT("DllGetClassObject: Create class factory.\r\n"));

    // can we create this component?
    if(clsid != CLSID_OEMRENDER)
        return CLASS_E_CLASSNOTAVAILABLE;

    // create class factory
    IOEMCF* pOEMCF = new IOEMCF;  // reference count set to 1 in constructor
    if(pOEMCF == NULL)
        return E_OUTOFMEMORY;

    // get requested interface
    HRESULT hr = pOEMCF->QueryInterface(iid, ppv);
    pOEMCF->Release();

    return hr;
}