#ifndef PVL_H_INCLUDED
#define PVL_H_INCLUDED



#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef STRICT
#define STRICT 1
#endif 




#include <windows.h>
#include <tchar.h>
#include <assert.h>


#define PVLAPI(T) extern "C" T _cdecl


#ifndef  PVLDLL
#pragma comment(lib,"pvl.lib")
#endif




enum PVL_MESSAGE
	{
	PVL_MESSAGE_BASE=WM_USER,
	PVL_MESSAGE_PAGE_DIRTY=PVL_MESSAGE_BASE+1,											 // lParam - page number
	PVL_MESSAGE_END=PVL_MESSAGE_BASE+100
	};

//===================================================================================
//
struct PVL_CALLBACK
    {
    DWORD     dwSize;																	  // =sizeof(PVL_CALLBACK)
    LPVOID    lpUserData;																  // Pointer to user data
	HRESULT   (__stdcall* pfnPrepareDC)   (PVL_CALLBACK *,HWND,DEVMODEA *,LONG);          // Prepare DC
	HRESULT   (__stdcall* pfnInit)        (PVL_CALLBACK *,HWND,HDC,const DEVMODEA *);     // Make content
	HRESULT   (__stdcall* pfnGetNumPages) (PVL_CALLBACK *,HWND,const DEVMODEA *,LONG*);   // Get number of pages
	HRESULT   (__stdcall* pfnDrawPage)    (PVL_CALLBACK *,HWND,HDC,DWORD,DWORD);          // Draw page
	HRESULT   (__stdcall* pfnCanBeClosed) (PVL_CALLBACK *,HWND,LONG*);		              // Can be closed?
	HRESULT   (__stdcall* pfnWindowCutOff)(PVL_CALLBACK *,HWND);      		              // Last call for cleanup
	HRESULT   (__stdcall* pfnPrintDisabled)(PVL_CALLBACK *,HWND);      		               // The function is called when 
    LPCSTR    pszWindowName;															  // Window caption
    LPCSTR    pszDocumentName;															  // Document name
	DWORD     dwStyleEx;		                                                          // Extended window style
	DWORD     dwStyle;			                                                          // Window style
	DWORD     dwInitialWindowWidth;                                                       // Initial window width
	DWORD     dwInitialWindowHeight;                                                      // Initial window height
	HWND      hParentWindow;															  // Parent window handle
	HINSTANCE hInstance;																  // Application HINSTANCE
	DWORD     dwShowStyle;																  //  Show style 
    };


//===================================================================================
// Register PVL windows classes
PVLAPI(BOOL) pvlRegisterClasses(HINSTANCE);

//===================================================================================
// Register PVL windows classes
PVLAPI(BOOL) pvlRegisterClasses2(HINSTANCE,HICON);
//===================================================================================
// Unregister PVL windows classes
PVLAPI(BOOL) pvlUnregisterClasses(HINSTANCE);

//===================================================================================
// Create preview instance 
PVLAPI(HWND) pvlCreatePreview(PVL_CALLBACK *);

 
//===================================================================================
// Get default printer's name
PVLAPI(LPCSTR) pvlGetDefaultPrinterName(LONG);

//===================================================================================
// Print direct to a printer
PVLAPI(LONG) pvlPrintDirect(PVL_CALLBACK *);

//===================================================================================
// Select printer 
PVLAPI(int) pvlSelectPrinter(HWND);

//===================================================================================
//
PVLAPI(LPCSTR) pvlGetLastUsedPrinterName();

//===================================================================================
//
PVLAPI(void) pvlSetUsedPrinterName(LPCSTR);

//===================================================================================
//
PVLAPI(void) pvlDisablePrint(LONG);

//===================================================================================
//
PVLAPI(void) pvlGetPrinterList(LPCSTR **,LONG *);

//===================================================================================
//
PVLAPI(ULONG) pvlGetMaxImageSize(void);

//===================================================================================
//
PVLAPI(void) pvlSetMaxImageSize(ULONG);

//#ifndef PVL_DISABLE_WRAPPER


//===================================================================================
// Wrapper for PVL_CALLBACK
#ifdef __cplusplus 

#pragma warning(push,3)
#include <string>
#include <list>
#pragma warning(pop)
#pragma warning(disable:4312)

class __declspec(novtable) PVL_CALLBACK_CLASS : public PVL_CALLBACK
    {

	protected:
	HWND m_hWnd;
    std::string m_szWindowName;
    std::string m_szDocumentName;

	private:
	static HRESULT __stdcall tplfnPrepareDC  (PVL_CALLBACK * p,HWND hwnd,DEVMODEA * pd,LONG lFromInit)
        {
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        return ptr->PrepareDC(hwnd,pd,lFromInit);
        }

	static HRESULT __stdcall tplfnInit  (PVL_CALLBACK * p,HWND hwnd,HDC dc,const DEVMODEA * pd)
        {
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        return ptr->Init(hwnd,dc,pd);
        }


	static HRESULT __stdcall tplfnGetNumPages(PVL_CALLBACK * p,HWND hwnd,const DEVMODEA * pd,LONG* pl)
        {
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        return ptr->GetNumPages(hwnd,pd,pl);
        }

	static HRESULT __stdcall tplfnDrawPage   (PVL_CALLBACK * p,HWND hwnd,HDC dc,DWORD page,DWORD prn)
        {
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        assert(ptr->pfnDrawPage);
        return ptr->DrawPage(hwnd,dc,page,prn);
        }

	static HRESULT __stdcall tplfnCanBeClosed(PVL_CALLBACK * p,HWND hwnd,LONG * pl)
        {
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        assert(ptr->pfnCanBeClosed);
        return ptr->CanBeClosed(hwnd,pl);
        }

	static HRESULT __stdcall tplfnWindowCutOff(PVL_CALLBACK * p,HWND hwnd)
		{
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        assert(ptr->pfnWindowCutOff);
        return ptr->WindowCutOff(hwnd);
		}

	static HRESULT __stdcall tplfnPrintDisabled(PVL_CALLBACK * p,HWND hwnd)
		{
        if(!p) return E_INVALIDARG;
        PVL_CALLBACK_CLASS * ptr=reinterpret_cast<PVL_CALLBACK_CLASS *>(p->lpUserData);
        assert(ptr);
        assert(ptr->pfnPrintDisabled);
        return ptr->PrintDisabled(hwnd);
		}

     public:
	 typedef std::list<PVL_CALLBACK_CLASS * > CALLBACK_CLASS_INSTANCE_LIST;
	 typedef std::list<PVL_CALLBACK_CLASS * >::iterator CALLBACK_CLASS_INSTANCE_LIST_ITERATOR;
	 static CALLBACK_CLASS_INSTANCE_LIST m_List;

		static void ForceCleanUp()
			{
			for(;;)
				{
				CALLBACK_CLASS_INSTANCE_LIST_ITERATOR I=m_List.begin();
				if(I==m_List.end())
					{
					break;
					}
				PVL_CALLBACK_CLASS * ptr=*I;
				if(ptr->GetHWnd()!=0)
					{
					ptr->SubmitCleanUp();
					}
				else
					{
					delete ptr;
					}
				}
			}

		static BOOL IsAnyPreviewActive()
			{
			return m_List.size()!=0;
			}

        PVL_CALLBACK_CLASS()
            {
            PVL_CALLBACK & r=static_cast<PVL_CALLBACK &>(*this);
            r.dwSize=sizeof(PVL_CALLBACK);
			r.hParentWindow=0;
			r.hInstance=0;
            r.lpUserData=reinterpret_cast<LPVOID>(this);
            r.pfnPrepareDC=PVL_CALLBACK_CLASS::tplfnPrepareDC;
            r.pfnInit=PVL_CALLBACK_CLASS::tplfnInit;
            r.pfnGetNumPages=PVL_CALLBACK_CLASS::tplfnGetNumPages;
            r.pfnDrawPage=PVL_CALLBACK_CLASS::tplfnDrawPage;
			r.pfnCanBeClosed=PVL_CALLBACK_CLASS::tplfnCanBeClosed;
			r.pfnWindowCutOff=PVL_CALLBACK_CLASS::tplfnWindowCutOff;
			r.pfnPrintDisabled=PVL_CALLBACK_CLASS::tplfnPrintDisabled;
			m_hWnd=0;
			r.dwInitialWindowHeight=600;
			r.dwInitialWindowWidth=600;
			r.dwStyle=WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
			r.dwStyleEx=WS_EX_APPWINDOW;
			r.dwShowStyle=SW_NORMAL;
			r.pszDocumentName=m_szWindowName.c_str();
			r.pszWindowName=m_szWindowName.c_str();
			m_List.push_back(this);

            }

        virtual ~PVL_CALLBACK_CLASS()
            {
			m_List.remove(this);
            }
        
		void SetParentWindow(HWND hwnd)
			{
			PVL_CALLBACK & r=static_cast<PVL_CALLBACK &>(*this);
			if(hwnd==0)
				{
				hwnd=::GetDesktopWindow();
				}	
			r.hParentWindow=hwnd;
			}

        void SetWindowName(LPCSTR psz)
            {
            m_szWindowName=psz;
            pszWindowName=m_szWindowName.c_str();
            }

        void SetDocumentName(LPCSTR psz)
            {
            m_szDocumentName=psz;
            pszDocumentName=m_szDocumentName.c_str();
            }

        virtual HWND CreatePreview(HWND hwnd)
            {
            PVL_CALLBACK & r=static_cast<PVL_CALLBACK &>(*this);
			SetParentWindow(hwnd);
			r.hInstance=((HINSTANCE)(::GetWindowLong(hwnd,GWL_HINSTANCE)));
			m_hWnd=::pvlCreatePreview(static_cast<PVL_CALLBACK*>(this));
            return m_hWnd;
            }

		void SetPageDirty(LONG page)
			{
			::SendMessage(m_hWnd,PVL_MESSAGE_PAGE_DIRTY,0,page);
			}

		HWND GetHWnd()
			{
			return m_hWnd;
			}

		BOOL PrintDirect(HWND hwnd)
			{
			int ires;
            PVL_CALLBACK & r=static_cast<PVL_CALLBACK &>(*this);
			SetParentWindow(hwnd);
			r.hInstance=(HINSTANCE)::GetWindowLong(hwnd,GWL_HINSTANCE);
			ires=pvlPrintDirect(this);
			return ires==0?FALSE:TRUE;
			}

		virtual void SubmitCleanUp()
			{
			HWND h=GetHWnd();
			::SendMessage(h,WM_CLOSE,0,0);			
			}

        // pure virtual functions
		virtual HRESULT PrepareDC(HWND,DEVMODEA *,LONG)=0;
        virtual HRESULT Init(HWND,HDC,const DEVMODEA *)=0;
        virtual HRESULT GetNumPages(HWND,const DEVMODEA *,LONG*)=0;
        virtual HRESULT DrawPage(HWND,HDC,DWORD,DWORD)=0;
        virtual HRESULT CanBeClosed(HWND,LONG*)=0;
        virtual HRESULT WindowCutOff(HWND)=0;
        virtual HRESULT PrintDisabled(HWND)=0;
    };







#if _MSC_VER > 1200 // MSVC 7.0 and later
// VS.NET works better than VC 6.0
__declspec(selectany) PVL_CALLBACK_CLASS::CALLBACK_CLASS_INSTANCE_LIST PVL_CALLBACK_CLASS::m_List;
#else 





#ifdef PVL_CALLBACK_CLASS_MEMBER_INSTANCE

	// We have to instantiate this static member of PVL_CALLBACK_CLASS
	PVL_CALLBACK_CLASS::CALLBACK_CLASS_INSTANCE_LIST PVL_CALLBACK_CLASS::m_List;

#else 

#pragma message("===================================================================")
#pragma message("== pvl.h IMPORTANT NOTE: READ CAREFULLY !!!                        ")
#pragma message("===================================================================")
#pragma message("To use the class with an old compiler (VC 6.0) you have to include ")
#pragma message("the file into the file stdafx.cpp as it is shown below:" )
#pragma message("#include \"stdafx.h\"" )
#pragma message("#define PVL_CALLBACK_CLASS_MEMBER_INSTANCE" )
#pragma message("#include \"pvl.h\"" )
#pragma message("" )
#pragma message("===================================================================")


#endif  // PVL_CALLBACK_CLASS_MEMBER_INSTANCE

#endif // _MSC_VER > 1200

//#endif // __cplusplus


#endif // #ifndef PVL_DISABLE_WRAPPER



	


#endif //PVL_H_INCLUDED