home *** CD-ROM | disk | FTP | other *** search
/ Mastering Microsoft Visual C++ 4 (2nd Edition) / VisualC4.ISO / minidrw7 / miniddoc.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  9.8 KB  |  418 lines
  1. // MiniDDoc.cpp : implementation of the CMiniDrawDoc class
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "MiniDraw.h"
  6.  
  7. #include "MiniDDoc.h"
  8.  
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CMiniDrawDoc
  17.  
  18. IMPLEMENT_DYNCREATE(CMiniDrawDoc, CDocument)
  19.  
  20. BEGIN_MESSAGE_MAP(CMiniDrawDoc, CDocument)
  21.    //{{AFX_MSG_MAP(CMiniDrawDoc)
  22.    ON_COMMAND(ID_EDIT_CLEAR_ALL, OnEditClearAll)
  23.    ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR_ALL, OnUpdateEditClearAll)
  24.    ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
  25.    ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo)
  26.    //}}AFX_MSG_MAP
  27. END_MESSAGE_MAP()
  28.  
  29. /////////////////////////////////////////////////////////////////////////////
  30. // CMiniDrawDoc construction/destruction
  31.  
  32. CMiniDrawDoc::CMiniDrawDoc()
  33. {
  34.    // TODO: add one-time construction code here
  35.  
  36. }
  37.  
  38. CMiniDrawDoc::~CMiniDrawDoc()
  39. {
  40. }
  41.  
  42. BOOL CMiniDrawDoc::OnNewDocument()
  43. {
  44.    if (!CDocument::OnNewDocument())
  45.       return FALSE;
  46.  
  47.    // TODO: add reinitialization code here
  48.    // (SDI documents will reuse this document)
  49.  
  50.    return TRUE;
  51. }
  52.  
  53. /////////////////////////////////////////////////////////////////////////////
  54. // CMiniDrawDoc serialization
  55.  
  56. void CMiniDrawDoc::Serialize(CArchive& ar)
  57. {
  58.    if (ar.IsStoring())
  59.    {
  60.       // TODO: add storing code here
  61.       m_FigArray.Serialize (ar);
  62.    }
  63.    else
  64.    {
  65.       // TODO: add loading code here
  66.       m_FigArray.Serialize (ar);
  67.    }
  68. }
  69.  
  70. /////////////////////////////////////////////////////////////////////////////
  71. // CMiniDrawDoc diagnostics
  72.  
  73. #ifdef _DEBUG
  74. void CMiniDrawDoc::AssertValid() const
  75. {
  76.    CDocument::AssertValid();
  77. }
  78.  
  79. void CMiniDrawDoc::Dump(CDumpContext& dc) const
  80. {
  81.    CDocument::Dump(dc);
  82. }
  83. #endif //_DEBUG
  84.  
  85. /////////////////////////////////////////////////////////////////////////////
  86. // CMiniDrawDoc commands
  87.  
  88. void CMiniDrawDoc::AddFigure (CFigure *PFigure)
  89.    {            
  90.    m_FigArray.Add (PFigure);
  91.    SetModifiedFlag ();
  92.    }
  93.  
  94. CFigure *CMiniDrawDoc::GetFigure (int Index)
  95.    {
  96.    if (Index < 0 || Index > m_FigArray.GetUpperBound ())
  97.       return 0;
  98.    return (CFigure *)m_FigArray.GetAt (Index);    
  99.    }    
  100.    
  101. int CMiniDrawDoc::GetNumFigs ()
  102.    {
  103.    return m_FigArray.GetSize ();
  104.    }
  105.  
  106. void CMiniDrawDoc::DeleteContents() 
  107. {
  108.    // TODO: Add your specialized code here and/or call the base class
  109.    
  110.    int Index = m_FigArray.GetSize ();
  111.    while (Index--)
  112.       delete m_FigArray.GetAt (Index);      
  113.    m_FigArray.RemoveAll ();      
  114.  
  115.    CDocument::DeleteContents();
  116. }
  117.  
  118. void CMiniDrawDoc::OnEditClearAll() 
  119. {
  120.    // TODO: Add your command handler code here
  121.  
  122.    DeleteContents ();
  123.    UpdateAllViews (0);
  124.    SetModifiedFlag ();
  125. }
  126.  
  127. void CMiniDrawDoc::OnUpdateEditClearAll(CCmdUI* pCmdUI) 
  128. {
  129.    // TODO: Add your command update UI handler code here
  130.  
  131.    pCmdUI->Enable (m_FigArray.GetSize ());   
  132. }
  133.  
  134. void CMiniDrawDoc::OnEditUndo() 
  135. {
  136.    // TODO: Add your command handler code here
  137.  
  138.    int Index = m_FigArray.GetUpperBound ();
  139.    if (Index > -1)
  140.       {
  141.       delete m_FigArray.GetAt (Index);
  142.       m_FigArray.RemoveAt (Index);
  143.       }
  144.    UpdateAllViews (0);
  145.    SetModifiedFlag ();   
  146. }
  147.  
  148. void CMiniDrawDoc::OnUpdateEditUndo(CCmdUI* pCmdUI) 
  149. {
  150.    // TODO: Add your command update UI handler code here
  151.    
  152.    pCmdUI->Enable (m_FigArray.GetSize ());
  153. }
  154.  
  155. // implementation of figure classes:
  156.  
  157. IMPLEMENT_SERIAL (CFigure, CObject, 3)
  158.  
  159. CRect CFigure::GetDimRect ()
  160.    {
  161.    return CRect 
  162.      (min (m_X1, m_X2),
  163.       min (m_Y1, m_Y2), 
  164.       max (m_X1, m_X2) + 1,
  165.       max (m_Y1, m_Y2) + 1);
  166.    }
  167.  
  168. void CFigure::Serialize (CArchive& ar)
  169.    {
  170.    if (ar.IsStoring ())
  171.       ar << m_X1 << m_Y1 << m_X2 << m_Y2 << m_Color;
  172.    else
  173.       ar >> m_X1 >> m_Y1 >> m_X2 >> m_Y2 >> m_Color;
  174.    }
  175.  
  176. IMPLEMENT_SERIAL (CLine, CFigure, 3) 
  177.  
  178. CLine::CLine (int X1, int Y1, int X2, int Y2, COLORREF Color, int Thickness)
  179.    {
  180.    m_X1 = X1;
  181.    m_Y1 = Y1;
  182.    m_X2 = X2;
  183.    m_Y2 = Y2;
  184.    m_Color = Color;
  185.    m_Thickness = Thickness;
  186.    }
  187.  
  188. void CLine::Serialize (CArchive& ar)
  189.    {
  190.    CFigure::Serialize (ar);
  191.    if (ar.IsStoring ())
  192.       ar << m_Thickness;
  193.    else
  194.       ar >> m_Thickness;
  195.    }
  196.  
  197. void CLine::Draw (CDC *PDC)
  198.    {        
  199.    CPen Pen, *POldPen;
  200.  
  201.    // select pen/brush:   
  202.    Pen.CreatePen (PS_SOLID, m_Thickness, m_Color);
  203.    POldPen = PDC->SelectObject (&Pen);
  204.               
  205.    // draw figure:              
  206.    PDC->MoveTo (m_X1, m_Y1);
  207.    PDC->LineTo (m_X2, m_Y2);
  208.                   
  209.    // remove pen/brush:                 
  210.    PDC->SelectObject (POldPen);
  211.    }
  212.  
  213. IMPLEMENT_SERIAL (CRectangle, CFigure, 3) 
  214.  
  215. CRectangle::CRectangle (int X1, int Y1, int X2, int Y2, 
  216.                         COLORREF Color, int Thickness)
  217.    {  
  218.    m_X1 = X1;
  219.    m_Y1 = Y1;
  220.    m_X2 = X2;
  221.    m_Y2 = Y2;
  222.    m_Color = Color;
  223.    m_Thickness = Thickness;
  224.    }
  225.  
  226. void CRectangle::Serialize (CArchive& ar)
  227.    {
  228.    CFigure::Serialize (ar);
  229.    if (ar.IsStoring ())
  230.       ar << m_Thickness;
  231.    else
  232.       ar >> m_Thickness;
  233.    }
  234.  
  235. void CRectangle::Draw (CDC *PDC)
  236.    {
  237.    CPen Pen, *POldPen;
  238.  
  239.    // select pen/brush:   
  240.    Pen.CreatePen (PS_INSIDEFRAME, m_Thickness, m_Color);
  241.    POldPen = PDC->SelectObject (&Pen);
  242.    PDC->SelectStockObject (NULL_BRUSH);
  243.               
  244.    // draw figure:              
  245.    PDC->Rectangle (m_X1, m_Y1, m_X2, m_Y2);
  246.                   
  247.    // remove pen/brush:                  
  248.    PDC->SelectObject (POldPen);   
  249.    }
  250.  
  251. IMPLEMENT_SERIAL (CRectFill, CFigure, 3) 
  252.  
  253. CRectFill::CRectFill (int X1, int Y1, int X2, int Y2, COLORREF Color)
  254.    {  
  255.    m_X1 = min (X1, X2);
  256.    m_Y1 = min (Y1, Y2);
  257.    m_X2 = max (X1, X2);
  258.    m_Y2 = max (Y1, Y2);
  259.    m_Color = Color;
  260.    }
  261.  
  262. void CRectFill::Draw (CDC *PDC)
  263.    {             
  264.    CBrush Brush, *POldBrush;
  265.    CPen Pen, *POldPen;
  266.  
  267.    // select pen/brush:   
  268.    Pen.CreatePen (PS_INSIDEFRAME, 1, m_Color);
  269.    POldPen = PDC->SelectObject (&Pen);    
  270.    Brush.CreateSolidBrush (m_Color);
  271.    POldBrush = PDC->SelectObject (&Brush);
  272.               
  273.    // draw figure:              
  274.    PDC->Rectangle (m_X1, m_Y1, m_X2, m_Y2);
  275.                   
  276.    // remove pen/brush:                  
  277.    PDC->SelectObject (POldPen);
  278.    PDC->SelectObject (POldBrush);   
  279.    }
  280.    
  281. IMPLEMENT_SERIAL (CRectRound, CFigure, 3) 
  282.  
  283. CRectRound::CRectRound (int X1, int Y1, int X2, int Y2, 
  284.                         COLORREF Color, int Thickness)
  285.    {  
  286.    m_X1 = min (X1, X2);
  287.    m_Y1 = min (Y1, Y2);
  288.    m_X2 = max (X1, X2);
  289.    m_Y2 = max (Y1, Y2);
  290.    m_Color = Color;
  291.    m_Thickness = Thickness;
  292.    }
  293.  
  294. void CRectRound::Serialize (CArchive& ar)
  295.    {
  296.    CFigure::Serialize (ar);
  297.    if (ar.IsStoring ())
  298.       ar << m_Thickness;
  299.    else
  300.       ar >> m_Thickness;
  301.    }
  302.  
  303. void CRectRound::Draw (CDC *PDC)
  304.    {
  305.    CPen Pen, *POldPen;
  306.  
  307.    // select pen/brush:   
  308.    Pen.CreatePen (PS_INSIDEFRAME, m_Thickness, m_Color);
  309.    POldPen = PDC->SelectObject (&Pen);
  310.    PDC->SelectStockObject (NULL_BRUSH);
  311.               
  312.    // draw figure:
  313.    int SizeRound = (m_X2 - m_X1 + m_Y2 - m_Y1) / 6;
  314.    PDC->RoundRect (m_X1, m_Y1, m_X2, m_Y2, SizeRound, SizeRound);
  315.                   
  316.    // remove pen/brush:                  
  317.    PDC->SelectObject (POldPen);   
  318.    }
  319.    
  320. IMPLEMENT_SERIAL (CRectRoundFill, CFigure, 3) 
  321.  
  322. CRectRoundFill::CRectRoundFill (int X1, int Y1, int X2, int Y2, COLORREF Color)
  323.    {  
  324.    m_X1 = min (X1, X2);
  325.    m_Y1 = min (Y1, Y2);
  326.    m_X2 = max (X1, X2);
  327.    m_Y2 = max (Y1, Y2);
  328.    m_Color = Color;
  329.    }
  330.  
  331. void CRectRoundFill::Draw (CDC *PDC)
  332.    {             
  333.    CBrush Brush, *POldBrush;
  334.    CPen Pen, *POldPen;
  335.  
  336.    // select pen/brush:   
  337.    Pen.CreatePen (PS_INSIDEFRAME, 1, m_Color);
  338.    POldPen = PDC->SelectObject (&Pen);    
  339.    Brush.CreateSolidBrush (m_Color);
  340.    POldBrush = PDC->SelectObject (&Brush);
  341.               
  342.    // draw figure:              
  343.    int SizeRound = (m_X2 - m_X1 + m_Y2 - m_Y1) / 6;
  344.    PDC->RoundRect (m_X1, m_Y1, m_X2, m_Y2, SizeRound, SizeRound);
  345.                   
  346.    // remove pen/brush:                  
  347.    PDC->SelectObject (POldPen);
  348.    PDC->SelectObject (POldBrush);   
  349.    }
  350.  
  351. IMPLEMENT_SERIAL (CCircle, CFigure, 3) 
  352.  
  353. CCircle::CCircle (int X1, int Y1, int X2, int Y2, 
  354.                   COLORREF Color, int Thickness)
  355.    {  
  356.    m_X1 = min (X1, X2);
  357.    m_Y1 = min (Y1, Y2);
  358.    m_X2 = max (X1, X2);
  359.    m_Y2 = max (Y1, Y2);
  360.    m_Color = Color;
  361.    m_Thickness = Thickness;
  362.    }
  363.  
  364. void CCircle::Serialize (CArchive& ar)
  365.    {
  366.    CFigure::Serialize (ar);
  367.    if (ar.IsStoring ())
  368.       ar << m_Thickness;
  369.    else
  370.       ar >> m_Thickness;
  371.    }
  372.  
  373. void CCircle::Draw (CDC *PDC)
  374.    {
  375.    CPen Pen, *POldPen;
  376.  
  377.    // select pen/brush:   
  378.    Pen.CreatePen (PS_INSIDEFRAME, m_Thickness, m_Color);
  379.    POldPen = PDC->SelectObject (&Pen);
  380.    PDC->SelectStockObject (NULL_BRUSH);
  381.               
  382.    // draw figure:              
  383.    PDC->Ellipse (m_X1, m_Y1, m_X2, m_Y2);
  384.                   
  385.    // remove pen/brush:                  
  386.    PDC->SelectObject (POldPen);   
  387.    }
  388.    
  389. IMPLEMENT_SERIAL (CCircleFill, CFigure, 3) 
  390.  
  391. CCircleFill::CCircleFill (int X1, int Y1, int X2, int Y2, COLORREF Color)
  392.    {  
  393.    m_X1 = min (X1, X2);
  394.    m_Y1 = min (Y1, Y2);
  395.    m_X2 = max (X1, X2);
  396.    m_Y2 = max (Y1, Y2);
  397.    m_Color = Color;
  398.    }
  399.  
  400. void CCircleFill::Draw (CDC *PDC)
  401.    {             
  402.    CBrush Brush, *POldBrush;
  403.    CPen Pen, *POldPen;
  404.  
  405.    // select pen/brush:   
  406.    Pen.CreatePen (PS_INSIDEFRAME, 1, m_Color);
  407.    POldPen = PDC->SelectObject (&Pen);    
  408.    Brush.CreateSolidBrush (m_Color);
  409.    POldBrush = PDC->SelectObject (&Brush);
  410.               
  411.    // draw figure:              
  412.    PDC->Ellipse (m_X1, m_Y1, m_X2, m_Y2);
  413.                   
  414.    // remove pen/brush:                  
  415.    PDC->SelectObject (POldPen);
  416.    PDC->SelectObject (POldBrush);   
  417.    }
  418.