previewdialog.cpp

虚拟打印机

void PreviewDialog::EnableAutoRotate(IN BOOL bEnable) {
	this->EnableDlgItem(IDC_CHECK_AUTOROTATE, bEnable);
	if (!bEnable) {
		this->WriteAutoRotate(FALSE);
	}
}

void PreviewDialog::EnableLandscape(IN BOOL bEnable) {
	this->EnableDlgItem(IDC_CHECK_LANDSCAPE, bEnable);
	this->EnableAutoRotate(bEnable);
	if (!bEnable) {
		this->WriteLandscape(FALSE);
	}
}

void PreviewDialog::EnablePageControls(IN BOOL bEnable) {
	BOOL bPageListEnabled = this->IsDlgItemEnabled(IDC_LIST_PAGES);
	ChildEnabler cd(this->hdlg(), bEnable);
	cd.DoEnable();
	this->EnableDlgItem(IDC_BUTTON_EXIT, TRUE);
	this->EnableDlgItem(IDC_LIST_PAGES, bEnable | bPageListEnabled);

	m_pTabDialogs->ShowWindow(bEnable ? SW_SHOW : SW_HIDE);

	HMENU hmenu = this->GetMenu();
	UINT uiFlag = MF_BYCOMMAND | (bEnable ? MF_ENABLED : MF_GRAYED);
	::EnableMenuItem(hmenu, ID_FILE_SAVEPOSTER, uiFlag);
	::EnableMenuItem(hmenu, ID_FILE_SAVEORIGINALPAGESASBITMAPS, uiFlag);
}

void PreviewDialog::EnableOriginalSelection(IN BOOL bEnable) {
	this->EnableDlgItem(IDC_RADIO_SELECTION_ORIGINAL, bEnable);
	this->EnableDlgItem(IDC_RADIO_ALL_ORIGINAL, bEnable);
}
#if 0
void PreviewDialog::EnableResizedSelection(IN BOOL bEnable) {
	this->EnableDlgItem(IDC_RADIO_ALL_RESIZED, bEnable);
	this->EnableDlgItem(IDC_RADIO_SELECTION_RESIZED, bEnable);
}
#endif

void PreviewDialog::ErrorMessage(LPCTSTR lptstrMessage, HWND hwndParent) {
	if (hwndParent == NULL) {
		hwndParent = this->hdlg();
	}
	::ErrorMessage(PrintResizerComponents::ePreviewApp, hwndParent, lptstrMessage);
}

void PreviewDialog::FillPageList(uint nPages) {
	uint nPagesOld = this->SendDlgItemMessage(IDC_LIST_PAGES, LB_GETCOUNT, 0, 0);
	if (nPagesOld != nPages) {
		this->SendDlgItemMessage(IDC_LIST_PAGES, LB_RESETCONTENT, 0, 0);
		TCHAR atstrBuff[MAX_LISTBOX_PAGES_CCH];
		nPages = min(nPages, MAX_LISTBOX_PAGES);
		for(uint k = 0; k < nPages; ++k) {
			StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("Page %d"), k+1);
			this->SendDlgItemMessage(IDC_LIST_PAGES, LB_ADDSTRING, 0, (LPARAM) atstrBuff);
		}
	}
}

void PreviewDialog::GetDefaultPageSpec(OUT ::PageSpec& ps, IN const ::MarginSpec& ms, 
									   IN BOOL bLandscape, IN BOOL bEvenMargins) const {
	ps.szdPhysicalPage_Inches.cx = 8.5;
	ps.szdPhysicalPage_Inches.cy = 11.0;
	ps.szlPhysicalPage.cx = RoundToLong(ps.szdPhysicalPage_Inches.cx * 300);
	ps.szlPhysicalPage.cy = RoundToLong(ps.szdPhysicalPage_Inches.cy * 300);
	ps.ptlOffsetPrintable.x = 150;
	ps.ptlOffsetPrintable.y = 150;
	ps.szlPrintable.cx = ps.szlPhysicalPage.cx - ps.ptlOffsetPrintable.x * 2;
	ps.szlPrintable.cy = ps.szlPhysicalPage.cy - ps.ptlOffsetPrintable.y * 2;
	ps.ms = ms;
	//7/13
	ps.rotDir = ::LandscapeRot::e90;
	ps.bLandscape = FALSE;
	if (bLandscape) {
		//::ReflectPageSpec(ps);
		::LandscapeRotatePageSpec(ps);
	}
	// 7/1
	::EnforceMinimumMargins(ps, bEvenMargins);
}

PRListViewDialog *PreviewDialog::GetResizedDialog(void) { 
	return (PRListViewDialog *) m_pTabDialogs->GetDialog(RESIZED_DIALOG_INDEX); 
}

PRListViewDialog *PreviewDialog::GetOriginalSourceDialog(void) { 
	return (PRListViewDialog *) m_pTabDialogs->GetDialog(SOURCE_DIALOG_INDEX); 
}

void PreviewDialog::GetResizedSourceSpecForPage(IN uint uiPage, IN HENHMETAFILE hMeta, OUT ::SourceSpec& ssResized) {
	if (! m_pDataSource->GetResizedSourceSpec(uiPage, ssResized)) {
		::GetEnhMetafileFrame_Inches(ssResized.rdTotalImage_Inches, hMeta);
		ssResized.rdSelection_Inches = ssResized.rdTotalImage_Inches;
	}
}

BOOL PreviewDialog::IsAutoRotateEnabled(void) const {
	BOOL b = this->IsDlgItemEnabled(IDC_CHECK_AUTOROTATE);
	return b;
}

BOOL PreviewDialog::IsLandscapeEnabled(void) const {
	BOOL b = this->IsDlgItemEnabled(IDC_CHECK_LANDSCAPE);
	return b;
}

BOOL PreviewDialog::IsOriginalSelectionEnabled(void) const {
	BOOL b = this->IsDlgItemEnabled(IDC_RADIO_ALL_ORIGINAL);
	return b;
}

BOOL PreviewDialog::IsValidMosaicSize(const SIZE& szMosaic,
									  const ::RenderSpec &rs, const ::PageSpec& ps, const ::SourceSpec& ss) const {
	if (0 == AREA(szMosaic) || AREA(szMosaic) > MAX_PRINTED_PAGES) return FALSE;
	RenderSpec rsTemp = rs;
	rsTemp.szMosaic = szMosaic;
	rsTemp.mode = RenderSpec::eMosaic;
	RenderSpec::MosaicFullDimension fulldim;
	double dZoom = ::CalculateZoomFromMosaicSize(rsTemp.szMosaic, rsTemp, ps, ss, fulldim);
	BOOL b = (dZoom > 0 && dZoom <= MAX_ZOOM);
	return b;
}

BOOL PreviewDialog::IsValidPageSpec(IN const ::PageSpec ps, IN double dMinPrintable) const {
	BOOL b = ::IsPageSpecValid(ps, dMinPrintable, PAGE_ALLOW_NONSTD_MARGINS);
	return b;
}

BOOL PreviewDialog::IsValidSourceSelection(IN const RECTD& rdSelection_Inches) const {
	RECTD rdTemp;
	::IntersectRect(rdTemp, rdSelection_Inches, m_ssResized.rdTotalImage_Inches);
	if (::EqualRect(rdTemp, rdSelection_Inches)) {
		::RenderSpec rsTemp = m_rsResized;
		::PageSpec psTemp = m_psResized;
		::SourceSpec ssTemp = m_ssResized;
		ssTemp.rdSelection_Inches = rdSelection_Inches;
		BOOL bRotated;
		::MakeZoomSettingsConsistent(rsTemp, psTemp, ssTemp, this->ReadAutoRotate(), bRotated);
		if (bRotated) {
			//::ReflectPageSpec(psTemp);
			::LandscapeRotatePageSpec(psTemp);
		}
		if (IsValidZoom(rsTemp.dZoom, rsTemp, psTemp, ssTemp)) {
			return TRUE;
		}
	}
	return FALSE;
}

BOOL PreviewDialog::IsValidZoom(double dZoom, 
								const ::RenderSpec &rs, const ::PageSpec& ps, const ::SourceSpec& ss) const {
	if (dZoom < MIN_ZOOM || dZoom > MAX_ZOOM) return FALSE;
	SIZE szMosaic;
	::RenderSpec rsTemp = rs;
	rsTemp.dZoom = dZoom;
	rsTemp.mode = RenderSpec::eZoom;
	::CalculateMosaicSizeFromZoom(szMosaic, rsTemp.dZoom, rsTemp, ps, ss);
	BOOL b = 0 < AREA(szMosaic) && AREA(szMosaic) < MAX_PRINTED_PAGES;
	return b;
}

void PreviewDialog::MakeZoomSettingsConsistent(void) {
	BOOL bRotated;
	::MakeZoomSettingsConsistent(m_rsResized, m_psResized, m_ssResized, this->ReadAutoRotate(), bRotated);
	if (bRotated) {
		//::ReflectPageSpec(m_psResized);
		::LandscapeRotatePageSpec(m_psResized);

		//6/3
		//this->m_bRotatedPSResized = ! this->m_bRotatedPSResized;
	}
	//6/2 AVOID CASE OF MODE BEING MOSAIC AND SPECS CHANGE (SOURCE SPEC HAS CAUSED PROBLEM)
	// IN SUCH A WAY THAT A LOT OF MOSAIC PAGES ARE ACTUALLY BLANK 
	// E.G. GO FROM A WIDE, SHORT SELECTION IMAGE ON A 6 WIDE, 1 HIGH MOSAIC TO THE FULL IMAGE
	// NOW IT SQUASES DOWN TO FIT THE HEIGHT, AND MOST OF THE 6 WIDE ARE EMPTY
	if (m_rsResized.mode == ::RenderSpec::eMosaic) {
		SIZE szMosaic;
		::CalculateMosaicSizeFromZoom(szMosaic, m_rsResized.dZoom, m_rsResized, m_psResized, m_ssResized);
		if (AREA(szMosaic) < AREA(m_rsResized.szMosaic)) {
			m_rsResized.szMosaic = szMosaic;
		}
	}
}


void PreviewDialog::OnOpenFile(IN const tstring& tstrFileName, PRDataSource *pprdsNew/*, IN ::PrintPreviewDataSource ppdsNew*/) {
	if (pprdsNew->Open(tstrFileName)) {
		this->OnNewDataSource(pprdsNew);
	} else {
		delete pprdsNew;
		tstring tstrMessage = TEXT("Unable to open file ");
		tstrMessage += tstrFileName;
		this->ErrorMessage(tstrMessage.c_str());
	}
}

void PreviewDialog::OnNewDataSource(::PRDataSource *pprdsNew) {
	ASSERT(pprdsNew != NULL);

	delete m_pDataSource;
	m_pDataSource = pprdsNew;

	//m_ppds = ppdsNew;
	
	//if (m_ppds == ::PrintPreviewDataSources::ePrintSpoolerDataFile) {
	if (m_pDataSource->GetDataSourceType() == ::PrintPreviewDataSources::ePrintSpoolerDataFile) {

		this->SetDialogTitle(m_pDataSource->GetJobName());
	}
	this->FillPageList(m_pDataSource->GetPageCount());

	this->EnableDlgItem(IDC_LIST_PAGES, TRUE);

	if (m_pDataSource->GetPageCount() != 0) {
		this->SelectPage(0);
	} else {
		this->ErrorMessage(TEXT("Error initializing.  Data contains no pages."));
	}
}
void PreviewDialog::OnZoomEditBoxEntry(void) {
	BOOL bError = TRUE;
	double dZoomNew;
	BOOL bRead = this->ReadZoomEditBox(dZoomNew);
	if (bRead) {
		if (this->IsValidZoom(dZoomNew, m_rsResized, m_psResized, m_ssResized)) {
			m_rsResized.mode = RenderSpec::eZoom;
			m_rsResized.dZoom = dZoomNew;
			this->MakeZoomSettingsConsistent();
			this->ResetResizedViewableList();
			bError = FALSE;
		} 
	}
	if (bError) {
		this->ErrorMessage(TEXT("Text entry for \"zoom\" enlargement percent was not valid"));
		HWND hwndZoomEditBox = this->GetDlgItem(IDC_EDIT_ZOOM);
		::SetFocus(hwndZoomEditBox);
	}
}

BOOL PreviewDialog::ReadAutoRotate(void) const {
	BOOL b =  this->IsDlgButtonChecked(IDC_CHECK_AUTOROTATE);
	return b;
}


BOOL PreviewDialog::ReadEvenMargins(void) const {
	BOOL b = this->IsDlgButtonChecked(IDC_CHECK_EVENMARGINS);
	return b;
}

BOOL PreviewDialog::ReadLandscape(void) const {
	BOOL b = this->IsDlgButtonChecked(IDC_CHECK_LANDSCAPE);
	return b;
}

BOOL PreviewDialog::ReadNoCutGuidelines(void) const {
	BOOL b =  this->IsDlgButtonChecked(IDC_CHECK_NOGUIDELINES);
	return b;
}

BOOL PreviewDialog::ReadOriginalAll(void) const {
	BOOL b = this->IsDlgButtonChecked(IDC_RADIO_ALL_ORIGINAL);
	return b;
}
#if 0
BOOL PreviewDialog::ReadResizedAll(void) const {
	BOOL b = this->IsDlgButtonChecked(IDC_RADIO_ALL_RESIZED);
	return b;
}
#endif

BOOL PreviewDialog::ReadSelectedPage(OUT uint& uiPage) const {
	LRESULT lres = const_cast<PreviewDialog*>(this)->SendDlgItemMessage(IDC_LIST_PAGES, LB_GETCURSEL, 0, 0);
	if (lres != LB_ERR) {
		uiPage = (uint) lres;
		return TRUE;
	} 
	return FALSE;
}

BOOL PreviewDialog::ReadSelectedPrinter(OUT tstring& tstr) {
	LRESULT lres = this->SendDlgItemMessage(IDC_COMBO_PRINTERS, CB_GETCURSEL, 0, 0);
	if (lres != CB_ERR) {
		uint uiSel = (uint) lres;
		uint cChSel = this->SendDlgItemMessage(IDC_COMBO_PRINTERS, CB_GETLBTEXTLEN, (WPARAM) uiSel, 0);
		::ItemBuffer  buff(cChSel + 1, sizeof(TCHAR));
		this->SendDlgItemMessage(IDC_COMBO_PRINTERS, CB_GETLBTEXT, (WPARAM) uiSel, (LPARAM) buff.GetPtr());
		tstr = (LPTSTR) buff.GetPtr();
		return TRUE;
	} else {
		tstr.empty();
	}
	return FALSE;
}

BOOL PreviewDialog::ReadSourceSelection(RECTD& rdSelection_Inches) const {
	BOOL bRetValue = FALSE;
	uint uiPage;
	if (this->ReadSelectedPage(uiPage)) {
		const ::PRListViewDialog* prlvd = const_cast<PreviewDialog*>(this)->GetOriginalSourceDialog();
		const ::ListViewWindow* plvw = prlvd->GetListViewWindow();
		if (plvw->HasArrowSelectionBox()) {
			const ::ViewableList *pvl = plvw->GetList();
			RECTD rdListSelBox = plvw->GetArrowSelectionBox();
			POINTD ptdItem;
			::CenterInRect(ptdItem, rdListSelBox);
			uint uiItem;
			// ITEM SHOULD ALWAYS BE FOUND AND BE 0 (ONLY 1 ITEM IN LIST, THE SOURCE PAGE FOR 
			// CURRENT SELECTED PAGE
			if (pvl->ItemFromPt(uiItem, ptdItem)) {
				RECTD rdItem;
				pvl->GetItemSelectableBounds(uiItem, rdItem);
				::OffsetRect(rdListSelBox, 
					m_ssResized.rdTotalImage_Inches.left - rdItem.left, 
					m_ssResized.rdTotalImage_Inches.top - rdItem.top
					);
				rdSelection_Inches = rdListSelBox;
				bRetValue = TRUE;
			}
		}
	}
	return bRetValue;
}

BOOL PreviewDialog::ReadZoomEditBox(OUT double& dZoom) const {
	TCHAR atstrBuff[MAX_ZOOM_TCHAR+1];
	const_cast<PreviewDialog*>(this)->GetDlgItemText(IDC_EDIT_ZOOM, atstrBuff, ARRCOUNT(atstrBuff));
	double dTemp;
	if (::swscanf(atstrBuff, TEXT("%lf"), &dTemp) == 1) {
		dZoom = dTemp / 100.0;
		return TRUE;
	}
	return FALSE;
}

// MAY WANT TO HAVE A VERSION THAT ALTERS LIST CHARACTERISTICS
// WITHOUT A COMPLETE RESET (ESP. IF MOSAIC SIZE ISN'T CHANGED)
void PreviewDialog::ResetResizedViewableList(void) {
	PRListViewDialog *pprlvd = this->GetResizedDialog();
	::ViewablePrintPagesList *pvppl = NULL;
	uint uiPage;
	if (this->ReadSelectedPage(uiPage)) {
		// DEBUG / FIX WE DON'T NEED TO BE DELETING/CREATING THE METAFILE THIS OFTEN
		// MAYBE MAKE A REFERENCE COUNTING OBJECT, THEN WE CAN SHARE IT AND MAINTAIN IT FOR THE SELECTED
		// PAGE
		//HENHMETAFILE hMeta = m_pDataSource->GetPageEMF(uiPage);
		// DEBUG - FIX
		// hMeta = ghMeta;
		pvppl = new ::ViewablePrintPagesList(m_hMetaForPage, m_hMetaDraftForPage, m_rsResized, m_psResized, m_ssResized);
	}

	pvppl = (ViewablePrintPagesList *) pprlvd->SetList(pvppl, m_prdp, ListViewWindow::eSelectItems, m_szdMinSelectionBox);
	if (pvppl != NULL) {
		delete pvppl;
	}

	this->WriteResizedImageInfo();
}

// 7/3 SAVED BACKUP VERSION BEFORE SWAPPING ORDER RESIZED / ORIGINAL
// 7/3 SAVED BACKUP VERSION IN #IF BLOCK AT END -- AFTER GETTING USER SELECTION WORKING
// ON OPEN POSTER
void PreviewDialog::SelectPage(uint uiPage) {

	this->WriteSelectedPage(uiPage);
	// HMETA IS GIVEN TO ORIGINAL SOURCE VIEW DIALOG'S ViewablePrintPagesList (WHICH WILL OWN IT)

	this->CloseViewableLists();

	ASSERT(m_hMetaForPage == NULL);
	ASSERT(m_hMetaDraftForPage == NULL);
	m_hMetaForPage = m_pDataSource->GetPageEMF(uiPage);

	if (m_hMetaForPage != NULL) {
		m_hMetaDraftForPage = ::CreateDraftMetaFile(m_hMetaForPage, RGB(0xff, 0xff, 0xff), DRAFT_METAFILE_MAXDIMENSION);

		this->EnablePageControls(TRUE);

		// CODE WORKS FROM THIS DEFAULT STATE
		this->WriteOriginalAll(TRUE);
		this->EnableOriginalSelection(FALSE);
#if 0
		this->WriteResizedAll(TRUE);
		this->EnableResizedSelection(FALSE);
#endif
		// ****
		// **** SET UP THE ORIGINAL SOURCE ViewablePrintPagesList ***
		// ****

		// SOURCE SPEC
		this->GetResizedSourceSpecForPage(uiPage, m_hMetaForPage, m_ssResized);