Scribdoc.cpp
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:8k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // ScribDoc.cpp : implementation of the CScribbleDoc class
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  21. #include "Scribble.h"
  22. #include "ScribDoc.h"
  23. #include "ScribItm.h"
  24. #include "PenDlg.h"
  25. #include "ScribVw.h"
  26. #ifdef _DEBUG
  27. #define new DEBUG_NEW
  28. #undef THIS_FILE
  29. static char THIS_FILE[] = __FILE__;
  30. #endif
  31. /////////////////////////////////////////////////////////////////////////////
  32. // CScribbleDoc
  33. IMPLEMENT_DYNCREATE(CScribbleDoc, COleServerDoc)
  34. BEGIN_MESSAGE_MAP(CScribbleDoc, COleServerDoc)
  35. //{{AFX_MSG_MAP(CScribbleDoc)
  36. ON_COMMAND(ID_EDIT_CLEAR_ALL, OnEditClearAll)
  37. ON_COMMAND(ID_PEN_THICK_OR_THIN, OnPenThickOrThin)
  38. ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR_ALL, OnUpdateEditClearAll)
  39. ON_UPDATE_COMMAND_UI(ID_PEN_THICK_OR_THIN, OnUpdatePenThickOrThin)
  40. ON_COMMAND(ID_PEN_WIDTHS, OnPenWidths)
  41. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  42. //}}AFX_MSG_MAP
  43. END_MESSAGE_MAP()
  44. /////////////////////////////////////////////////////////////////////////////
  45. // CScribbleDoc construction/destruction
  46. CScribbleDoc::CScribbleDoc()
  47. {
  48. // Use OLE compound files
  49. EnableCompoundFile();
  50. m_sizeDoc = CSize(200, 200);
  51. }
  52. CScribbleDoc::~CScribbleDoc()
  53. {
  54. }
  55. BOOL CScribbleDoc::OnNewDocument()
  56. {
  57. if (!COleServerDoc::OnNewDocument())
  58. return FALSE;
  59. InitDocument();
  60. return TRUE;
  61. }
  62. /////////////////////////////////////////////////////////////////////////////
  63. // CScribbleDoc serialization
  64. void CScribbleDoc::Serialize(CArchive& ar)
  65. {
  66. if (ar.IsStoring())
  67. {
  68. ar << m_sizeDoc;
  69. }
  70. else
  71. {
  72. ar >> m_sizeDoc;
  73. }
  74. m_strokeList.Serialize(ar);
  75. }
  76. /////////////////////////////////////////////////////////////////////////////
  77. // CScribbleDoc diagnostics
  78. #ifdef _DEBUG
  79. void CScribbleDoc::AssertValid() const
  80. {
  81. COleServerDoc::AssertValid();
  82. }
  83. void CScribbleDoc::Dump(CDumpContext& dc) const
  84. {
  85. COleServerDoc::Dump(dc);
  86. }
  87. #endif //_DEBUG
  88. /////////////////////////////////////////////////////////////////////////////
  89. // CScribbleDoc commands
  90. BOOL CScribbleDoc::OnOpenDocument(LPCTSTR lpszPathName)
  91. {
  92. if (!COleServerDoc::OnOpenDocument(lpszPathName))
  93. return FALSE;
  94. InitDocument();
  95. return TRUE;
  96. }
  97. void CScribbleDoc::DeleteContents()
  98. {
  99. while (!m_strokeList.IsEmpty())
  100. {
  101. delete m_strokeList.RemoveHead();
  102. }
  103. COleServerDoc::DeleteContents();
  104. }
  105. void CScribbleDoc::InitDocument()
  106. {
  107. m_bThickPen = FALSE;
  108. m_nThinWidth = 2;   // default thin pen is 2 pixels wide
  109. m_nThickWidth = 5;  // default thick pen is 5 pixels wide
  110. ReplacePen();       // initialize pen according to current width
  111. // default document size is 2 x 2 inches
  112. m_sizeDoc = CSize(200,200);
  113. }
  114. CStroke* CScribbleDoc::NewStroke()
  115. {
  116. CStroke* pStrokeItem = new CStroke(m_nPenWidth);
  117. m_strokeList.AddTail(pStrokeItem);
  118. SetModifiedFlag();  // Mark the document as having been modified, for
  119.                     // purposes of confirming File Close.
  120. return pStrokeItem;
  121. }
  122. /////////////////////////////////////////////////////////////////////////////
  123. // CStroke
  124. IMPLEMENT_SERIAL(CStroke, CObject, 2)
  125. CStroke::CStroke()
  126. {
  127. // This empty constructor should be used by serialization only
  128. }
  129. CStroke::CStroke(UINT nPenWidth)
  130. {
  131. m_nPenWidth = nPenWidth;
  132. m_rectBounding.SetRectEmpty();
  133. }
  134. void CStroke::Serialize(CArchive& ar)
  135. {
  136. if (ar.IsStoring())
  137. {
  138. ar << m_rectBounding;
  139. ar << (WORD)m_nPenWidth;
  140. m_pointArray.Serialize(ar);
  141. }
  142. else
  143. {
  144. ar >> m_rectBounding;
  145. WORD w;
  146. ar >> w;
  147. m_nPenWidth = w;
  148. m_pointArray.Serialize(ar);
  149. }
  150. }
  151. BOOL CStroke::DrawStroke(CDC* pDC)
  152. {
  153. CPen penStroke;
  154. if (!penStroke.CreatePen(PS_SOLID, m_nPenWidth, RGB(0,0,0)))
  155. return FALSE;
  156. CPen* pOldPen = pDC->SelectObject(&penStroke);
  157. pDC->MoveTo(m_pointArray[0]);
  158. for (int i=1; i < m_pointArray.GetSize(); i++)
  159. {
  160. pDC->LineTo(m_pointArray[i]);
  161. }
  162. pDC->SelectObject(pOldPen);
  163. return TRUE;
  164. }
  165. void CScribbleDoc::OnEditClearAll()
  166. {
  167. DeleteContents();
  168. SetModifiedFlag();  // Mark the document as having been modified, for
  169.                     // purposes of confirming File Close.
  170. UpdateAllViews(NULL);
  171. }
  172. void CScribbleDoc::OnPenThickOrThin()
  173. {
  174. // Toggle the state of the pen between thin or thick.
  175. m_bThickPen = !m_bThickPen;
  176. // Change the current pen to reflect the new user-specified width.
  177. ReplacePen();
  178. }
  179. void CScribbleDoc::ReplacePen()
  180. {
  181. m_nPenWidth = m_bThickPen? m_nThickWidth : m_nThinWidth;
  182. // Change the current pen to reflect the new user-specified width.
  183. m_penCur.DeleteObject();
  184. m_penCur.CreatePen(PS_SOLID, m_nPenWidth, RGB(0,0,0)); // solid black
  185. }
  186. void CScribbleDoc::OnUpdateEditClearAll(CCmdUI* pCmdUI)
  187. {
  188. // Enable the command user interface object (menu item or tool bar
  189. // button) if the document is non-empty, i.e., has at least one stroke.
  190. pCmdUI->Enable(!m_strokeList.IsEmpty());
  191. }
  192. void CScribbleDoc::OnUpdatePenThickOrThin(CCmdUI* pCmdUI)
  193. {
  194. // Add check mark to Draw Thick Line menu item, if the current
  195. // pen width is "thick".
  196. pCmdUI->SetCheck(m_bThickPen);
  197. }
  198. void CScribbleDoc::OnPenWidths()
  199. {
  200. CPenWidthsDlg dlg;
  201. // Initialize dialog data
  202. dlg.m_nThinWidth = m_nThinWidth;
  203. dlg.m_nThickWidth = m_nThickWidth;
  204. // Invoke the dialog box
  205. if (dlg.DoModal() == IDOK)
  206. {
  207. // retrieve the dialog data
  208. m_nThinWidth = dlg.m_nThinWidth;
  209. m_nThickWidth = dlg.m_nThickWidth;
  210. // Update the pen that is used by views when drawing new strokes,
  211. // to reflect the new pen width definitions for "thick" and "thin".
  212. ReplacePen();
  213. }
  214. }
  215. void CStroke::FinishStroke()
  216. {
  217. // Calculate the bounding rectangle.  It's needed for smart
  218. // repainting.
  219. if (m_pointArray.GetSize()==0)
  220. {
  221. m_rectBounding.SetRectEmpty();
  222. return;
  223. }
  224. CPoint pt = m_pointArray[0];
  225. m_rectBounding = CRect(pt.x, pt.y, pt.x, pt.y);
  226. for (int i=1; i < m_pointArray.GetSize(); i++)
  227. {
  228. // If the point lies outside of the accumulated bounding
  229. // rectangle, then inflate the bounding rect to include it.
  230. pt = m_pointArray[i];
  231. m_rectBounding.left     = min(m_rectBounding.left, pt.x);
  232. m_rectBounding.right    = max(m_rectBounding.right, pt.x);
  233. m_rectBounding.top      = max(m_rectBounding.top, pt.y);
  234. m_rectBounding.bottom   = min(m_rectBounding.bottom, pt.y);
  235. }
  236. // Add the pen width to the bounding rectangle.  This is necessary
  237. // to account for the width of the stroke when invalidating
  238. // the screen.
  239. m_rectBounding.InflateRect(CSize(m_nPenWidth, -(int)m_nPenWidth));
  240. return;
  241. }
  242. COleServerItem* CScribbleDoc::OnGetEmbeddedItem()
  243. {
  244. // OnGetEmbeddedItem is called by the framework to get the COleServerItem
  245. //  that is associated with the document.  It is only called when necessary.
  246. CScribbleItem* pItem = new CScribbleItem(this);
  247. ASSERT_VALID(pItem);
  248. return pItem;
  249. }
  250. void CScribbleDoc::OnSetItemRects(LPCRECT lpPosRect, LPCRECT lpClipRect)
  251. {
  252. // call base class to change the size of the window
  253. COleServerDoc::OnSetItemRects(lpPosRect, lpClipRect);
  254. // notify first view that scroll info should change
  255. POSITION pos = GetFirstViewPosition();
  256. CScribbleView* pView = (CScribbleView*)GetNextView(pos);
  257. pView->ResyncScrollSizes();
  258. }
  259. void CScribbleDoc::OnEditCopy()
  260. {
  261. CScribbleItem* pItem = GetEmbeddedItem();
  262. pItem->CopyToClipboard(TRUE);
  263. }