dialogwindow.cpp

虚拟打印机

/*
 *
 * dialogwindow.cpp
 *
   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]
 */


#include "dialogwindow.h"
#include "mathutils.h"
#include "syncobject.h"
#include "types.h"
#include "window.h"
#include <windows.h>

// WE MIGHT AUTOMATICALLY HAVE SPACE RESERVED IN GWL_USERDATA?  COULD CHECK W/SPY E.G.
static TCHAR g_atstrWinProp[] = TEXT("iuhsqkhbx DialogWindow");
std::vector<HWND> g_vhwndDialogWindows;
::SynchronizedObject g_synobj;

void AddDialogWindow(HWND hdlg) ;
void RemoveDialogWindow(HWND hdlg) ;


DialogWindow::DialogWindow(IN HINSTANCE hinst, IN WORD wTemplateID) {
	m_hinst = hinst;
	m_hdlg = NULL;
	m_wTemplateID = wTemplateID;
	m_bAutoDelete = TRUE;
}

DialogWindow::~DialogWindow() {
	// NOTHING TO DELETE
}

BOOL DialogWindow::DoCreateDialog(Window *pw) {
	HWND hdlg = pw->CreateChildDialogParam(
		MAKEINTRESOURCE(m_wTemplateID),
		(DLGPROC) DialogWindow::TheirDlgProc,
		(LPARAM) this
		);

	// ABOVE SETS m_hdlg
	BOOL bRetValue = (hdlg != NULL);
	return bRetValue;
}

BOOL DialogWindow::DoCreateDialog(HWND hwndParent) {
	HWND hdlg = ::CreateDialogParam(
		m_hinst,
		MAKEINTRESOURCE(m_wTemplateID),
		hwndParent,
		(DLGPROC) DialogWindow::TheirDlgProc,
		(LPARAM) this
		);

	// ABOVE SETS m_hdlg
	BOOL bRetValue = (hdlg != NULL);
	return bRetValue;
}

INT_PTR DialogWindow::DoModalDialog(HWND hwndParent) {
	INT_PTR retValue = ::DialogBoxParamW(
		m_hinst,
		MAKEINTRESOURCE(m_wTemplateID),
		hwndParent,
		(DLGPROC) DialogWindow::TheirDlgProc,
		(LPARAM) this
		);
	
	return retValue;
}

// NOT RELIABLE, HAVE TO TAKE INTO ACCOUNT FONT CHOICE
#if 0
void DialogWindow::GetSizeFromTemplate(SIZE& sz) const {
	HRSRC hrsrc = FindResource(::GetModuleHandle(0), MAKEINTRESOURCE(m_wTemplateID), RT_DIALOG); 
	HGLOBAL hglb = LoadResource(::GetModuleHandle(0), hrsrc); 
	LPDLGTEMPLATE lpdt = (LPDLGTEMPLATE) LockResource(hglb); 
	DWORD dwDlgBase = ::GetDialogBaseUnits();

	sz.cx = lpdt->cx;

	UnlockResource(hglb);
	::FreeResource(hglb);
}
#endif 


BOOL DialogWindow::CenterWindowAboveParent(void) {
	BOOL b = ::CenterWindowAboveParent(m_hdlg);
	return b;
}

void DialogWindow::SetHasSystemMenu(IN BOOL b) {
	DWORD dwStyle = this->GetWindowStyle();
	if (b) {
		dwStyle = dwStyle | WS_SYSMENU;
	} else {
		dwStyle = dwStyle & (~ (DWORD) WS_SYSMENU);
	}
	this->SetWindowStyleAndRedraw(dwStyle);
}

void DialogWindow::SetWindowStyleAndRedraw(DWORD dwStyle) {
	::SetWindowLong(m_hdlg, GWL_STYLE, dwStyle);
	::SetWindowPos(m_hdlg, NULL, 0,0,0,0, 
		SWP_FRAMECHANGED |  SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER );
}

BOOL DialogWindow::TheirIsDialogMessage(::MSG& msg) {
	//std::vector<HWND>& v = g_vhwndDialogWindows;
	std::vector<HWND> v;
	g_synobj.Lock();
	try {
		v = g_vhwndDialogWindows;
		g_synobj.UnLock();
	} catch( ... ) {
		g_synobj.UnLock();
		throw;
	}
	
	for(uint ui = 0; ui < v.size(); ++ui) {
		HWND hwndDlg = v[ui];
		if (::IsDialogMessage(hwndDlg, &msg)) {
			return TRUE;
		}
	}
	return FALSE;
}


// ***
// *** PRIVATE:  class DialogWindow
// ***

BOOL DialogWindow::InitMsg(WPARAM wParam, LPARAM lParam) {
	//m_hdlg = hdlg;
	return TRUE;
}

BOOL DialogWindow::CommandMsg(WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::CommonControlColorNotifyMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::NotificationMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::NotifyMsg(WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::ScrollMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::TimerMsg(WPARAM wParam, LPARAM lParam) {
	return FALSE;
}

BOOL DialogWindow::DlgProc(UINT msg, WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;

	switch(msg) {
	case WM_INITDIALOG: 
		bRetValue = this->InitMsg(wParam, lParam);
		break; 

	case WM_COMMAND: 
		bRetValue = this->CommandMsg(wParam, lParam);
		break;

	case WM_CTLCOLORMSGBOX:
	case WM_CTLCOLOREDIT:
	case WM_CTLCOLORLISTBOX:
	case WM_CTLCOLORBTN:
	case WM_CTLCOLORDLG:
	case WM_CTLCOLORSCROLLBAR:
	case WM_CTLCOLORSTATIC:
		bRetValue = this->CommonControlColorNotifyMsg(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:
		bRetValue = this->NotificationMsg(msg, wParam, lParam);
		break;

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

	case WM_HSCROLL:
	case WM_VSCROLL: 
		bRetValue = this->ScrollMsg(msg, wParam, lParam);
		break;

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

	default:
		break;
	} // switch(msg)

	return bRetValue;
}


// ***
// *** STATIC:  class DialogWindow
// ***

BOOL CALLBACK DialogWindow::TheirDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;
	DialogWindow *pdw = (DialogWindow *) ::GetProp(hDlg, ::g_atstrWinProp);

	if (msg == WM_INITDIALOG) {
		pdw = (DialogWindow *) lParam;
		pdw->m_hdlg = hDlg;
		::AddDialogWindow(hDlg);
		::SetProp(hDlg, ::g_atstrWinProp, (HANDLE) pdw);
	}

	if (pdw != NULL) {
		bRetValue = pdw->DlgProc(msg, wParam, lParam);
	}

	if (msg == WM_NCDESTROY) {
		// RECURSION -- ABOVE CALL TO pdw->DlgProc CAN CAUSE WM_NCDESTROY TO BE SENT, IN WHICH CASE
		// WE HIT THIS ON THE WAY OUT AGAIN (AT LEAST ONCE)
		// PROBABLY SHOULD NOT ACTUALLY DELETE UNTIL WE ARE LEAVING ANY RECURSIVE LOOP WE'RE IN --- LATER/FIX
		pdw = (DialogWindow *) ::GetProp(hDlg, ::g_atstrWinProp);		
		if (pdw != NULL) {
			::SetProp(hDlg, ::g_atstrWinProp, (HANDLE) NULL);
			//DialogWindow* pdwTest =  (DialogWindow *) ::GetProp(hDlg, ::g_atstrWinProp);		
			::RemoveDialogWindow(hDlg);
			if (pdw->GetAutoDelete()) {
				delete pdw;
				pdw = NULL;
			} else {
				pdw->m_hdlg = NULL;
			}
		}
	}

	return bRetValue;
}

static void AddDialogWindow(HWND hdlg) {
	std::vector<HWND>& v = g_vhwndDialogWindows;
	g_synobj.Lock();
	try {
		v.push_back(hdlg);
		g_synobj.UnLock();
	} catch( ... ) {
		g_synobj.UnLock();
		throw;
	}
}

static void RemoveDialogWindow(HWND hdlg) {
	g_synobj.Lock();
	try {
		std::vector<HWND>& v = g_vhwndDialogWindows;
		for(uint ui = 0; ui < v.size(); ++ui) {
			HWND hwndDlg = v[ui];
			if (hwndDlg == hdlg) {
				v.erase(v.begin() + ui);
				break;
			}
		}
		g_synobj.UnLock();
	} catch( ... ) {
		g_synobj.UnLock();
		throw;
	}
}