previewdialog.cpp

虚拟打印机

		m_ssOriginal.rdSelection_Inches = m_ssOriginal.rdTotalImage_Inches = m_ssResized.rdTotalImage_Inches;

		// PAGE SPEC
		this->UpdateOriginalPageSpec();

		// RENDER SPEC 
		m_rsOriginal.bCutGuides = FALSE;
		m_rsOriginal.bCenter = RENDERSPEC_CENTER_ORIGINAL;
		m_rsOriginal.mode = RenderSpec::eZoom;
		m_rsOriginal.dZoom = 1;
		m_rsOriginal.szMosaic.cx = 1;
		m_rsOriginal.szMosaic.cy = 1;

		::PRListViewDialog *pprlvdOrig = this->GetOriginalSourceDialog();
		::ViewablePrintPagesList *pvpplOrig = new ::ViewablePrintPagesList(m_hMetaForPage, m_hMetaDraftForPage, 
			m_rsOriginal, m_psOriginal, m_ssOriginal);


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

		// ****
		// **** SET UP THE RESIZED OUTPUT ViewablePrintPagesList 
		// ****
		
		{
			BOOL bEvenMargins;
			if (m_pDataSource->GetEvenPageMargins(uiPage, bEvenMargins)) {
				this->WriteEvenMargins(bEvenMargins);
			}
		}

		{ // BLOCK:  RESIZED PAGESPEC 
			BOOL bUpdatedResizedPageSpec = FALSE;
			{ // BLOCK:  SET TARET PRINTER FROM DATA 
				tstring tstrTargetPrinterName;
				PDEVMODE pdmTargetDefault = m_pDataSource->GetTargetPrinter(uiPage, tstrTargetPrinterName);
				if (pdmTargetDefault != NULL && this->WriteSelectedPrinter(tstrTargetPrinterName.c_str())) {	
					if (this->UpdateResizedPageSpec(pdmTargetDefault)) {
						PDEVMODE pdm = this->m_pdmKeeper->GetDevMode(tstrTargetPrinterName);
						::DM_Copy(pdmTargetDefault, (LPBYTE) pdm);					
						bUpdatedResizedPageSpec = TRUE;
					} else {
						this->WriteSelectedPrinter(this->m_tstrLastPrinterSelected.c_str());
					}
				}
			} // BLOCK:  SET TARGET PRINTER FROM DATA
			
			if (!bUpdatedResizedPageSpec) {
				if (this->UpdateResizedPageSpec()) {
					bUpdatedResizedPageSpec = TRUE;
				}
			}

			// TRY AGAIN WITHOUT EVEN MARGINS IF THEY WERE SET
			if (!bUpdatedResizedPageSpec && this->ReadEvenMargins()) {
				this->WriteEvenMargins(FALSE);
				if (this->UpdateResizedPageSpec()) {
					bUpdatedResizedPageSpec = TRUE;
				}
			}

			// GIVE UP AND USE DEFAULT PAGE SPEC
			if (!bUpdatedResizedPageSpec) {
				BOOL bLandscape = this->ReadLandscape();
				BOOL bEvenMargins = this->ReadEvenMargins();
				this->GetDefaultPageSpec(m_psResized, this->m_msResized, bLandscape, bEvenMargins);
			}
		} // BLOCK: RESIZED PAGESPEC

		// SET DATA LANDSCAPE VALUE HERE SO THAT SIZING TAKES IT INTO ACCOUNT
		// IF WE HAVE THE DATA, TURN OFF "AUTO ROTATE" UNTIL END WHEN IT IS RESET TO
		// EITHER ITS OLD VALUE OR VALUE FROM THE DATA 
		BOOL bOldAutoRotate = this->ReadAutoRotate();
		if (this->IsLandscapeEnabled()) {
			BOOL bLandscape;
			if (m_pDataSource->GetLandscape(uiPage, bLandscape)) {
				BOOL bOldLandscape = this->ReadLandscape();
				//if (bLandscape ^ bOldLandscape) {
				if (lxor(bLandscape, bOldLandscape)) {
					LandscapeRotatePageSpec(m_psResized);
					this->WriteLandscape(bLandscape);
					this->WriteAutoRotate(FALSE);
				}
			}
		}

		// SOURCE SPEC
		// SETTING THE VIEWABLELIST FOR THE ORIGINAL SOURCE DIALOG CAUSES ANY 
		// CURRENT SELECTION TO BE CLEARED SO WE LOAD THE SOURCE SPEC AGAIN
		// SAVE THE SELECTION IN ANOTHER VARIABLE JUST TO BE SAFE
		this->GetResizedSourceSpecForPage(uiPage, m_hMetaForPage, m_ssResized);
		RECTD rdSourceSelection = m_ssResized.rdSelection_Inches;

		// RENDER SPEC
		::RenderSpec rsTemp;
		if (m_pDataSource->GetResizedRenderSpec(uiPage, rsTemp)) {
			m_rsResized = rsTemp;
			this->MakeZoomSettingsConsistent();
			this->WriteNoCutGuidelines(! m_rsResized.bCutGuides);
		} else {
			BOOL bHasNoCutGuideMargins = this->ReadNoCutGuidelines();
			m_rsResized.bCutGuides = ! bHasNoCutGuideMargins;
			m_rsResized.bCenter = RENDERSPEC_CENTER_RESIZED;

			m_rsResized.szMosaic.cx = 1;
			m_rsResized.szMosaic.cy = 1;
			m_rsResized.mode = RenderSpec::eMosaic;
			RenderSpec::MosaicFullDimension fulldim;
			m_rsResized.dZoom = ::CalculateZoomFromMosaicSize(m_rsResized.szMosaic, m_rsResized, m_psResized, m_ssResized, fulldim);
		}

		this->WriteZoom(m_rsResized.dZoom);
		this->ResetResizedViewableList();

		// SET USER SOURCE SELECTION BOX FROM DATA
		if (memcmp(& m_ssResized.rdTotalImage_Inches, & rdSourceSelection, sizeof(m_ssResized.rdTotalImage_Inches)) != 0) {
			::PRListViewDialog* pprlvd = this->GetOriginalSourceDialog();		
			const ::ListViewWindow* plvw = pprlvd->GetListViewWindow();
			const ::ViewableList *pvl = plvw->GetList();
			RECTD rdItem;
			pvl->GetItemSelectableBounds(0, rdItem);
			RECTD rdSelectionForList = rdSourceSelection;
			::OffsetRect(rdSelectionForList, 
				rdItem.left - m_ssResized.rdTotalImage_Inches.left, 
				rdItem.top - m_ssResized.rdTotalImage_Inches.top
				);
			// FINAL 'TRUE' ARGUMENT GIVES US A CALL-BACK NOTIFICATION, WHICH WILL SET
			// THE SELECTION AS IF THE USER HAD DONE IT (OR REJECT IT BASED ON THE USUAL CRITERIA)
			pprlvd->SetArrowSelectionBox(TRUE, &rdSelectionForList, TRUE);
		}

		// IF AUTOROTATE IS SET BY DATA TRY TO WRITE THAT,
		// OR TRY TO REWRITE THE ORIGINAL AUTOROTATE VALUE
		if (this->IsAutoRotateEnabled()) {
			BOOL bAutoRotate = bOldAutoRotate;
			m_pDataSource->GetAutoRotate(uiPage, bAutoRotate);
			this->WriteAutoRotate(bAutoRotate);
		}

	} else {
		this->ClosePage();

		TCHAR atstrBuff[MAX_LISTBOX_PAGES_CCH];
		::StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("%ld"), (DWORD) uiPage + 1);
		tstring tstrMessage = TEXT("Unable to read image data for page ");
		tstrMessage += atstrBuff;
		this->ErrorMessage(tstrMessage.c_str());
	}
}

BOOL PreviewDialog::SetSourceSelection(IN BOOL bHasSelection, IN const RECTD* prdSelection_Inches) {
	BOOL bRetValue = TRUE;
	if (bHasSelection) {
		if (! ::EqualRect(*prdSelection_Inches, m_ssResized.rdSelection_Inches) ) {
			if (this->IsValidSourceSelection(*prdSelection_Inches)) {
				m_ssResized.rdSelection_Inches = *prdSelection_Inches;
				this->MakeZoomSettingsConsistent();
				this->WriteZoom(m_rsResized.dZoom);
				this->ResetResizedViewableList();
			} else {
				bRetValue = FALSE;
				this->ErrorMessage(TEXT("Unable to select area from original source.  Using all of source."));
				// RECALL RECURSIVELY, RESULTS IN "else" BLOCK BELOW BEING EXECUTED
				this->SetSourceSelection(FALSE, NULL);
			}
		}
	} else {
		if (! ::EqualRect(m_ssResized.rdSelection_Inches, m_ssResized.rdTotalImage_Inches) ) {
			m_ssResized.rdSelection_Inches = m_ssResized.rdTotalImage_Inches;
			this->MakeZoomSettingsConsistent();
			this->WriteZoom(m_rsResized.dZoom);
			this->ResetResizedViewableList();
		}
	}
	return bRetValue;
}

void PreviewDialog::SetDialogTitle(const tstring& tstrJobName) {
	tstring tstrTemp;
	if (tstrJobName.length() > 0) {
		this->ComposeDialogTitle(tstrTemp, tstrJobName.c_str());
	} else {
		//7/9
		//this->ComposeDialogTitle(tstrTemp, TEXT("(no print job)"));
		this->ComposeDialogTitle(tstrTemp, TEXT(""));
	}
	this->SetWindowText(tstrTemp.c_str());
}

void PreviewDialog::UpdateOriginalPageSpec(void) {
	// 6/25 DEBUG / FIX
	// THE TARGET DEV MODE SHOULD BE THE DEFAULT STARTING POINT WHEN THE USER SELECTS THAT PRINTER FROM THE LIST
	BOOL bGetDefault = TRUE;
	uint uiPage;
	if (this->ReadSelectedPage(uiPage)) {
		::PageSpec psTemp ;
		//PCDEVMODE pdm = (PCDEVMODE) this->m_pDataSource->GetPRDevMode(uiPage);
		//const tstring& tstrPrinterName = this->m_pDataSource->GetPrinterName();
		//if (pdm != NULL && ::GetPageSpec(psTemp, m_msOriginal, pdm, tstrPrinterName.c_str())) {
		if (m_pDataSource->GetSourcePageSpec(uiPage, psTemp)) {
			if (this->IsValidPageSpec(psTemp, PAGE_MIN_ORIGINAL_PRINTABLE)) {
				bGetDefault = FALSE;
				m_psOriginal = psTemp;
			} 
		}
	}

	if (bGetDefault) {
		// THIS SHOULD REALLY NEVER BE NECESSARY
		SHOULD(FALSE);
		this->GetDefaultPageSpec(m_psOriginal, m_msOriginal, FALSE, FALSE);
	}

	//BOOL bGetDefault = TRUE;
	//::PageSpec psTemp ;
	//// 6/25 DEBUG / FIX
	//// THE TARGET DEV MODE SHOULD BE THE DEFAULT STARTING POINT WHEN THE USER SELECTS THAT PRINTER FROM THE LIST
	//PCDEVMODE pdm = (PCDEVMODE) this->m_pDataSource->GetPRDevMode();
	//// 6/25 DEBUG / FIX SHOULD BE SURE TO GET FULL PRINTER NAME HERE
	//if (pdm != NULL && ::GetPageSpec(psTemp, m_msOriginal, pdm, pdm->dmDeviceName) ) {
	//	if (this->IsValidPageSpec(psTemp)) {
	//		bGetDefault = FALSE;
	//		m_psOriginal = psTemp;
	//	} 
	//}
	//if (bGetDefault) {
	//	// THIS SHOULD REALLY NEVER BE NECESSARY
	//	ASSERTFAIL();
	//	this->GetDefaultPageSpec(m_psOriginal, m_msOriginal, FALSE);
	//}
}

BOOL PreviewDialog::UpdateResizedPageSpec(PCDEVMODE pdmNew) {
	// 7/3 PRESERVE OLD DEVMODEKEEPER IF WE FAIL -- SO TRUE FALLBACK TO OLD STATE IS POSSIBLE
	::DevModeKeeper dmkOld( *m_pdmKeeper );

	BOOL bLandscape = (pdmNew != NULL) ? (pdmNew->dmOrientation == DMORIENT_LANDSCAPE) : this->ReadLandscape();
	//7/13
	BOOL bEvenMargins = this->ReadEvenMargins();
	BOOL bRetValue = FALSE;
	BOOL bGetPageSpec = FALSE;
	tstring tstrPrinter;
	if (this->ReadSelectedPrinter(tstrPrinter)) {
		PCDEVMODE pdm = (pdmNew == NULL) ? this->m_pdmKeeper->GetDevMode(tstrPrinter) : pdmNew;
		PDEVMODE pdmTemp = ::DM_Duplicate(pdm);
		pdmTemp->dmOrientation = bLandscape ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
		::PageSpec psTemp;
		//7/13
		//BOOL bEvenMargins = this->ReadEvenMargins();
		if ( ::GetPageSpec(psTemp, m_msResized, pdmTemp, tstrPrinter.c_str(), bEvenMargins, FALSE) ) {
			if (this->IsValidPageSpec(psTemp, PAGE_MIN_RESIZED_PRINTABLE)) {
				BOOL bEnableLandscape = (psTemp.rotDir != ::LandscapeRot::eNone);
				this->EnableLandscape( bEnableLandscape );
				if (bEnableLandscape) {
					this->WriteLandscape( pdmTemp->dmOrientation == DMORIENT_LANDSCAPE );
				}
				m_psResized = psTemp;
				bRetValue = TRUE;
			}
		}
		free(pdmTemp);
	} else {
		//7/13
		this->GetDefaultPageSpec(m_psResized, this->m_msResized, bLandscape, bEvenMargins);
		bRetValue = TRUE;
	}

	if (!bRetValue) {
		* m_pdmKeeper = dmkOld;
	}

	return bRetValue;
}

void PreviewDialog::WriteAutoRotate(IN BOOL b) { 
	this->CheckDlgButton(IDC_CHECK_AUTOROTATE, b); 
}

void PreviewDialog::WriteEvenMargins(IN BOOL b) {
	this->CheckDlgButton(IDC_CHECK_EVENMARGINS, b);
}

void PreviewDialog::WriteImageInfo(IN BOOL bClear, IN PRListViewDialog *pprlvd, IN LPCTSTR lptstrTitle, 
								   IN const SIZED *pszdImage, IN const double *pdZoom) {
	if (bClear) {
		pprlvd->SetInfoText(TEXT(""), 0);
		pprlvd->SetInfoText(TEXT(""), 1);
		pprlvd->SetInfoText(TEXT(""), 2);
	} else {
		pprlvd->SetInfoText(lptstrTitle, 0);
		double dTemp = pszdImage->cx * (*pdZoom);
		TCHAR atstrBuff[32];
		if (dTemp < 36) {
			StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("W: %3.2lf In"), dTemp);
		} else {
			StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("W: %3.2lf Ft"), dTemp/12);
		}
		pprlvd->SetInfoText(atstrBuff, 1);
		dTemp = pszdImage->cy * (*pdZoom);
		if (dTemp < 36) {
			StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("H: %3.2lf In"), dTemp);
		} else {
			StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("H: %3.2lf Ft"), dTemp/12);
		}
		pprlvd->SetInfoText(atstrBuff, 2);
	}
}

void PreviewDialog::WriteLandscape(IN BOOL b) {
	this->CheckDlgButton(IDC_CHECK_LANDSCAPE, b);
}

void PreviewDialog::WriteNoCutGuidelines(IN BOOL b) { 
	this->CheckDlgButton(IDC_CHECK_NOGUIDELINES, b); 
}

void PreviewDialog::WriteOriginalAll(IN BOOL b) {
	this->CheckDlgButton(IDC_RADIO_ALL_ORIGINAL, b);
	this->CheckDlgButton(IDC_RADIO_SELECTION_ORIGINAL, !b);
}
#if 0
void PreviewDialog::WriteResizedAll(IN BOOL b) {
	this->CheckDlgButton(IDC_RADIO_ALL_RESIZED, b);
	this->CheckDlgButton(IDC_RADIO_SELECTION_RESIZED, !b);
}
#endif

void PreviewDialog::WriteSelectedPage(IN uint uiPage) { 
	this->SendDlgItemMessage(IDC_LIST_PAGES, LB_SETCURSEL, (WPARAM) uiPage, 0); 
}

void PreviewDialog::WriteOriginalImageInfo(void) {
	::PRListViewDialog *pprlvd = this->GetOriginalSourceDialog();
	BOOL bHasList = pprlvd->HasList();
	if (bHasList) {
		SIZED szdImage = { RW(m_ssResized.rdSelection_Inches), RH(m_ssResized.rdSelection_Inches) };
		double dZoom = m_rsOriginal.dZoom;
		this->WriteImageInfo(FALSE, pprlvd, TEXT("Source Image"), &szdImage, &dZoom);
	} else {
		this->WriteImageInfo(TRUE, pprlvd, NULL, NULL, NULL);
	}
}

void PreviewDialog::WriteResizedImageInfo(void) {
	::PRListViewDialog *pprlvd = this->GetResizedDialog();
	BOOL bHasList = pprlvd->HasList();
	if (bHasList) {
		SIZED szdImage = { RW(m_ssResized.rdSelection_Inches), RH(m_ssResized.rdSelection_Inches) };
		double dZoom = m_rsResized.dZoom;
		this->WriteImageInfo(FALSE, pprlvd, TEXT("Poster Image"), &szdImage, &dZoom);
	} else {
		this->WriteImageInfo(TRUE, pprlvd, NULL, NULL, NULL);
	}
}

BOOL PreviewDialog::WriteSelectedPrinter(IN LPCTSTR lptstrPrinterName) {
	this->ReadSelectedPrinter(m_tstrLastPrinterSelected);

	HWND hwndPrinterList = this->GetDlgItem(IDC_COMBO_PRINTERS);
	DWORD dwIndex;
	BOOL bFound = FindStringInCombo(&dwIndex, lptstrPrinterName, hwndPrinterList);
	if (bFound) {
		this->SendDlgItemMessage(IDC_COMBO_PRINTERS, CB_SETCURSEL, (WPARAM) dwIndex, 0);
	} else {
		// SET NO SELECTION
		this->SendDlgItemMessage(IDC_COMBO_PRINTERS, CB_SETCURSEL, (WPARAM) -1, 0);
	}
	return bFound;
}

void PreviewDialog::WriteZoom(IN double dZoom) {
	TCHAR atstrBuff[MAX_ZOOM_TCHAR];
	if (dZoom > WRITEZOOM_ROUNDUP_BOUNDARY) {
		// 5/31 AVOID MOSAIC SIZE CHANGING WHEN USER TYPES IN THE SAME PERCENT ZOOM SHOWN --
		// BY ROUNDING UP, ENTERING THE PERCENT CAN ONLY MAKE IT DECREASE, USUALLY MOSAIC WON'T CHANGE
		// BUT NOT AT VERY SMALL ZOOM VALUES, THERE THE RELATIVE ERROR (1.01 PERCENT READS AS 2 PERCENT) IS TOO BIG
		int iZoom = ::RoundUp(dZoom * 100.0);
		::StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("%d"), iZoom);
	} else {
		::StringCchPrintf(atstrBuff, ARRCOUNT(atstrBuff), TEXT("%3.0f"), dZoom * 100.0);
	}
	this->SendDlgItemMessage(IDC_EDIT_ZOOM, WM_SETTEXT, 0, (LPARAM) atstrBuff);
}

	// MAKE SURE ZOOM AND MOSAIC ARE CONSISTENT
	//switch(m_rsResized.mode) {
	//	case RenderSpec::eMosaic: {
	//		::RenderSpec::MosaicFullDimension fulldim;
	//		double dMosaicZoom =