previewdialog.cpp

虚拟打印机

					this->SelectPage(uiPage);
				}
				break;
			default:
				break;
			}
		} break;
		case IDC_EDIT_ZOOM: {
			WORD wCode = HIWORD(wParam);
			switch(wCode) {
			//7/14
			case EN_SETFOCUS: {
				HWND hwndCtrl = this->GetDlgItem(IDC_EDIT_ZOOM);
				::PostMessage(hwndCtrl, EM_SETSEL, 0, (LPARAM) -1);
			} break;
			default:
				break;
			}
		} break;
		case IDC_RADIO_ALL_ORIGINAL:
			this->CheckDlgButton(IDC_RADIO_ALL_ORIGINAL, TRUE);
			this->CheckDlgButton(IDC_RADIO_SELECTION_ORIGINAL, FALSE);
			this->SetSourceSelection(FALSE, NULL);
			break;
		case IDC_RADIO_SELECTION_ORIGINAL:
			this->CheckDlgButton(IDC_RADIO_SELECTION_ORIGINAL, TRUE);
			this->CheckDlgButton(IDC_RADIO_ALL_ORIGINAL, FALSE);
			RECTD rdSelection_Inches;
			if (this->ReadSourceSelection(rdSelection_Inches)) {
				if (! this->SetSourceSelection(TRUE, &rdSelection_Inches)) {
					::PRListViewDialog *pprlvd = this->GetOriginalSourceDialog();
					//pprlvd->SetNoSelectionBox();
					pprlvd->SetArrowSelectionBox(FALSE, NULL);
				}
			}
			break;
#if 0
		case IDC_RADIO_ALL_RESIZED:
			this->CheckDlgButton(IDC_RADIO_ALL_RESIZED, TRUE);
			this->CheckDlgButton(IDC_RADIO_SELECTION_RESIZED, FALSE);
			break;
		case IDC_RADIO_SELECTION_RESIZED:
			this->CheckDlgButton(IDC_RADIO_SELECTION_RESIZED, TRUE);
			this->CheckDlgButton(IDC_RADIO_ALL_RESIZED, FALSE);
			break;
#endif		
		default:
			break;
	}
	return TRUE;
}

BOOL PreviewDialog::NotificationMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;
	switch(msg) {
		case WM_CLOSE:
			this->PostMessageW(WM_COMMAND, IDC_BUTTON_EXIT, 0);
			break;
		case WM_NCDESTROY:
			::PostQuitMessage(0);
			break;
		default:
			break;
	}
	return bRetValue;;
}


BOOL PreviewDialog::NotifyMsg(WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;
	int idCtrl = (int) wParam;
	switch(idCtrl) {
	case IDC_EDIT_ZOOM: {
		LPNMHDR lpnmh = (LPNMHDR) lParam;
		UINT uiCode = lpnmh->code;
		switch(uiCode) {
		case NM_RETURN: {
			int k = 0; 

			++k;
			bRetValue = TRUE;
		} break;
		default:
			break;
		}
	} break;
	//case IDC_TABDIALOG: {
	//	LPNMHDR lpnmh = (LPNMHDR) lParam;
	//	UINT uiCode = lpnmh->code;
	//	switch(uiCode) {
	//	case ::TabDialogsCtrl::eDialogChanged: {
	case IDC_PRVIEWWINDOW: {
		LPNMHDR lpnmh = (LPNMHDR) lParam;
		UINT uiCode = lpnmh->code;
		if (lpnmh->hwndFrom == m_hwndOriginalListView) {
			switch(uiCode) {
			case ::ListViewWindow::eArrowSelectionBoxChange: {
				RECTD rdSelection_Inches;
				if (this->ReadSourceSelection(rdSelection_Inches)) {
					if (this->SetSourceSelection(TRUE, &rdSelection_Inches) ) {
						this->EnableOriginalSelection(TRUE);
						this->WriteOriginalAll(FALSE);
						::PRListViewDialog* pprlvd = this->GetOriginalSourceDialog();
						pprlvd->SetCursorType(::ListViewWindow::eHand);
					} else {
						PRListViewDialog* pprlvd = this->GetOriginalSourceDialog();
						//pprlvd->SetNoSelectionBox();
						pprlvd->SetArrowSelectionBox(FALSE, NULL);
					}
				} else {
					this->SetSourceSelection(FALSE, NULL);
					this->EnableOriginalSelection(FALSE);
					this->WriteOriginalAll(TRUE);
				}
				this->WriteOriginalImageInfo();
			} break;
			default:
				break;
			}
		} else if (lpnmh->hwndFrom == m_hwndResizedListView) {
#if 0
			// RESPOND TO RESIZED SELECTIONS HERRE		
			PRListViewDialog* pprlvd = this->GetResizedDialog();
			if (pprlvd->HasSelectionItems()) {
				this->EnableResizedSelection(TRUE);
				this->WriteResizedAll(FALSE);
			} else {
				this->EnableResizedSelection(FALSE);
				this->WriteResizedAll(TRUE);
			}
#endif
		} 
		else {
			ASSERTFAIL();
		}
		bRetValue = TRUE;
	} break;
	default:
		break;
	}
	return bRetValue;
}

BOOL PreviewDialog::ScrollMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;
	switch(msg) {
		case WM_VSCROLL: {
			uint uiPage;
			BOOL bPage = this->ReadSelectedPage(uiPage);
			if (bPage) {
				BOOL bAutoRotate = this->ReadAutoRotate();
				WORD wScrollCode = LOWORD(wParam);
				switch(wScrollCode) {
				case SB_LINEDOWN: {
					::PageSpec psTemp = m_psResized;
					BOOL bRot = FALSE;
					SIZE szMosaic = m_rsResized.szMosaic;
					::RenderSpec::SizeMode mode = ::RenderSpec::eMosaic;
					double dZoomOld = m_rsResized.dZoom;
					double dZoomNew;

					if (bAutoRotate) {
						dZoomNew = ::FindNextSmallerMosaicSizeWithRotation(szMosaic, bRot, dZoomOld,
							m_rsResized, psTemp, m_ssResized);
						if (bRot) {
							//::ReflectPageSpec(psTemp);
							::LandscapeRotatePageSpec(psTemp);
						}
					} else {
						dZoomNew = ::FindNextSmallerMosaicSize(szMosaic, m_rsResized, psTemp, m_ssResized);
					}

					if ( ::EqualSz(szMosaic, m_rsResized.szMosaic) && !bRot ) {
						dZoomNew = dZoomOld;
						szMosaic = m_rsResized.szMosaic;
						psTemp = m_psResized;
						bRot = FALSE;
						mode = RenderSpec::eZoom;
						if (dZoomNew > 3.0) {
							dZoomNew -= 1.0;
						} else if (dZoomNew > 0.2) {
							dZoomNew -= 0.1;
						} else  {
							dZoomNew -= 0.01;
						} 
						::CalculateMosaicSizeFromZoom(szMosaic, dZoomNew, m_rsResized, m_psResized, m_ssResized);
					}

					BOOL bOk;
					switch(mode) {
					case ::RenderSpec::eMosaic: 
						bOk = this->IsValidMosaicSize(szMosaic, m_rsResized, psTemp, m_ssResized);
						break;
					case ::RenderSpec::eZoom:
						bOk = this->IsValidZoom(dZoomNew, m_rsResized, psTemp, m_ssResized);
						break;
					default:
						ASSERTFAIL();
						break;
					}

					if (bOk) {
						m_rsResized.szMosaic = szMosaic;
						m_rsResized.mode = mode;
						m_rsResized.dZoom = dZoomNew;
						if (bRot) {
							m_psResized = psTemp;
							this->WriteLandscape(m_psResized.bLandscape);
						}
					} else {
						ErrorMessage(TEXT("Cannot further decrease zoom size."));
						m_rsResized.dZoom = MIN_ZOOM;
						m_rsResized.mode = RenderSpec::eZoom;
					}

					this->ResetResizedViewableList();
					this->WriteZoom(m_rsResized.dZoom);
				} break; // case SB_LINEDOWN
				case SB_LINEUP: {
					::PageSpec psTemp = m_psResized;
					BOOL bRot = FALSE;
					SIZE szMosaic = m_rsResized.szMosaic;
					double dZoomOld = m_rsResized.dZoom;
					double dZoomNew;

					if (bAutoRotate) {
						dZoomNew = ::FindNextLargerMosaicSizeWithRotation(szMosaic, bRot, dZoomOld,
							m_rsResized, psTemp, m_ssResized);
						if (bRot) {
							//::ReflectPageSpec(psTemp);
							::LandscapeRotatePageSpec(psTemp);
						}
					} else {
						dZoomNew = ::FindNextLargerMosaicSize(szMosaic, dZoomOld, m_rsResized, psTemp, m_ssResized);
					}

					if (!IsValidMosaicSize(szMosaic, m_rsResized, psTemp, m_ssResized)) {
						ErrorMessage(TEXT("Cannot further increase zoom size with zoom-up button."));
						break;
					}

					m_rsResized.szMosaic = szMosaic;
					m_rsResized.mode = RenderSpec::eMosaic;
					m_rsResized.dZoom = dZoomNew;
					if (bRot) {
						m_psResized = psTemp;
						this->WriteLandscape(m_psResized.bLandscape);
					}

					this->ResetResizedViewableList();
					this->WriteZoom(m_rsResized.dZoom);
				} break; // case SB_LINEUP
				default:
					break;
				} // switch(wScrollCode)
				bRetValue = TRUE;
			} // if (bPage)
		}  break; // case WM_VSCROLL
		default:
			break;
	} // switch(msg)
	return bRetValue;
}

BOOL PreviewDialog::InterProcessMsg(UINT msg, WPARAM wParam, LPARAM lParam) {
	switch(msg) {
	case WM_TEMPFILEWRITTEN: {
		if (m_pdwWaitingForSpoolerData != NULL) {
			m_pdwWaitingForSpoolerData->EndDialog(0);
			delete m_pdwWaitingForSpoolerData;
			m_pdwWaitingForSpoolerData = NULL;
		}	

		::PRDataSource *pprdsNew = new ::PRSpoolerDataFile();
		if (pprdsNew->Open(m_tstrCommandLine)) {
			this->OnNewDataSource(pprdsNew);
		} else {
			this->ErrorMessage(TEXT("Error initializing.  Unable to read print job data from spooler."));
		}
		m_tstrCommandLine.erase();
	} break;
	case WM_ABORTPRINTING:
		if (m_pdwWaitingForSpoolerData != NULL) {
			m_pdwWaitingForSpoolerData->EndDialog(0);
			delete m_pdwWaitingForSpoolerData;
			m_pdwWaitingForSpoolerData = NULL;
		}	
		this->DestroyWindow();
		break;
	default:
		break;
	}

	return TRUE;
}

BOOL PreviewDialog::DlgProc(UINT msg, WPARAM wParam, LPARAM lParam) {
	BOOL bRetValue = FALSE;
	switch(msg) {
		case WM_ABORTPRINTING:
		case WM_TEMPFILEWRITTEN:
			bRetValue = this->InterProcessMsg(msg, wParam, lParam);
			break;
		default:
			bRetValue = this->DialogWindow::DlgProc(msg, wParam, lParam);
			break;
	}
	return bRetValue;
}

// ****
// **** private:  class PreviewDialog
// ****


void PreviewDialog::CloseDataSource(void) {
	this->ClosePage();
	this->EnableDlgItem(IDC_LIST_PAGES, FALSE);
	delete m_pDataSource;
	m_pDataSource = NULL;
}

BOOL PreviewDialog::CloseDataSourceCofirmationMessage(LPCTSTR lptstrAction) {
	BOOL bRetValue = TRUE;
	if (m_pDataSource != NULL && 
		m_pDataSource->GetDataSourceType() == ::PrintPreviewDataSources::ePrintSpoolerDataFile
	) {
		tstring tstrMessage = lptstrAction;
		tstrMessage += TEXT("?\n\nPrint job data will be permanently deleted.");
		bRetValue  = this->ConfirmationMessage(tstrMessage.c_str());
	}
	return bRetValue;
}

void PreviewDialog::ClosePage(void) {
	this->EnablePageControls(FALSE);
	this->CloseViewableLists();
}

void PreviewDialog::CloseViewableLists(void) {
	{
		PRListViewDialog *pprlvd = this->GetResizedDialog();
		::ViewablePrintPagesList *pvppl = 
			(ViewablePrintPagesList *) pprlvd->SetList(NULL, m_prdp, ListViewWindow::eSelectItems, m_szdMinSelectionBox);
		if (pvppl != NULL) {
			delete pvppl;
		}
	}

	{
		::PRListViewDialog *pprlvdOrig = this->GetOriginalSourceDialog();
		::ViewablePrintPagesList *pvppl = 
			(ViewablePrintPagesList *) pprlvdOrig->SetList(NULL, m_prdp, ListViewWindow::eSelectBox, m_szdMinSelectionBox);
		if (pvppl != NULL) {
			delete pvppl;
		}
	}

	this->WriteResizedImageInfo();
	this->WriteOriginalImageInfo();

	this->DeletePageMetaFiles();
}

void PreviewDialog::ComposeDialogTitle(OUT tstring& tstrTitle, IN LPCTSTR lptstrSubject) {
#if 0
	tstrTitle = PRINTRESIZER_APP_NAME;
	tstrTitle += TEXT(":  ");
	tstrTitle += lptstrSubject;
#else
	::ComposeDialogTitle(::PrintResizerComponents::ePreviewApp, tstrTitle, lptstrSubject);
#endif
}

BOOL PreviewDialog::ConfirmationMessage(LPCTSTR lptstrMessage, HWND hwndParent) {
	if (hwndParent == NULL) {
		hwndParent = this->hdlg();
	}
	BOOL b = ::ConfirmationMessage(::PrintResizerComponents::ePreviewApp, hwndParent, lptstrMessage);
	return b;
}

void PreviewDialog::DeletePageMetaFiles(void) {
	if (m_hMetaForPage != NULL) {
		::DeleteEnhMetaFile(m_hMetaForPage);
		m_hMetaForPage = NULL;
	}
	if (m_hMetaDraftForPage != NULL) {
		::DeleteEnhMetaFile(m_hMetaDraftForPage);
		m_hMetaDraftForPage = NULL;
	}
}