window.cpp

虚拟打印机

			break;
		default:
			ASSERTFAIL();
			break;
		}

		::PAINTSTRUCT ps;
		HDC hdc = ::BeginPaint(m_hwnd, &ps);

		switch(m_pm) {
		case ePaintDirect:
			this->Paint(hdc);

			if (m_ps != NULL) {
				// CLIPPING?
				m_ps->Save(hdc, m_hrgnUpdate);
				m_ps->Draw(hdc);
			}
			this->PaintDirectLayer(hdc);
			break;
		case ePaintBuffered: {
			SIZE szClient = { RW(m_rClient), RH(m_rClient) };
			Window::BackBufferDCInfo bbdi;
			HDC hdcMem = this->CreateBackBufferDC(bbdi, hdc);


			if (! ::EqualRgn(m_hrgnUpdate, m_hrgnEmpty)) {
				::SelectClipRgn(hdcMem, m_hrgnUpdate);
				if (this->m_bEraseBufferBkg) {
					if (m_bHasBkClr) {
						::FillSolidColor(hdcMem, m_rClient, m_bkClr);
					} else {
						::FillBkColor(hdcMem, m_rClient);
					}
				}
				this->Paint(hdcMem);

				if (m_ps != NULL) {
					if (m_bUpdateSpriteWithWindow) {
						HRGN hrgn = ::CreateRectRgn(0, 0, RW(m_rClient), RH(m_rClient));
						::CombineRgn(hrgn, hrgn, m_hrgnUpdate, RGN_DIFF);
						::SelectClipRgn(hdcMem, hrgn);
						::DeleteObject(hrgn);

						m_ps->Update(hdcMem, NULL);
						m_bUpdateSpriteWithWindow = FALSE;
					}
					// CLIPPING?
					::SelectClipRgn(hdcMem, NULL);
					m_ps->Save(hdcMem, m_hrgnUpdate);

					// DEBUG/FIX 7/7 QUCK TEST ADDING THIS CLIP
					::SelectClipRgn(hdcMem, m_hrgnUpdate);

					m_ps->Draw(hdcMem);
				}
			} 
			m_bEraseBufferBkg = FALSE;

			::SelectClipRgn(hdcMem, NULL);
			::SelectClipRgn(hdc, hrgnMeta);
			::BitBlt(hdc, 0, 0, szClient.cx, szClient.cy, hdcMem, 0, 0, SRCCOPY);
			this->PaintDirectLayer(hdc);

			this->DeleteBackBufferDC(bbdi);
		} break;

		default:
			ASSERTFAIL();
			break;
		}

		::EndPaint(m_hwnd, &ps);

		::DeleteObject(m_hrgnUpdate);
		m_hrgnUpdate = ::CreateRectRgn(0,0,0,0);

		if (hrgnMeta != NULL ) {
			::DeleteObject(hrgnMeta);
		}
		mr.bProcessed = TRUE;
	} break;

	default:
		break;
	}
}

void Window::TimerMsg(OUT MSGRESULT& mr, WPARAM wParam, LPARAM lParam) {
	mr.bProcessed = FALSE;
}

LRESULT Window::WindowProc(UINT msg, WPARAM wParam, LPARAM lParam) {
	// 6/29  DEBUG / FIX -- SEE IF THIS CHANGE BREAKS ANYTHING
	// THINK THE DEFAULT SHOULD BE THAT THE MESSAGE ISN'T PROCESSED, AND IS PASSED TO THE DEFWNDPROC
	//MSGRESULT mr = { TRUE, 0 };
	MSGRESULT mr = { FALSE, 0 };

	switch(msg) {
	case WM_SETCURSOR:
		this->CursorMsg(mr, msg, wParam, lParam);
		break;

	case WM_KEYDOWN:
	case WM_KEYUP:
	case WM_CHAR:
	case WM_DEADCHAR:
	case WM_SYSKEYDOWN:
	case WM_SYSKEYUP:
	case WM_SYSCHAR:
	case WM_SYSDEADCHAR:
		this->KeyboardMsg(mr, msg, wParam, lParam);
		break;

	case WM_MOUSEMOVE: 
	case WM_LBUTTONDOWN:
	case WM_LBUTTONUP:  
	case WM_LBUTTONDBLCLK:
	case WM_RBUTTONDOWN: 
	case WM_RBUTTONUP:  
	case WM_RBUTTONDBLCLK:
	case WM_MBUTTONDOWN: 
	case WM_MBUTTONUP:  
	case WM_MBUTTONDBLCLK:
	case WM_CAPTURECHANGED:
		this->MouseMsg(mr, msg, wParam, lParam);
		break;

	case WM_ACTIVATEAPP:
	case WM_CANCELMODE:
	case WM_CHILDACTIVATE:
	case WM_CLOSE:
	case WM_COMPACTING:
	case WM_CREATE:
	case WM_DESTROY:
	case WM_ENABLE:
	case WM_ENTERSIZEMOVE:
	case WM_EXITSIZEMOVE:
	case WM_GETICON:
	case WM_GETMINMAXINFO:
	case WM_INPUTLANGCHANGE:
	case WM_INPUTLANGCHANGEREQUEST:
	case WM_MOVE:
	case WM_MOVING:
	case WM_NCACTIVATE:
	case WM_NCCALCSIZE:
	case WM_NCCREATE:
	case WM_NCDESTROY:
	case WM_NULL:
	case WM_PARENTNOTIFY:
	case WM_QUERYDRAGICON:
	case WM_QUERYOPEN:
	case WM_SHOWWINDOW:
	case WM_SIZE:
	case WM_SIZING:
	case WM_STYLECHANGED:
	case WM_STYLECHANGING:
	//case WM_THEMECHANGED:
	case WM_USERCHANGED:
	case WM_WINDOWPOSCHANGED:
	case WM_WINDOWPOSCHANGING:
		this->NotificationMsg(mr, msg, wParam, lParam);
		break;

	case WM_NOTIFY:
		this->NotifyMsg(mr, wParam, lParam);
		break;

	case WM_ERASEBKGND:
	case WM_PAINT: 
		this->PaintMsg(mr, msg, wParam, lParam);
		break;

	case WM_TIMER:
		this->TimerMsg(mr, wParam, lParam);
		break;

	default:
		mr.bProcessed = FALSE;
		break;
	}

	if (!mr.bProcessed) {
		mr.lRetValue = this->DefWindowProc(msg, wParam, lParam);
	}

	return mr.lRetValue;
}

LRESULT Window::DefWindowProc(UINT msg, WPARAM wParam, LPARAM lParam) {
	LRESULT lRetValue = ::DefWindowProc(m_hwnd, msg, wParam, lParam);
	return lRetValue;
}


// ****
// ****  private:  class Window
// ****

HDC Window::CreateBackBufferDC(OUT BackBufferDCInfo &bbdi, IN HDC hdcRef) {
	HDC hdcRetValue = NULL;
	::ZeroMemory(&bbdi, sizeof(bbdi));

	HDC hdcScreen = NULL;
	if (hdcRef == NULL) {
		hdcScreen = ::GetDC(NULL);
		hdcRef = hdcScreen;
	}
	try {
		if (hdcRef != NULL) {
			bbdi.hdcMem = CreateCompatibleDC(hdcRef);
			if (bbdi.hdcMem != NULL) {
				bbdi.hbmpOld = (HBITMAP) ::SelectObject(bbdi.hdcMem, this->m_hbmpBuffer);

				::SetTextColor(bbdi.hdcMem, ::GetTextColor(hdcRef));
				::SetBkColor(bbdi.hdcMem, ::GetBkColor(hdcRef));
				::SetROP2(bbdi.hdcMem, ::GetROP2(hdcRef));
				::SetBkMode(bbdi.hdcMem, ::GetBkMode(hdcRef));
				hdcRetValue = bbdi.hdcMem;
			}
		}
		if (hdcScreen != NULL) {
			::ReleaseDC(NULL, hdcScreen);
		}
	} catch( ... ) {
		if (hdcScreen != NULL) {
			::ReleaseDC(NULL, hdcScreen);
		}
		throw;
	}

	return hdcRetValue;
}

void Window::DeleteBackBufferDC(IN const BackBufferDCInfo &bbdi) {
	::SelectObject(bbdi.hdcMem, bbdi.hbmpOld);
	::DeleteDC(bbdi.hdcMem);
}

void Window::SizePaintBuffer(void) {
	switch(m_pm) {
	case Window::ePaintDirect:
		if (m_hbmpBuffer != NULL) {
			::DeleteObject(m_hbmpBuffer);
			m_hbmpBuffer = NULL;
		}
		break;
	case Window::ePaintBuffered: {
		SIZE szOld = { 0, 0 };

		if (m_hbmpBuffer != NULL) {
			BITMAP bmp;
			::GetObject(m_hbmpBuffer, sizeof(BITMAP), &bmp);
			szOld.cx = bmp.bmWidth;
			szOld.cy = bmp.bmHeight;
		}

		SIZE szClient = { RW(m_rClient), RH(m_rClient) };
		if (szOld.cx != szClient.cx || szOld.cy != szClient.cy) {
			HDC hdc = ::GetDC(m_hwnd);
			HBITMAP hbmpNew = ::CreateCompatibleBitmap(hdc,szClient.cx, szClient.cy);
			if (m_hbmpBuffer != NULL) {
				HDC hdcMem1 = ::CreateCompatibleDC(hdc);
				HBITMAP hbmpOld1 = (HBITMAP) ::SelectObject(hdcMem1, hbmpNew);
				HDC hdcMem2 = ::CreateCompatibleDC(hdc);
				HBITMAP hbmpOld2 = (HBITMAP) ::SelectObject(hdcMem2, m_hbmpBuffer);

				::BitBlt(hdcMem1, 0, 0, szOld.cx, szOld.cy, hdcMem2, 0, 0, SRCCOPY);

				::SelectObject(hdcMem1, hbmpOld1);
				::DeleteDC(hdcMem1);
				::SelectObject(hdcMem2, hbmpOld2);
				::DeleteDC(hdcMem2);

				::DeleteObject(m_hbmpBuffer);
			}
			m_hbmpBuffer = hbmpNew;
			::ReleaseDC(m_hwnd, hdc);

			HRGN hrgnTemp = ::CreateRectRgn(0, 0, szClient.cx, szClient.cy);
			HRGN hrgnTemp2 = ::CreateRectRgn(0, 0, szOld.cx, szOld.cy);
			::CombineRgn(hrgnTemp, hrgnTemp, hrgnTemp2, RGN_DIFF);
			this->InvalidateRgn(hrgnTemp, TRUE);
			::DeleteObject(hrgnTemp);
			::DeleteObject(hrgnTemp2);
		}
	} break;
	default:
		ASSERTFAIL();
		break;
	}
}


// ***************************************************************************
// **  STATIC:  class Window  ************************************************
// ***************************************************************************

static const TCHAR gatstrWindowClassName[] = WINDOW_CLASSNAME;

LPCTSTR Window::TheirGetWindowClassName(void) {
	return gatstrWindowClassName;
}

Window* Window::TheirGetObjPtr(HWND hwnd) {
	Window *pw = (Window *) GetWindowLongPtr(hwnd, 0);
	return pw;
}

void Window::TheirInstallObjPtr(HWND hwnd, Window *pw) {
	::SetWindowLongPtr(hwnd, 0, (LONG_PTR) pw);
}

void Window::TheirRemoveObjPtr(HWND hwnd, Window *pw) {
	::SetWindowLongPtr(hwnd, 0, (LONG_PTR) NULL);
}

void Window::TheirGetClassInfo(OUT ::WNDCLASSEX & wcex, 
	HINSTANCE hinst, LPCTSTR lptstrClass, WNDPROC wndproc, DWORD dwcExtra) {

	wcex.cbSize			= sizeof(WNDCLASSEX);
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= wndproc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= dwcExtra;
	wcex.hInstance		= hinst;
	wcex.hIcon			= NULL;
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_BTNFACE+1);
	wcex.lpszMenuName	= NULL;
	wcex.lpszClassName	= lptstrClass;
	wcex.hIconSm		= NULL;
}