window.h

虚拟打印机

/*
 * 
 * window.h
 *
   Copyright (C) 2006 Michael H. Overlin

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   
   Contact at [e-mail]
 */

#ifndef WINDOW_H
#define WINDOW_H

#include "mathutils.h"
#include "utils.h"
#include <windows.h>
#include <vector>

// 7/6
#include "..\lib\sprite.h"

#define WINDOW_CLASSNAME		TEXT("Window-ClassWrapper")

class UpdateDirectLayer {
public:
	virtual ~UpdateDirectLayer() {};
	virtual void PaintDirect(HDC hdc) = 0;
};

class Window {
public:
	enum PaintMode { ePaintDirect, ePaintBuffered };

	Window(HINSTANCE hinst, HWND hwnd, PaintMode pm = ePaintDirect) ;
	virtual ~Window() ;

	BOOL IsMyWindowHandle(HWND hwnd) const { return hwnd == m_hwnd; }
	// PAINT BUFFERING
	// IF THE PAINT MODE IS "ePaintDirect": SIMPLY CALLS THE WINDOWS API VERSION
	// IF THE PAINT MODE IS "ePaintBuffered":
	// IT'S ASSUMED THAT "r" SPECIFIES A REGION OF THE BACK-BUFFER THAT IS DIRTY
	// (AS OPPOSED TO EXTERNALLY GENERATED INVALID REGIONS, WHICH NEED TO BE
	// REPAINTED ON THE SCREEN BUT FOR WHICH THE BACK-BUFFER IS NOT ASSUMED TO BE DIRTY)
	// THUS "r" IS ADDED TO DIRTY REGION FOR BOTH THE BACK-BUFFER AND THE DISPLAYED WINDOW CLIENT REGION
	BOOL InvalidateRect(const RECT& r, BOOL bErase)  ;
	BOOL InvalidateRgn(HRGN hrgn, BOOL bErase) ;
	BOOL InvalidateDirectLayer(const RECT& r, BOOL bErase) { return ::InvalidateRect(m_hwnd, &r, bErase); }
	BOOL InvalidateDirectLayer(HRGN hrgn, BOOL bErase) { return ::InvalidateRgn(m_hwnd, hrgn, bErase); }
	// THE API GetDC WOULD ALLOW DIRECT PAINTING TO THE WINDOW SURFACE WITHOUT NOTIFICATION THAT
	// THE BACK-BUFFER IS DIRTY (DOESN'T HAVE THE NEW MODIFICATIONS) -- THREREFORE THE GetDC API ISN'T
	// PROVIDED, INSTED A DESCENDENT CLASS CALLS "DoUpdateDirectLayer" WHICH CALLS THE VIRTUAL MEMBER
	// "PaintDirect" EITHER JUST WITH THE "GetDC" DC IF PaintMode IS ePaintDirect, OR TWICE,
	// WITH THE "GetDC" DC AND WITH A BACK-BUFFER MEMORY DC IF PaintMode IS ePaintBuffered
	// THIS WAY DESCENDENT CODE HAS NO SPECIAL CASES FOR BACK-BUFFERING VS. DIRECT PAINTING
	void DoUpdateDirectLayer(UpdateDirectLayer &pp);
	class Sprite *GetSprite(void) { return m_ps; }
	const class Sprite *GetSprite(void) const { return m_ps; }
	void SetSprite(class Sprite *ps);
	void DoUpdateSprite(void);
	void UpdateSpriteOnNextPaint(void) { 
		if (m_ps != NULL) {
			HRGN hrgn = m_ps->GetUpdateRegion();
			this->InvalidateRgn(hrgn, FALSE);
			::DeleteObject(hrgn);
		}
		m_bUpdateSpriteWithWindow = TRUE; 
	}

	void SetBackgroundColor(COLORREF clr) ;

	void ScrollWindow(int dx, int dy, const RECT& rSrcScroll) ;

	// WIN API
	BOOL AddPort(LPCTSTR pName, LPCTSTR pMonitorName) { return ::AddPort( const_cast<LPTSTR>(pName), m_hwnd, const_cast<LPTSTR>(pMonitorName) ); }
	HWND CreateChildWindowEx(DWORD dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HMENU hMenu, LPVOID lpParam) { return ::CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, m_hwnd, hMenu, m_hinst, lpParam); }
	HWND CreateChildDialogParam(LPCTSTR lpTemplateName, DLGPROC lpDialogFunc, LPARAM dwInitParam) { return ::CreateDialogParam(m_hinst, lpTemplateName, m_hwnd, lpDialogFunc, dwInitParam); }
	BOOL DestroyWindow(void) { return ::DestroyWindow(m_hwnd); }
	int GetDlgCtrlID(void) const { return ::GetDlgCtrlID(m_hwnd); }
	//void GetClientRect(OUT RECT& r) { r = m_rClient; }
	const RECT& rClient() const { return m_rClient; }
	HWND GetParent(void) const { return ::GetParent(m_hwnd); }
	BOOL KillTimer(UINT_PTR idTimer) { return ::KillTimer(m_hwnd, idTimer); }
	BOOL ScreenToClient(IN OUT POINT& pt) const { return ::ScreenToClient(m_hwnd, &pt); }
	BOOL ScreenToClient(IN OUT RECT& r) const { return ::ScreenToClient(r, m_hwnd); }
	LRESULT SendMessage(UINT msg, WPARAM wParam, LPARAM lParam) { return ::SendMessage(m_hwnd, msg, wParam, lParam); }
	HWND SetCapture(void) { return ::SetCapture(m_hwnd); }
	HWND SetFocus(void) { return ::SetFocus(m_hwnd); }
	UINT_PTR SetTimer(UINT_PTR idTimer, UINT ms) { return ::SetTimer(m_hwnd, idTimer, ms, NULL); }
	BOOL ShowWindow(int nCmdShow) { return ::ShowWindow(m_hwnd, nCmdShow); }
	BOOL PostMessage(UINT msg, WPARAM wParam, LPARAM lParam) { return ::PostMessage(m_hwnd, msg, wParam, lParam); }

	// WIN API SHORT-HAND
	HWND AddArgumentAsNotifyTarget(HWND hwnd) ;
	HWND AddToArgumentsNotifyTargetList(Window *pw);
	// CALLER IS RESPONSIBLE FOR FREEING RETURNED MALLOC'D BUFFER
	LPTSTR GetWindowText(void) const;
	LRESULT SendNotification(IN HWND hwnd, NMHDR *pnmh) ;
	LRESULT SendNotification(IN UINT code) ;

protected:	
	struct MSGRESULT {
		BOOL bProcessed;
		LRESULT lRetValue;
	};

	//inline HWND hwnd(void) const { return m_hwnd; }

	virtual void Paint(HDC hdc);
	virtual void PaintDirectLayer(HDC hdc);

	virtual void CursorMsg(OUT MSGRESULT& mr, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void KeyboardMsg(OUT MSGRESULT& mr, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void MouseMsg(OUT MSGRESULT& mr, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void NotificationMsg(OUT MSGRESULT& mr, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void NotifyMsg(OUT MSGRESULT& mr, WPARAM wParam, LPARAM lParam);
	virtual void PaintMsg(OUT MSGRESULT& mr, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void TimerMsg(OUT MSGRESULT& mr, WPARAM wParam, LPARAM lParam);

	virtual LRESULT WindowProc(UINT msg, WPARAM wParam, LPARAM lParam) ;
	virtual LRESULT DefWindowProc(UINT msg, WPARAM wParam, LPARAM lParam) ;

private:
	friend class SubClassWindow;

	struct BackBufferDCInfo {
		HDC hdcMem;
		HBITMAP hbmpOld;
	};

	HDC GetDC(void) { return ::GetDC(m_hwnd); }
	int ReleaseDC(HDC hdc) { return ::ReleaseDC(m_hwnd, hdc); }
	HDC CreateBackBufferDC(OUT BackBufferDCInfo &bbdi, IN HDC hdcRef);
	void DeleteBackBufferDC(IN const BackBufferDCInfo &bbdi);

	void SizePaintBuffer(void);

	// 7/7
	RECT m_rScroll;
	POINT m_ptScroll;

	HINSTANCE m_hinst;
	HWND m_hwnd;
	RECT m_rClient;

	// PAINTING / PAINT BUFFERING
	PaintMode m_pm;
	BOOL m_bEraseBufferBkg;
	HRGN m_hrgnUpdate;
	HRGN m_hrgnEmpty;
	HBITMAP m_hbmpBuffer;
	BOOL m_bHasBkClr;
	COLORREF m_bkClr;

	// SPRITES
	class Sprite *m_ps;
	BOOL m_bUpdateSpriteWithWindow;

	// 6/1 ADDITIONAL NOTIFICATION TARGETS
	std::vector<HWND> m_vhwndNotify;

// ***
// ***  STATIC
// ***

public:
	static LPCTSTR TheirGetWindowClassName(void);
	static Window* TheirGetObjPtr(HWND hwnd) ;
	static void TheirInstallObjPtr(HWND hwnd, Window *pw);
	static void TheirRemoveObjPtr(HWND hwnd, Window *pw);
	static void TheirGetClassInfo(OUT ::WNDCLASSEX & wcex, 
		IN HINSTANCE hinst, IN LPCTSTR lptstrClass, IN WNDPROC wndproc, IN DWORD dwcExtra);

#pragma warning(disable:4312)
#pragma warning(disable:4244)

	template<class TWindow> static ATOM TheirRegisterWindowClass(HINSTANCE hInst) {
		::WNDCLASSEX wcex;
		TWindow::TheirGetClassInfo(wcex, hInst, TWindow::TheirGetWindowClassName(),
			Window::TheirWndProc<TWindow>, sizeof(LONG_PTR));
		ATOM atomRetValue = ::RegisterClassEx(&wcex);
		return atomRetValue;
	}

	template<class TWindow>  
	static LRESULT CALLBACK TheirWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
		LRESULT lRetValue = 0;
		Window *pw = TWindow::TheirGetObjPtr(hwnd);

		if (msg == WM_CREATE) {
			LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam;
			pw = new TWindow(lpcs->hInstance, hwnd);
			TWindow::TheirInstallObjPtr(hwnd, pw);
		}

		if (pw != NULL) {
			lRetValue = pw->WindowProc(msg, wParam, lParam);
		} else {
			lRetValue = ::DefWindowProc(hwnd, msg, wParam, lParam);
		}

		if (msg == WM_NCDESTROY) {
			TWindow::TheirRemoveObjPtr(hwnd, pw);
			//SetWindowLongPtr(hwnd, 0, (LONG_PTR) NULL);
			delete pw;
			pw = NULL;
		}

		return lRetValue;
	}

};

#endif