// textbmpView.cpp : implementation of the CTextbmpView class
//
///////////////////////////////////////////////////////////////////////////
//
//
// Copyright: Jacob Boo
// Created: 28-June-1999
//
// A Single Page Printing FrameWork
//
// You are free to use or modify this code without any restrictions.
//
// Credits:
// Special thanks goes to Joe Ismert for providing the VC6.0 fix for the RulerBar
//
//
//======================================================================
//DISCLAIMER:
//
//THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
//THE ENTIRE RISK OF THE USE OF THE SOFTWARE IS ASSUMED BY YOU.
//
//
//THE AUTHOR OF THIS SOFTWARE SPECIFICALLY DISCLAIMS ALL WARRANTIES,
//EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF
//MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFINGEMENT WITH
//RESPECT TO THIS SOFTWARE AND ANY ACCOMPANYING WRITTEN MATERIALS.
//
//
//IN NO EVENT WILL THE AUTHOR BE LIABLE TO YOU FOR
//DAMAGES, INCLUDING ANY LOSS OF PROFITS, DATA, OR OTHER INCIDENTAL OR CONSEQUENTIAL
//DAMAGES ARISING OUT OF YOUR USE OR INABILITY TO USE THIS SOFTWARE, EVEN IF
//THE AUTHOR HAS BEEN SPECIFICALLY ADVISED ON THE
//POSSIBLILITY OF SUCH DAMAGES.
////////////////////////////////////////////////////////////////////////////
//#include <stdio.h>
#include "stdafx.h"
#include "textbmp.h"
#include "textbmpDoc.h"
#include "textbmpView.h"
#include "MainFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView
IMPLEMENT_DYNCREATE(CTextbmpView, CScrollView)
BEGIN_MESSAGE_MAP(CTextbmpView, CScrollView)
//{{AFX_MSG_MAP(CTextbmpView)
ON_WM_CREATE()
ON_COMMAND(ID_VIEW_FITWIDTH, OnZoomFitWidth)
ON_WM_SIZE()
ON_WM_DESTROY()
ON_COMMAND(ID_VIEW_FITHEIGHT, OnZoomFitHeight)
ON_COMMAND(ID_VIEW_ZOOM100, OnViewZoom100)
ON_WM_LBUTTONDOWN()
ON_WM_HSCROLL()
ON_COMMAND(ID_FILE_MARGINS, OnMargins)
ON_WM_ERASEBKGND()
ON_COMMAND(ID_VIEW_ZOOM150, OnViewZoom150)
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM150, OnUpdateViewZoom150)
ON_COMMAND(ID_VIEW_ZOOM125, OnViewZoom125)
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM125, OnUpdateViewZoom125)
ON_COMMAND(ID_VIEW_ZOOM75, OnViewZoom75)
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM75, OnUpdateViewZoom75)
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM100, OnUpdateViewZoom100)
ON_UPDATE_COMMAND_UI(ID_VIEW_FITHEIGHT, OnUpdateViewFitheight)
ON_UPDATE_COMMAND_UI(ID_VIEW_FITWIDTH, OnUpdateViewFitwidth)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)
END_MESSAGE_MAP()
//========================================================
//Definitions for compilation
//need enough high res to allows smooth text scrolling and double buffer painting...
#define MAP_MODE MM_TWIPS; //other choices : MM_HIENGLISH, MM_LOMETRIC
#define XGRAY_MARGIN 1000 //10 mm :units in HIMETRIC added to bottom of gray page, paper will be offet by half of this amount if paper larger than screen
#define YGRAY_MARGIN 1000 //10 mm :units in HIMETRIC added to right of gray page, , paper will be offet by half of this amount if paper larger than screen
//=========================================================
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView construction/destruction
CTextbmpView::CTextbmpView()
{
// TODO: add construction code here
m_ScreenLarger_YD2=0;
m_ScreenLarger_XD2=0;
m_offsetGrayYD2=0;
m_offsetGrayXD2=0;
m_WinOrg.x=0;
m_WinOrg.y=0;
m_GrayMargin.cx=0;
m_GrayMargin.cy=0;
m_ZoomPercent=100;
m_ZoomState=ZOOMFITWIDTH;
m_StoredPt.x=0;
m_StoredPt.y=0;
m_mapmode=MAP_MODE;
//fonts stuff: initialize the m_logfont
ZeroMemory(&m_logfont, sizeof(m_logfont));
m_logfont.lfHeight = 18;
m_logfont.lfWidth = 0;
strcpy((LPSTR)&(m_logfont.lfFaceName), _T("Times New Roman"));
//Set margins to one inch
if (m_mapmode==MM_TWIPS) {
m_rectUserMarginLog.top=1440;
m_rectUserMarginLog.bottom=1440;
m_rectUserMarginLog.left=1440;
m_rectUserMarginLog.right=1440;
}
else if (m_mapmode==MM_LOMETRIC) {
m_rectUserMarginLog.top=254;
m_rectUserMarginLog.bottom=254;
m_rectUserMarginLog.left=254;
m_rectUserMarginLog.right=254;
}
else if (m_mapmode==MM_HIENGLISH) {
m_rectUserMarginLog.top=1000;
m_rectUserMarginLog.bottom=1000;
m_rectUserMarginLog.left=1000;
m_rectUserMarginLog.right=1000;
}
}
CTextbmpView::~CTextbmpView()
{
}
BOOL CTextbmpView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CScrollView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView drawing
void CTextbmpView::OnDraw(CDC* pDC)
{
CTextbmpDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
//For Double Buffer: Simply Set up the Compatible DC and Bitmap
//Using whatever mapmode we are currently in. The DocToClient convert the clip rectangle into device units (pixels)
//The intersectionClipRect is created using current map mode
CDC dc;
CDC* pDrawDC = pDC;
CBitmap bitmap;
CBitmap* pOldBitmap;
// only paint the rect that needs repainting
CRect client;
pDC->GetClipBox(client);
CRect rect = client;
DocToClient(rect);
if (!pDC->IsPrinting())
{
// draw to offscreen bitmap for fast looking repaints
if (dc.CreateCompatibleDC(pDC))
{
if (bitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height()))
{
OnPrepareDC(&dc, NULL);
pDrawDC = &dc;
// offset origin more because bitmap is just piece of the whole drawing
dc.OffsetViewportOrg(-rect.left, -rect.top);
pOldBitmap = dc.SelectObject(&bitmap);
dc.SetBrushOrg(rect.left % 8, rect.top % 8);
// might as well clip to the same rectangle
dc.IntersectClipRect(client);
}
}
}
if (!pDrawDC->IsPrinting()) { //draw the borders
//Fill background of client window gray before setting an mapmode...
::FillRect(pDrawDC->m_hDC,&client, (HBRUSH)GetStockObject(GRAY_BRUSH)); //background
if (m_ZoomState==ZOOMFITWIDTH) {
pDrawDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDrawDC->SetWindowExt(m_ScrollRectLog.right,-m_ScrollRectLog.right);
CSize rSize = pDrawDC->SetViewportExt(m_ClientRectDev.right,m_ClientRectDev.right);
}
else if (m_ZoomState==ZOOMFITHEIGHT) {
long extValue,viewValue;
extValue=labs(m_ScrollRectLog.bottom);
viewValue=labs(m_ClientRectDev.bottom);
pDrawDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDrawDC->SetWindowExt(extValue,-extValue);
CSize rSize = pDrawDC->SetViewportExt(viewValue,viewValue);
}
else if (m_ZoomState==ZOOMIN) {
CSize WinSize = pDrawDC->GetWindowExt();
CSize ViewSize = pDrawDC->GetViewportExt();
ViewSize.cx=MulDiv(ViewSize.cx,m_ZoomPercent,100);
ViewSize.cy=MulDiv(ViewSize.cy,m_ZoomPercent,100);
pDrawDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDrawDC->SetWindowExt(WinSize);
CSize rSize = pDrawDC->SetViewportExt(ViewSize);
}
//Fill physical paper white
::FillRect(pDrawDC->m_hDC,&m_PaperRectLog, (HBRUSH)GetStockObject(WHITE_BRUSH)); //paper
//Draw a dark outline around the paper
CPen *oldPen;
oldPen=pDrawDC->SelectObject(&m_shadowPen);
pDrawDC->MoveTo(m_PaperRectLog.left-1,m_PaperRectLog.top+1);
pDrawDC->LineTo(m_PaperRectLog.right+1,m_PaperRectLog.top+1);
pDrawDC->LineTo(m_PaperRectLog.right+1,m_PaperRectLog.bottom-1);
pDrawDC->LineTo(m_PaperRectLog.left-1,m_PaperRectLog.bottom-1);
pDrawDC->LineTo(m_PaperRectLog.left-1,m_PaperRectLog.top+1);
//Draw the printable area
pDrawDC->SelectObject(&m_dashPen);
pDrawDC->MoveTo(m_PageRectLog.left,m_PageRectLog.top);
pDrawDC->LineTo(m_PageRectLog.right,m_PageRectLog.top);
pDrawDC->LineTo(m_PageRectLog.right,m_PageRectLog.bottom);
pDrawDC->LineTo(m_PageRectLog.left,m_PageRectLog.bottom);
pDrawDC->LineTo(m_PageRectLog.left,m_PageRectLog.top);
pDrawDC->SelectObject(oldPen);
pDrawDC->SetWindowOrg(m_WinOrg);
}
CRect rMargins ,rPaper, rPrintable;
GetPageInfo(&rMargins, &rPaper, &rPrintable);
DrawHere(pDrawDC,rPaper,rPrintable,rMargins);
//BitBlt the Bitmap in MM_TEXT Mode
if (pDrawDC != pDC)
{
pDC->SetViewportOrg(0, 0);
pDC->SetWindowOrg(0,0);
pDC->SetMapMode(MM_TEXT);
dc.SetViewportOrg(0, 0);
dc.SetWindowOrg(0,0);
dc.SetMapMode(MM_TEXT);
pDC->BitBlt(rect.left, rect.top, rect.Width(), rect.Height(),
&dc, 0, 0, SRCCOPY);
dc.SelectObject(pOldBitmap);
}
}
void CTextbmpView::DrawHere(CDC* pDC,CRect PaperRect, CRect PrintableRect,CRect MarginsRect)
{
TRACE("\nPaperRect top=%d, left=%d, bottom=%d, right=%d",PaperRect.top,PaperRect.left,PaperRect.bottom,PaperRect.right);
TRACE("\nPrintableRect top=%d, left=%d, bottom=%d, right=%d",PrintableRect.top,PrintableRect.left,PrintableRect.bottom,PrintableRect.right);
TRACE("\nMarginsRect top=%d, left=%d, bottom=%d, right=%d",MarginsRect.top,MarginsRect.left,MarginsRect.bottom,MarginsRect.right);
//Assuming A4 Sized Paper, with PaperRect dimension : top=168 twips, left=-168 twips, bottom=-16672 twips, right=11740 twips
//1 inch = 1440 twips
//////////////////////////////////////////////////////////////////////////////////////
//ADD Drawing code here!!!
//Using SetWinOrg, SetViewPortOrg ,SetWindowsExt or SetViewportExt functions here may cause unexpected results.
CString szText;
szText="This program provides a framework for a simple printing program. The white area represents the paper. You can left click to place a small circle anywhere on the paper.";
//Text Bounds
CRect newRect;
newRect.left=2740;
newRect.right=9000; //7 inch width
newRect.top=-1000; //y values are negative
newRect.bottom=-8740; //6 inch deep
//Font Stuff + Draw Text
CFont* pOldFont=NULL;
CFont cFont;
LOGFONT curlogFont;
curlogFont=m_logfont;
curlogFont.lfWidth=m_logfont.lfWidth*20;
curlogFont.lfHeight=m_logfont.lfHeight*20;
if (curlogFont.lfHeight>0) curlogFont.lfHeight=-curlogFont.lfHeight;
if (curlogFont.lfWidth>0) curlogFont.lfWidth=-curlogFont.lfWidth;
cFont.CreateFontIndirect(&curlogFont);
pOldFont=pDC->SelectObject(&cFont);
pDC->DrawText( szText, newRect, DT_LEFT | DT_WORDBREAK );
pDC->SelectObject(pOldFont);
cFont.DeleteObject();
//Draw some shapes
pDC->RoundRect( 500, -3000, 4500, -5000, 1000, 1000 );
pDC->RoundRect( 2500, -3500, 6500, -5500, 1000, 1000 );
pDC->Rectangle( 7500, -3500, 9500, -5500);
pDC->Ellipse( 7500, -3500, 9500, -5500);
//Draw a horizontal 1 inch line
pDC->MoveTo(0,-2000);
pDC->LineTo(1440,-2000);
//Draw a small circle
pDC->Ellipse(m_StoredPt.x-30,m_StoredPt.y+30,m_StoredPt.x+30,m_StoredPt.y-30);
}
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView printing
BOOL CTextbmpView::OnPreparePrinting(CPrintInfo* pInfo)
{
// default preparation
return DoPreparePrinting(pInfo);
}
void CTextbmpView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add extra initialization before printing
}
void CTextbmpView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// TODO: add cleanup after printing
}
void CTextbmpView::OnFilePrintPreview() {
CMainFrame* mainWnd=(CMainFrame*) AfxGetMainWnd( );
//Hide Rulers before preview
(mainWnd->m_wndRulerBarH).ShowWindow(SW_HIDE);
(mainWnd->m_wndRulerBarV).ShowWindow(SW_HIDE);
CScrollView::OnFilePrintPreview();
}
void CTextbmpView::OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo,
POINT pt, CPreviewView* pView) {
//Restore Rulers after preview
CMainFrame* mainWnd=(CMainFrame*) AfxGetMainWnd();
(mainWnd->m_wndRulerBarH).ShowWindow(SW_SHOW);
(mainWnd->m_wndRulerBarV).ShowWindow(SW_SHOW);
CScrollView::OnEndPrintPreview(pDC, pInfo,
pt, pView);
}
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView diagnostics
#ifdef _DEBUG
void CTextbmpView::AssertValid() const
{
CScrollView::AssertValid();
}
void CTextbmpView::Dump(CDumpContext& dc) const
{
CScrollView::Dump(dc);
}
CTextbmpDoc* CTextbmpView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTextbmpDoc)));
return (CTextbmpDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CTextbmpView message handlers
int CTextbmpView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CScrollView::OnCreate(lpCreateStruct) == -1)
return -1;
//Pen Creation
m_shadowPen.CreatePen(PS_SOLID, 3, RGB(64,64,64));
m_dashPen.CreatePen(PS_DOT, 1, RGB(0,0,0));
// TODO: Add your specialized creation code here
SetPageGlobals();
return 0;
}
//Set Page Globals
int CTextbmpView::SetPageGlobals() {
long PageWidthDev=0 ;
long PageHeightDev=0 ;
long LOGPInchX=0;
long LOGPInchY=0;
long PhyWidth=0;
long PhyHeight=0;
long PhyOffsetX=0;
long PhyOffsetY=0;
long PrinterType=0;
CDC *printDC = NULL;
printDC = CreatePrinterDC();
if (printDC==NULL) {
SetDefaultPaper();
return FALSE;
}
PageWidthDev = printDC->GetDeviceCaps(HORZRES);
PageHeightDev = printDC->GetDeviceCaps(VERTRES);
LOGPInchX = printDC->GetDeviceCaps(LOGPIXELSX);
LOGPInchY= printDC->GetDeviceCaps(LOGPIXELSY);
PhyWidth = printDC->GetDeviceCaps(PHYSICALWIDTH);
PhyHeight = printDC->GetDeviceCaps(PHYSICALHEIGHT);
PhyOffsetX = printDC->GetDeviceCaps(PHYSICALOFFSETX);
PhyOffsetY = printDC->GetDeviceCaps(PHYSICALOFFSETY);
PrinterType = printDC->GetDeviceCaps(TECHNOLOGY);
if ((PrinterType!=DT_PLOTTER) && (PrinterType!=DT_RASPRINTER)) {
SetDefaultPaper();
return FALSE;
}
CSize Tsize(PhyWidth,PhyHeight);
printDC->SetMapMode(m_mapmode);
printDC->DPtoLP(&Tsize);
m_PaperSizeLog=Tsize;
m_OffsetDev.x=PhyOffsetX;
m_OffsetDev.y=PhyOffsetY;
m_OffsetLog=m_OffsetDev;
printDC->DPtoLP(&m_OffsetLog);
m_PageSizeDev.cx=PageWidthDev;
m_PageSizeDev.cy=PageHeightDev;
m_PageSizeLog=m_PageSizeDev;
printDC->DPtoLP(&m_PageSizeLog);
::DeleteDC(printDC->GetSafeHdc());
return TRUE;
}
int CTextbmpView::OnSetPageGlobals() {
SetPageGlobals();
//This is to make sure the gray area will be updated correctly
SetScreenGlobals();
EventPaperChange();
Invalidate(TRUE);
return TRUE;
}
void CTextbmpView::OnInitialUpdate()
{
CScrollView::OnInitialUpdate();
// TODO: Add your specialized code here and/or call the base class
}
void CTextbmpView::SetScreenGlobals()
{
CClientDC xDC(this);
::GetClientRect(this->m_hWnd, &m_ClientRectDev);
xDC.SetMapMode(m_mapmode);
m_ClientRectLog=m_ClientRectDev;
xDC.DPtoLP(&m_ClientRectLog);
CSize TMargin(XGRAY_MARGIN,YGRAY_MARGIN);
xDC.HIMETRICtoLP(&TMargin);
m_GrayMargin=TMargin;
m_offsetGrayYD2=TMargin.cy/2;
m_offsetGrayXD2=TMargin.cx/2;
//Compare Client Window Size To Paper Size
//First set the m_MaxRectLog to the logical client rectangle
m_MaxRectLog=m_ClientRectLog;
m_PaperXLargerThanClientX=TRUE;
m_MaxRectLog.right=m_PaperSizeLog.cx;
m_PaperYLargerThanClientY=TRUE;
m_MaxRectLog.bottom=m_PaperSizeLog.cy;
SetGlobalRect();
CSize Scrollsize;
if (m_ZoomState==ZOOMIN) {
//Set scroll size to equal that of the gray rectangle
Scrollsize.cx=MulDiv(m_ScrollRectLog.right,m_ZoomPercent,100);
Scrollsize.cy=MulDiv(m_ScrollRectLog.bottom,m_ZoomPercent,100);
}
else if (m_ZoomState==ZOOMFITWIDTH) {
Scrollsize.cx=m_ClientRectLog.right;
Scrollsize.cy=MulDiv(m_ScrollRectLog.bottom,m_ClientRectLog.right ,m_ScrollRectLog.right);
}
else if (m_ZoomState==ZOOMFITHEIGHT) { //Actually means fit height
Scrollsize.cx=MulDiv(m_ScrollRectLog.right,m_ClientRectLog.bottom ,m_ScrollRectLog.bottom);
Scrollsize.cy=m_ClientRectLog.bottom;
}
if (Scrollsize.cy<0) Scrollsize.cy=-Scrollsize.cy;
//TRACE("\nm_MaxRectLog = %d %d\n",m_MaxRectLog.right,m_MaxRectLog.bottom);
//TRACE("\nScrollSize =%d %d\n",Scrollsize.cx,Scrollsize.cy);
SetScrollSizes(m_mapmode, Scrollsize);
}
void CTextbmpView::OnSize(UINT nType, int cx, int cy)
{
CScrollView::OnSize(nType, cx, cy);
// TODO: Add your message handler code here
SetScreenGlobals();
}
void CTextbmpView::OnDestroy()
{
CScrollView::OnDestroy();
// TODO: Add your message handler code here
m_shadowPen.DeleteObject();
m_dashPen.DeleteObject();
}
void CTextbmpView::SetGlobalRect()
{
//Assume that m_MaxRectLog is properly initialized
m_ScrollRectLog=m_MaxRectLog;
if (!m_PaperYLargerThanClientY) { //ScreenLarger
//Need inversion for m_MaxRectLog
m_ScrollRectLog.bottom=-m_MaxRectLog.bottom;
m_PaperRectLog.top=-m_ScreenLarger_YD2;
m_PaperRectLog.bottom=-m_PaperSizeLog.cy-m_ScreenLarger_YD2;
m_PageRectLog.top=m_OffsetLog.y-m_ScreenLarger_YD2;; //because it is point...so no need to invert in the logcal coordinates
m_PageRectLog.bottom=m_PageRectLog.top-m_PageSizeLog.cy; //need to invert size for this map mode
}
else { //Paper Larger
m_ScrollRectLog.bottom=-m_MaxRectLog.bottom-m_GrayMargin.cy;
m_PaperRectLog.top=-m_offsetGrayYD2;
m_PaperRectLog.bottom=-m_PaperSizeLog.cy-m_offsetGrayYD2; //because it is size...so must invert
m_PageRectLog.top=m_OffsetLog.y-m_offsetGrayYD2; //because it is point...so no need to invert in the logcal coordinates
m_PageRectLog.bottom=m_PageRectLog.top-m_PageSizeLog.cy; //need to invert size for this map mode
}
if (!m_PaperXLargerThanClientX) { //ScreenLarger
m_ScrollRectLog.right=m_MaxRectLog.right;
m_PaperRectLog.left=m_ScreenLarger_XD2;
m_PaperRectLog.right=m_PaperSizeLog.cx+m_ScreenLarger_XD2;
m_PageRectLog.left=m_OffsetLog.x+m_ScreenLarger_XD2;
m_PageRectLog.right=m_PageRectLog.left+m_PageSizeLog.cx;
}
else { //Paper Larger
m_ScrollRectLog.right=m_MaxRectLog.right+m_GrayMargin.cx;
m_PaperRectLog.left=m_offsetGrayXD2;
m_PaperRectLog.right=m_PaperSizeLog.cx+m_offsetGrayXD2; //because it is size...so must invert
m_PageRectLog.left=m_OffsetLog.x+m_offsetGrayXD2;
m_PageRectLog.right=m_PageRectLog.left+m_PageSizeLog.cx;
}
m_WinOrg.x=-(m_PageRectLog.left);
m_WinOrg.y=-(m_PageRectLog.top);
}
void CTextbmpView::OnZoomFitHeight()
{
// TODO: Add your command handler code here
m_ZoomState=ZOOMFITHEIGHT;
SetScreenGlobals();
Invalidate(TRUE);
}
//Fit Width
void CTextbmpView::OnZoomFitWidth()
{
// TODO: Add your command handler code here
m_ZoomState=ZOOMFITWIDTH;
SetScreenGlobals();
Invalidate(TRUE);
}
void CTextbmpView::SetDefaultPaper()
{
//Set 8.5 inch by 11 inch
if (m_mapmode==MM_TWIPS) {
m_PaperSizeLog.cx=12244;
m_PaperSizeLog.cy=15844;
m_OffsetLog.x=168;
m_OffsetLog.y=-168;
m_PageSizeLog.cx=11904;
m_PageSizeLog.cy=14880;
}
else if (m_mapmode==MM_HIENGLISH) {
m_PaperSizeLog.cx=8503;
m_PaperSizeLog.cy=11003;
m_OffsetLog.x=117;
m_OffsetLog.y=-117;
m_PageSizeLog.cx=8267;
m_PageSizeLog.cy=10333;
}
else if (m_mapmode==MM_LOMETRIC) {
m_PaperSizeLog.cx=2160;
m_PaperSizeLog.cy=2795;
m_OffsetLog.x=30;
m_OffsetLog.y=-30;
m_PageSizeLog.cx=2100;
m_PageSizeLog.cy=2625;
}
}
void CTextbmpView::OnLButtonDown(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
ScreenToPaper(&point);
m_StoredPt=point;
Invalidate();
CScrollView::OnLButtonDown(nFlags, point);
}
void CTextbmpView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
{
// TODO: Add your specialized code here and/or call the base class
CScrollView::OnPrepareDC(pDC, pInfo);
}
void CTextbmpView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
CScrollView::OnHScroll(nSBCode, nPos, pScrollBar);
}
void CTextbmpView::DocToClient(CRect &rect)
{
CClientDC drawdc(this);
OnPrepareDC(&drawdc,NULL);
drawdc.LPtoDP(rect);
rect.NormalizeRect();
}
inline int roundleast(int n)
{
int mod = n%10;
n -= mod;
if (mod >= 5)
n += 10;
else if (mod <= -5)
n -= 10;
return n;
}
static void RoundRect(LPRECT r1)
{
r1->left = roundleast(r1->left);
r1->right = roundleast(r1->right);
r1->top = roundleast(r1->top);
r1->bottom = roundleast(r1->bottom);
}
static void MulDivRect(LPRECT r1, LPRECT r2, int num, int div)
{
r1->left = MulDiv(r2->left, num, div);
r1->top = MulDiv(r2->top, num, div);
r1->right = MulDiv(r2->right, num, div);
r1->bottom = MulDiv(r2->bottom, num, div);
}
void CTextbmpView::OnMargins()
{
// TODO: Add your command handler code here
CPageSetupDialog dlg;
PAGESETUPDLG& psd = dlg.m_psd;
psd.Flags |= PSD_MARGINS | PSD_INTHOUSANDTHSOFINCHES | PSD_DISABLEORIENTATION | PSD_DISABLEPAPER | PSD_DISABLEPRINTER;
int nUnitsPerInch = 1000;
//convert m_rectUserMarginLog in logical units to thousandths of inches
if (m_mapmode==MM_TWIPS)
MulDivRect(&psd.rtMargin, m_rectUserMarginLog, nUnitsPerInch, 1440);
else if (m_mapmode==MM_LOMETRIC)
MulDivRect(&psd.rtMargin, m_rectUserMarginLog, nUnitsPerInch, 254);
else if (m_mapmode==MM_HIENGLISH)
MulDivRect(&psd.rtMargin, m_rectUserMarginLog, nUnitsPerInch, 1000);
RoundRect(&psd.rtMargin);
PRINTDLG pd;
LPDEVNAMES ptrdevnames_pd;
LPDEVMODE ptrdevmode_pd;
LPDEVNAMES ptrdevnames_psd;
LPDEVMODE ptrdevmode_psd;
if (AfxGetApp()->GetPrinterDeviceDefaults(&pd)) {
//Copy default settings and put them into the page setup dialog
ptrdevnames_pd = (LPDEVNAMES) GlobalLock(pd.hDevNames);
ptrdevmode_pd = (LPDEVMODE) GlobalLock(pd.hDevMode);
if (psd.hDevNames) GlobalFree(psd.hDevNames);
if (psd.hDevMode) GlobalFree(psd.hDevMode);
psd.hDevNames = GlobalAlloc(GPTR, GlobalSize (pd.hDevNames));
psd.hDevMode = GlobalAlloc(GPTR, GlobalSize (pd.hDevMode));
ptrdevnames_psd = (LPDEVNAMES) GlobalLock(psd.hDevNames);
ptrdevmode_psd = (LPDEVMODE) GlobalLock(psd.hDevMode);
memcpy(ptrdevnames_psd,ptrdevnames_pd, (size_t) GlobalSize (pd.hDevNames));
memcpy(ptrdevmode_psd,ptrdevmode_pd, (size_t) GlobalSize (pd.hDevMode));
GlobalUnlock(ptrdevmode_pd);
GlobalUnlock(ptrdevmode_psd);
GlobalUnlock(ptrdevnames_pd);
GlobalUnlock(ptrdevnames_psd);
}
else {
psd.hDevNames = NULL;
psd.hDevMode = NULL;
}
if (dlg.DoModal() == IDOK)
{
RoundRect(&psd.rtMargin);
//convert psd.rtMargin in thousandths of inches to logical units
if (m_mapmode==MM_TWIPS)
MulDivRect(m_rectUserMarginLog, &psd.rtMargin, 1440, nUnitsPerInch);
else if (m_mapmode==MM_LOMETRIC)
MulDivRect(m_rectUserMarginLog, &psd.rtMargin, 254, nUnitsPerInch);
else if (m_mapmode==MM_HIENGLISH)
MulDivRect(m_rectUserMarginLog, &psd.rtMargin, 1000, nUnitsPerInch);
EventMarginsChange();
}
}
void CTextbmpView::GetPaperData(CRect& margins, CRect& paperrectpix, CSize& papersizepix, CSize& papersizelog)
{
CClientDC drawdc(this);
AdjustMapMode(&drawdc,FALSE);
//Margins Data
CRect MarginRectPixel;
MarginRectPixel=m_rectUserMarginLog;
drawdc.LPtoDP(&MarginRectPixel);
MarginRectPixel.top=abs(MarginRectPixel.top);
MarginRectPixel.bottom=abs(MarginRectPixel.bottom);
MarginRectPixel.left=abs(MarginRectPixel.left);
MarginRectPixel.right=abs(MarginRectPixel.right);
margins=MarginRectPixel;
//PaperRect Data
CRect PaperRectPixel;
PaperRectPixel=m_PaperRectLog;
drawdc.LPtoDP(&PaperRectPixel);
paperrectpix=PaperRectPixel;
//PaperSize in screen pixels
CSize PaperSizePixel;
PaperSizePixel=m_PaperSizeLog;
drawdc.LPtoDP(&PaperSizePixel);
papersizepix=PaperSizePixel;
//Logical PaperSize Data
papersizelog=m_PaperSizeLog;
}
void CTextbmpView::AdjustMapMode(CDC *pDC, BOOL bShiftOrigin)
{
pDC->SetMapMode(m_mapmode);
if (m_ZoomState==ZOOMFITWIDTH) {
pDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDC->SetWindowExt(m_ScrollRectLog.right,-m_ScrollRectLog.right);
CSize rSize = pDC->SetViewportExt(m_ClientRectDev.right,m_ClientRectDev.right);
}
else if (m_ZoomState==ZOOMFITHEIGHT) {
long extValue,viewValue;
extValue=labs(m_ScrollRectLog.bottom);
viewValue=labs(m_ClientRectDev.bottom);
pDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDC->SetWindowExt(extValue,-extValue);
CSize rSize = pDC->SetViewportExt(viewValue,viewValue);
}
else if (m_ZoomState==ZOOMIN) {
CSize WinSize = pDC->GetWindowExt();
CSize ViewSize = pDC->GetViewportExt();
ViewSize.cx=MulDiv(ViewSize.cx,m_ZoomPercent,100);
ViewSize.cy=MulDiv(ViewSize.cy,m_ZoomPercent,100);
pDC->SetMapMode(MM_ISOTROPIC); //gives WYSIWYG
CSize vSize = pDC->SetWindowExt(WinSize);
CSize rSize = pDC->SetViewportExt(ViewSize);
}
if (bShiftOrigin) pDC->SetWindowOrg(m_WinOrg);
}
BOOL CTextbmpView::OnEraseBkgnd(CDC* pDC)
{
// TODO: Add your message handler code here and/or call default
return TRUE;
//return CScrollView::OnEraseBkgnd(pDC);
}
CDC* CTextbmpView::CreatePrinterDC()
{
PRINTDLG PrtDlg;
HDC hDC;
if (!AfxGetApp()->GetPrinterDeviceDefaults(&PrtDlg))
{
return NULL;
}
else
{
CPrintDialog dlg(FALSE);
dlg.m_pd.hDevMode = PrtDlg.hDevMode;
dlg.m_pd.hDevNames = PrtDlg.hDevNames;
hDC = dlg.CreatePrinterDC();
}
CDC* pDC = CDC::FromHandle(hDC);
pDC->m_bPrinting = TRUE;
return pDC;
}
//Not yet tested...
void CTextbmpView::PaperToScreen(CSize* size)
{
CClientDC drawdc(this);
OnPrepareDC(&drawdc);
AdjustMapMode(&drawdc,TRUE);
drawdc.LPtoDP(size);
}
void CTextbmpView::PaperToScreen(CPoint* point)
{
CClientDC drawdc(this);
OnPrepareDC(&drawdc);
AdjustMapMode(&drawdc,TRUE);
drawdc.LPtoDP(point,1);
}
void CTextbmpView::ScreenToPaper(CSize* size)
{
CClientDC drawdc(this);
OnPrepareDC(&drawdc);
AdjustMapMode(&drawdc,TRUE);
drawdc.DPtoLP(size);
}
void CTextbmpView::ScreenToPaper(CPoint* point)
{
CClientDC drawdc(this);
OnPrepareDC(&drawdc);
AdjustMapMode(&drawdc,TRUE);
drawdc.DPtoLP(point,1);
}
void CTextbmpView::OnViewZoom150()
{
// TODO: Add your command handler code here
m_ZoomPercent=150;
m_ZoomState=ZOOMIN;
SetScreenGlobals();
Invalidate(TRUE);
}
void CTextbmpView::OnUpdateViewZoom150(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck((m_ZoomState==ZOOMIN) && (m_ZoomPercent==150));
}
void CTextbmpView::OnViewZoom125()
{
// TODO: Add your command handler code here
m_ZoomPercent=125;
m_ZoomState=ZOOMIN;
SetScreenGlobals();
Invalidate(TRUE);
}
void CTextbmpView::OnUpdateViewZoom125(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck((m_ZoomState==ZOOMIN) && (m_ZoomPercent==125));
}
void CTextbmpView::OnViewZoom75()
{
// TODO: Add your command handler code here
m_ZoomPercent=75;
m_ZoomState=ZOOMIN;
SetScreenGlobals();
Invalidate(TRUE);
}
void CTextbmpView::OnUpdateViewZoom75(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck((m_ZoomState==ZOOMIN) && (m_ZoomPercent==75));
}
void CTextbmpView::OnUpdateViewZoom100(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck((m_ZoomState==ZOOMIN) && (m_ZoomPercent==100));
}
void CTextbmpView::OnViewZoom100()
{
// TODO: Add your command handler code here
m_ZoomPercent=100;
m_ZoomState=ZOOMIN;
SetScreenGlobals();
Invalidate(TRUE);
}
void CTextbmpView::OnUpdateViewFitheight(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck(m_ZoomState==ZOOMFITHEIGHT);
}
void CTextbmpView::OnUpdateViewFitwidth(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->SetCheck(m_ZoomState==ZOOMFITWIDTH);
}
void CTextbmpView::EventPaperChange()
{
CRect rMargins, rPaper, rPrintable;
GetPageInfo(&rMargins, &rPaper, &rPrintable);
TRACE("\nrMargins top=%d, left=%d, bottom=%d, right=%d",rMargins.top,rMargins.left,rMargins.bottom,rMargins.right);
TRACE("\nrPaper top=%d, left=%d, bottom=%d, right=%d",rPaper.top,rPaper.left,rPaper.bottom,rPaper.right);
TRACE("\nrPrintable top=%d, left=%d, bottom=%d, right=%d",rPrintable.top,rPrintable.left,rPrintable.bottom,rPrintable.right);
//This event is called after the print setup dialog has been displayed
//Todo: add code here
}
void CTextbmpView::EventMarginsChange()
{
CRect rMargins ,rPaper, rPrintable;
GetPageInfo(&rMargins, &rPaper, &rPrintable);
//This event is called after the margins setup dialog has been displayed and the user clicked OK
//Todo: add code here
}
void CTextbmpView::GetPageInfo(CRect* rectMarginsLog, CRect* rectPaperLog, CRect* rectPrintableLog)
{
int orgx,orgy;
orgx=m_PageRectLog.left;
orgy=m_PageRectLog.top;
rectPaperLog->top=m_PaperRectLog.top-orgy;
rectPaperLog->bottom=m_PaperRectLog.bottom-orgy;
rectPaperLog->left=m_PaperRectLog.left-orgx;
rectPaperLog->right=m_PaperRectLog.right-orgx;
rectPrintableLog->top=m_PageRectLog.top-orgy;
rectPrintableLog->bottom=m_PageRectLog.bottom-orgy;
rectPrintableLog->left=m_PageRectLog.left-orgx;
rectPrintableLog->right=m_PageRectLog.right-orgx;
rectMarginsLog->top=rectPaperLog->top-m_rectUserMarginLog.top;
rectMarginsLog->bottom=rectPaperLog->bottom+m_rectUserMarginLog.bottom;
rectMarginsLog->left=rectPaperLog->left+m_rectUserMarginLog.left;
rectMarginsLog->right=rectPaperLog->right-m_rectUserMarginLog.right;
}