home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / gdi / fonts / gridfont / view.cxx < prev    next >
C/C++ Source or Header  |  1997-10-05  |  12KB  |  433 lines
  1. //--------------------------------------------------------------------
  2. // File: View.Cxx
  3. //
  4. // Classes: 
  5. //      CClientCanvas - Device context for client area
  6. //      CPrintCanvas  - Device context for printing
  7. //
  8. //      CView          - Base class for Views 
  9. //      CScrollaleView - Scrollable View
  10. //      CFullPageView  - NonScrollable FullPage View
  11. //
  12. // History: 22-Jan-1993 Asmusf  Created
  13. //
  14. // Copyright (C) 1993-1997 Microsoft Corp. All Rights reserved
  15. //
  16. //--------------------------------------------------------------------
  17. #include <windows.h>
  18. #include <windowsx.h>
  19. #include <commdlg.h>
  20. #include "app.h"
  21. #include "view.hxx"
  22. #include "grid.hxx"
  23.  
  24. //+--------------------------------------------------------
  25. // Class:       CView
  26. //
  27. // Purpose:     Standard fixed View for printing, or base class
  28. //
  29. // History:     22-Jan-1993     asmusf  created
  30. //----------------------------------------------------------
  31. CView::CView(int cx, int cy)
  32. {
  33.         _iScale = 100;        // percentage magnification
  34.         _ptOrg.x = 0;         // 0..(PAGEWIDTH - widht of window) 
  35.         _ptOrg.y = 0;         // 0..(PAGEHEIGHT - height of window)
  36.         _ptScroll.x = 0;      // 0..PAGEWIDTH
  37.         _ptScroll.y = 0;      // 0..PAGEHEIGHT
  38.         _size.cx = cx;        // width of window (dev. coord)
  39.         _size.cy = cy;        // widht of window (dev. coord)
  40. }
  41.  
  42. void CView::SetSize( int cx, int cy)
  43. {
  44.         _size.cx = cx;
  45.         _size.cy = cy;
  46. }
  47.  
  48. void CView::Invalidate(HWND hwnd, LPRECT lpRect)
  49. {
  50.         InvalidateRect(hwnd, lpRect, TRUE);             
  51. }
  52.  
  53. BOOL CView::Paint(CCanvas& canvas, CModel * _pModel, RECT rc)
  54. {
  55.         // Scale using MapMode = logical TWIPS
  56.         canvas.Scale(_iScale);
  57.         
  58.         // Client rect in logical coordinates
  59.         _ptClient.x=_size.cx;
  60.         _ptClient.y=_size.cy;
  61.         canvas.DPtoLP(&_ptClient);
  62.  
  63.         // Adjust GDIwindow origin, set _ptOrg
  64.         Scroll(canvas);
  65.  
  66.         // ClipRectangle in logical coordinates
  67.         POINT pt;
  68.         pt.x = rc.left; pt.y = rc.top;
  69.         canvas.DPtoLP(&pt);
  70.         rc.left = pt.x; rc.top = pt.y;
  71.  
  72.         pt.x = rc.right; pt.y = rc.bottom;
  73.         canvas.DPtoLP(&pt);
  74.         rc.right = pt.x; rc.bottom = pt.y;
  75.  
  76.  
  77.         // Paint
  78.         _pModel->Paint(canvas, rc);
  79.  
  80.         return TRUE;  // screen Paints don't fail
  81. }
  82.  
  83. UINT CView::Hittest(CCanvas& canvas, POINT ptTest, CModel * _pModel)
  84. {
  85.         // Scale using MapMode = logical TWIPS
  86.         canvas.Scale(_iScale);
  87.         
  88.         // Client rect in logical coordinates
  89.         _ptClient.x=_size.cx;
  90.         _ptClient.y=_size.cy;
  91.         canvas.DPtoLP(&_ptClient);
  92.  
  93.         // Adjust GDIwindow origin, set _ptOrg
  94.         Scroll(canvas);
  95.  
  96.         // Hittest
  97.  
  98.         canvas.DPtoLP(&ptTest);
  99.         return _pModel->Hittest( ptTest);
  100. }
  101.  
  102. void CView::Scroll(CCanvas &canvas)
  103. {
  104.         int dx=MulDiv(_ptClient.x,_ptScroll.x,PAGEWIDTH);
  105.         int dy=MulDiv(_ptClient.y,_ptScroll.y,PAGEHEIGHT);
  106.  
  107.         // Adjust GDIwindow origin, set _ptOrg
  108.         _ptOrg.x = _ptScroll.x-dx;
  109.         _ptOrg.y = _ptScroll.y-dy;
  110.         
  111.         canvas.Scroll(_ptOrg.x, _ptOrg.y);
  112. }
  113.  
  114. //+--------------------------------------------------------
  115. // Class:       CScrollableView
  116. //
  117. // Purpose:     View for scrollable window
  118. //
  119. // History:     22-Jan-1993     asmusf  created
  120. //----------------------------------------------------------
  121. void CScrollableView::SetHScrollPos(HWND hwnd, WPARAM wParam, LPARAM lParam, CModel * pModel)
  122. {
  123.     CScreenCanvas canvas(hwnd);
  124.     int nScrollPos = GetScrollPos( hwnd, SB_HORZ );
  125.     canvas.Scale(_iScale);
  126.  
  127.  
  128.     SIZE size;
  129.     pModel->GetLineSize(&size);
  130.  
  131.     // scroll position relative to page dimension
  132.     switch (wParam)
  133.     {
  134.     case SB_LINEUP:
  135.          nScrollPos -= 2 * size.cx;
  136.          break;
  137.     case SB_LINEDOWN:
  138.          nScrollPos += 2 * size.cx;
  139.          break;
  140.  
  141.     case SB_PAGEUP:
  142.          nScrollPos -= _ptClient.x; // size of Window in log coord
  143.          break;
  144.  
  145.     case SB_PAGEDOWN:
  146.          nScrollPos += _ptClient.x;
  147.          break;
  148.  
  149.     case SB_THUMBPOSITION:
  150.          nScrollPos = LOWORD(lParam);
  151.          break;
  152.  
  153.     default:
  154.          break;
  155.     }
  156.                       
  157.     nScrollPos = max( 0, min (nScrollPos, PAGEWIDTH));
  158.     
  159.     POINT pt;
  160.     pt.x =  GetScrollPos( hwnd, SB_HORZ ) - nScrollPos;
  161.     if( pt.x )
  162.     {
  163.         SetScrollPos(hwnd, SB_HORZ, nScrollPos, TRUE );
  164.  
  165.         pt.y = 0;
  166.         canvas.LPtoDP(&pt);
  167.  
  168.         pt.x -= MulDiv( _ptClient.x, pt.x, PAGEWIDTH);
  169.         ScrollWindow(hwnd, pt.x, pt.y, NULL, NULL );    
  170.     }
  171.     _ptScroll.x = nScrollPos;
  172. }
  173.  
  174. void CScrollableView::SetVScrollPos(HWND hwnd, WPARAM wParam, LPARAM lParam, CModel * pModel)
  175. {
  176.     CScreenCanvas canvas(hwnd);
  177.     int nScrollPos = GetScrollPos( hwnd, SB_VERT );
  178.     canvas.Scale(_iScale);
  179.  
  180.  
  181.     SIZE size;
  182.     pModel->GetLineSize(&size);
  183.  
  184.     // scroll position relative to page dimension
  185.     switch (wParam)
  186.     {
  187.     case SB_LINEUP:
  188.          nScrollPos -= 2 * size.cy;
  189.          break;
  190.     case SB_LINEDOWN:
  191.          nScrollPos += 2 * size.cy;
  192.          break;
  193.  
  194.     case SB_PAGEUP:
  195.          nScrollPos -= _ptClient.y; // size of Window in log coord
  196.          break;
  197.  
  198.     case SB_PAGEDOWN:
  199.          nScrollPos += _ptClient.y;
  200.          break;
  201.  
  202.     case SB_THUMBPOSITION:
  203.          nScrollPos = LOWORD(lParam);
  204.          break;
  205.  
  206.     default:
  207.          break;
  208.     }
  209.                       
  210.     nScrollPos = max( 0, min (nScrollPos, PAGEHEIGHT));
  211.     
  212.     POINT pt;
  213.     pt.y =  GetScrollPos( hwnd, SB_VERT ) - nScrollPos;
  214.     if( pt.y )
  215.     {
  216.         SetScrollPos(hwnd, SB_VERT, nScrollPos, TRUE );
  217.  
  218.         pt.x = 0;
  219.         canvas.LPtoDP(&pt);
  220.  
  221.         pt.y -= MulDiv( _ptClient.y, pt.y, PAGEHEIGHT);
  222.         ScrollWindow(hwnd, pt.x, pt.y, NULL, NULL );    
  223.     }
  224.     _ptScroll.y = nScrollPos;
  225. }
  226.  
  227. //+--------------------------------------------------------
  228. // Class:       CPrintCanvas
  229. //
  230. // Purpose:     Device Context for Printing
  231. //
  232. // History:     22-Jan-1993     asmusf  created
  233. //----------------------------------------------------------
  234.  
  235. // fully inline //
  236.  
  237. //+--------------------------------------------------------
  238. // Class:       CPrintRequest
  239. //
  240. // Purpose:     Print Job selection and parameters
  241. //
  242. // History:     22-Jan-1993     asmusf  created
  243. //----------------------------------------------------------
  244. CPrintAux PrGlobal;     // global flags for printing control
  245.  
  246. CPrintRequest::CPrintRequest(HWND hwnd, UINT nMinPage, UINT nMaxPage ) :
  247.         _hwnd(hwnd),
  248.         _hdc(0),
  249.         _hDevNames(0)
  250. {
  251.     PRINTDLG pd;
  252.  
  253.     pd.lStructSize= sizeof(PRINTDLG);
  254.     pd.hwndOwner=NULL;
  255.     pd.hDevMode=NULL;
  256.     pd.hDevNames=NULL;
  257.     pd.hDC;
  258.     pd.nFromPage = 0xFFFF; // cause initial blank field
  259.     pd.nToPage   = 0xFFFF; // in dialog
  260.     pd.nMinPage=nMinPage;
  261.     pd.nMaxPage=nMaxPage;
  262.     pd.nCopies=1;
  263.     pd.hInstance=NULL;
  264.     pd.lCustData=0L;
  265.     pd.lpfnPrintHook=NULL;
  266.     pd.lpfnSetupHook=NULL;
  267.     pd.lpPrintTemplateName=NULL;
  268.     pd.lpSetupTemplateName=NULL;
  269.     pd.hPrintTemplate=NULL;
  270.     pd.hSetupTemplate=NULL;
  271.  
  272.     pd.Flags = PD_RETURNDEFAULT;
  273.     
  274.     if( PrintDlg(&pd) )
  275.     {
  276.         pd.Flags = PD_SELECTION | PD_HIDEPRINTTOFILE | PD_RETURNDC;
  277.         if( PrintDlg( &pd ) )
  278.         {
  279.              if(pd.Flags & PD_PAGENUMS)
  280.              {
  281.                  _nFromPage = pd.nFromPage;
  282.                  _nToPage = pd.nToPage;
  283.              }
  284.              else if (pd.Flags & PD_SELECTION )
  285.              {
  286.                  _nFromPage = _nToPage = 0xFFFF;
  287.              }
  288.              else   // all non empty pages
  289.              {
  290.                  _nFromPage = nMinPage;
  291.                  _nToPage = nMaxPage;
  292.              }
  293.              _hdc = pd.hDC;
  294.              _hDevNames = pd.hDevNames;
  295.  
  296.              if( pd.hDevMode )
  297.              {
  298.                 GlobalFree (pd.hDevMode);
  299.              }
  300.              _status = PREQ_SUCCESS;
  301.              return;
  302.         }
  303.         else
  304.         {
  305.             _status = PREQ_ERROR;
  306.             return;
  307.         }
  308.     } 
  309.  
  310.     _status = PREQ_CANCEL;
  311. }
  312.  
  313. CPrintRequest:: ~CPrintRequest()
  314. {
  315.     if( _hDevNames )
  316.     {
  317.         GlobalFree( _hDevNames );
  318.     }
  319.     
  320.     if( _hdc )
  321.     {
  322.         DeleteDC(_hdc );
  323.     }
  324. }
  325.  
  326. UINT CPrintRequest::Print(HINSTANCE hInst, CCanvas &canvas, CModel *pModel)
  327. {
  328.      // needs to become app & font name....
  329.      static TCHAR szMessage [] = TEXT("Grid: Printing") ;
  330.  
  331.      TCHAR szCaption[30];
  332.      
  333.      BOOL       fError = PREQ_SUCCESS ;
  334.      ABORTPROC  lpfnAbortProc;
  335.      DLGPROC    lpfnPrintDlgProc ;
  336.      short      cxPage, cyPage ;
  337.  
  338.      cxPage = GetDeviceCaps (canvas, HORZRES) ;
  339.      cyPage = GetDeviceCaps (canvas, VERTRES) ;
  340.  
  341.      // disable user input to main window
  342.      EnableWindow (_hwnd, FALSE) ;
  343.  
  344.      lpfnPrintDlgProc = (DLGPROC) MakeProcInstance ((FARPROC) PrintDlgProc, hInst) ;
  345.      
  346.      LoadString(hInst, IDS_MSGCAPTION, szCaption, 30);
  347.      PrGlobal._bUserAbort = FALSE ;
  348.      PrGlobal._hDlgPrint = 
  349.                 CreateDialogParam (hInst, TEXT("PrintDlgBox"), _hwnd, 
  350.                                 lpfnPrintDlgProc, (LONG)(LPSTR) szCaption) ;
  351.  
  352.      lpfnAbortProc = (ABORTPROC) MakeProcInstance ((FARPROC) AbortProc, hInst) ;
  353.  
  354.      SetAbortProc(canvas, lpfnAbortProc);
  355.  
  356.      DOCINFO docinfo;
  357.      docinfo.cbSize = sizeof(DOCINFO);
  358.      docinfo.lpszDocName = szMessage;
  359.      docinfo.lpszOutput = NULL;
  360.  
  361.      if (Escape (canvas, STARTDOC, sizeof szMessage - 1, (LPCSTR)szMessage, NULL) > 0)
  362.      //if (StartDoc(canvas, &docinfo) > 0)
  363.      {
  364.           UINT fuFormat;
  365.           pModel->GetFormat(fuFormat);
  366.           pModel->SetFormat(fuFormat | PAGEPRINT|PAGEELEMS);
  367.           UINT iSavePage = pModel->GetPage();
  368.           
  369.  
  370.           // create printer view to 
  371.           CView  View(cxPage, cyPage);
  372.  
  373.  
  374.           if( _nToPage == 0xFFFF || _nFromPage == 0xFFFF )
  375.           {     
  376.                 _nToPage =   pModel->GetPage()+1;
  377.                 _nFromPage = pModel->GetPage()+1;
  378.           }
  379.  
  380.           for( ; _nFromPage <= _nToPage && ! fError; _nFromPage++ )
  381.           {
  382.              if (pModel->IsModelPageUsed(_nFromPage-1))
  383.                 {
  384.                 if( StartPage(canvas) < 0 )
  385.                     {
  386.                     fError = PREQ_ERRSTARTPAGE ;
  387.                     break;
  388.                     }    
  389.                 pModel->SetPage(_nFromPage-1);  // <- pages are 0 based in Model
  390.                 RECT rc;
  391.                 rc.left = rc.top = 0;
  392.                 rc.right= cxPage;
  393.                 rc.bottom = cyPage;
  394.                 View.Paint (canvas, pModel, rc) ;
  395.                 
  396.                 if ( EndPage(canvas) < 0)
  397.                     {
  398.                     fError = PREQ_ERRENDPAGE ;
  399.                     }
  400.                 }
  401.           }
  402.           if( !fError )
  403.           {
  404.                EndDoc(canvas);
  405.           }
  406.           // restore screen format
  407.           pModel->SetPage(iSavePage);
  408.           pModel->SetFormat(fuFormat);
  409.      }
  410.      else
  411.      {
  412.           fError = PREQ_ERRSTARTDOC ;
  413.      }
  414.  
  415.      if (!PrGlobal._bUserAbort)
  416.      {
  417.           EnableWindow (_hwnd, TRUE) ;
  418.           DestroyWindow (PrGlobal._hDlgPrint) ;
  419.      }
  420.  
  421.      FreeProcInstance ((FARPROC)lpfnPrintDlgProc) ;
  422.      FreeProcInstance ((FARPROC)lpfnAbortProc) ;
  423.  
  424.      if( PrGlobal._bUserAbort )
  425.      {
  426.         fError |= PREQ_USERABORT;
  427.      }
  428.  
  429.      return fError ;
  430. }
  431.  
  432.  
  433.