开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
drawView.cpp
资源名称：陈建春VC开发GIS的源码.rar　[点击查看]
上传用户：y440e3
上传日期：2010-03-08
资源大小：200k
文件大小：64k
源码类别：

GIS编程

开发平台：

Visual C++

drawView.cpp：源码内容
  1. // DrawView.cpp : implementation of the CDrawView class
  2. //
  4. #include "stdafx.h"
  5. #include "Draw.h"
  6. #include <float.h>
  7. #include <math.h>
  8. #include "DrawDoc.h"
  9. #include "CntrItem.h"
  10. #include "DrawView.h"
  11. #include "TextWriteDlg.h"
  12. #include "mainfrm.h"
  13. #include "winresrc.h"
  14. #include <afxwin.h>
  15. #include "datalinkdlg.h"
  16. #include <windowsx.h>
  17. #ifdef _DEBUG
  18. #define new DEBUG_NEW
  19. #undef THIS_FILE
  20. static char THIS_FILE[] = __FILE__;
  21. #endif
  22. extern CGraphPara *p_GraphPara; //初试化一个公用的关于图形参数的实例
  23. extern float xMinScreen,yMinScreen,xMaxScreen,yMaxScreen;
  24. /////////////////////////////////////////////////////////////////////////////
  25. // CDrawView
  26. CDrawDoc* p_Doc;
  27. CDrawView *p_View;
  28. BOOL b_Draw;
  29. CWinThread *m_pDrawThread;
  30. IMPLEMENT_DYNCREATE(CDrawView, CView)
  32. BEGIN_MESSAGE_MAP(CDrawView, CView)
  33. //{{AFX_MSG_MAP(CDrawView)
  34. ON_WM_DESTROY()
  35. ON_WM_SETFOCUS()
  36. ON_WM_SIZE() //视图大小变化时调用，OnSize函数的映射
  37. ON_COMMAND(ID_OLE_INSERT_NEW, OnInsertObject)
  38. ON_COMMAND(ID_CANCEL_EDIT_CNTR, OnCancelEditCntr)
  39. ON_COMMAND(ID_DRAW_ARC, OnDrawArc) //开始圆弧绘制
  40. ON_COMMAND(ID_DRAW_CIRCLE, OnDrawCircle) //开始圆绘制
  41. ON_COMMAND(ID_DRAW_CIRCLE1, OnDrawCircle1) //开始填充圆绘制
  42. ON_COMMAND(ID_DRAW_LINE, OnDrawLine) //开始直线绘制
  43. ON_COMMAND(ID_DRAW_PLINE, OnDrawPline) //开始连续直线绘制
  44. ON_COMMAND(ID_DRAW_RGN, OnDrawRgn) //开始连续多边形绘制
  45. ON_COMMAND(ID_DRAW_TEXT, OnDrawText) //开始文字标注
  46. ON_COMMAND(ID_TEXT_MESSAGE,DrawText) //标注文字时被调用在屏幕上写文字
  47. ON_COMMAND(ID_TEXT_ONOK,DrawTextOnOk) //按‘确定'退出标注文字框时被调用
  48. ON_COMMAND(ID_TEXT_ONCANCEL,DrawTextOnCancel)//按‘放弃'退出标注文字框时调用
  49. ON_WM_LBUTTONDOWN() //按下鼠标左键，OnlButtonDown函数顶消息映射
  50. ON_WM_MOUSEMOVE() //移动鼠标，OnMouseMove函数顶消息映射
  51. ON_WM_RBUTTONDOWN() //按下鼠标右键，OnRButtonDown函数顶消息映射
  52. ON_COMMAND(ID_GRAPH_REDRAW, OnGraphRedraw) //图形重画
  53. ON_COMMAND(ID_GRAPH_ZOOM, OnGraphZoom) //图形放大
  54. ON_COMMAND(ID_GRAPH_PAN, OnGraphPan) //图形摇动
  55. ON_COMMAND(ID_GRAPH_UP, OnGraphUp) //重画上屏
  56. ON_COMMAND(ID_GRAPH_FIRST, OnGraphFirst) //重画首屏
  57. ON_COMMAND(ID_GRAPH_ALL, OnGraphAll) //重画全屏
  58. ON_COMMAND(ID_SELECT_MOUSE, OnSelectMouse) //图形选中
  59. ON_COMMAND(ID_SELECT_CLEAR, OnSelectClear) //放弃选中
  60. ON_COMMAND(ID_SELECT_DELETE, OnSelectDelete)//删除选中图形
  61. ON_COMMAND(ID_EDIT_CUT, OnEditCut) //裁剪选中图形进裁剪板
  62. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste) //从剪裁板粘贴图形
  63. ON_COMMAND(ID_EDIT_UNDO, OnEditUndo) //逆向放弃操作
  64. ON_COMMAND(ID_EDIT_COPY, OnEditCopy) //拷贝选中图形进裁剪板
  65. ON_WM_HSCROLL()
  66. ON_WM_VSCROLL()
  67. ON_WM_KEYDOWN()
  68. ON_COMMAND(ID_BITMAP_CUT, OnBitmapCut)
  69. ON_COMMAND(ID_BITMAP_PASTE, OnBitmapPaste)
  70. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  71. ON_COMMAND(ID_GRAPH_DRAW, OnGraphDraw)
  72. ON_EN_CHANGE(IDC_EDIT1, OnChangeDlgEdit)
  73. ON_LBN_SELCHANGE(IDC_COMBO1,OnChangeDlgCom)
  74. ON_WM_LBUTTONDBLCLK()
  75. ON_COMMAND(ID_DATA_SEACHER, OnDataSeacher)
  76. //}}AFX_MSG_MAP
  77. // Standard printing commands
  78. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  79. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  80. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  81. END_MESSAGE_MAP()
  83. UINT DrawFunction(LPVOID PHWndView)
  84. {
  85. CClientDC ht(CWnd::FromHandle(*(HWND*)PHWndView));
  86. p_Doc->Draw(&ht,0,0,1);
  87. return(0);
  88. }
  90. //视图类的构造函数
  91. CDrawView::CDrawView()
  92. {
  93. m_pSelection = NULL;
  94. m_xStart=0;
  95. m_yStart=0;
  96. blc=1.0;
  97. m_bColor=0; //当前底色的序号
  98. m_pColor=1; //设置笔色
  99. m_brColor=1; //画刷色
  100. m_LineWide=1; //设置线宽
  101. m_LineType=0; //设置线型
  102. m_Layer=1; //设置当前层
  103. PointXyz=new PointStruct[3000];//存储连续直线点的数组
  104. PushNumb=0;
  105. b_RunFirst=1;
  106. pTextDlg=NULL;
  107. //以下设置初始字体大小
  108. m_FontHeight=20;
  109. m_FontWide=10;
  110. m_TextAngle=0;
  111. m_FontAngle=0;
  112. m_FontBetween=1;
  113. m_TextString.Empty();
  114. m_Text1=new CText();//实际初始化一个标注类
  115. m_bColor=7; //屏幕底色设置为0颜色号
  116.     nScrollMin=50;  //滚动条的最小滚动范围是在屏幕上滚动50个像素
  117.     nXLine=1;       //横向滚动一个滚动范围
  118.     nYLine=1;     //纵向滚动一个滚动范围（按中滚动条的按键时的滚动
  119. m_MapMode=1;
  120. // TODO: add construction code here
  121. }
  123. void CDrawView::DPtoVP(float x,float y,int *X,int *Y)
  124. {
  125. *X=(int)((x-m_xStart)/blc);
  126. if(m_MapMode==1)
  127. *Y=m_hScreen-(int)((y-m_yStart)/blc);
  128. else
  129. *Y=(int)((y-m_yStart)/blc)-m_hScreen;
  130. }
  132. void CDrawView::VPtoDP(int x,int y,float *X,float *Y)
  133. {
  134. *X=m_xStart+x*blc;
  135. if(m_MapMode==1)
  136. *Y=m_yStart+blc*(m_hScreen-y);
  137. else
  138. *Y=m_yStart+blc*(y+m_hScreen);
  139. }
  141. float CDrawView::VLtoDL(int l)
  142. {
  143. return blc*l;
  144. }
  146. int CDrawView::DLtoVL(float l)
  147. {
  148. return (int)(l/blc);
  149. }
  151. //视图类的析构函数
  152. CDrawView::~CDrawView()
  153. {
  154. delete PointXyz;
  155. delete m_Text1;
  156. }
  158. //预定制窗口函数
  159. BOOL CDrawView::PreCreateWindow(CREATESTRUCT& cs)
  160. {
  161. cs.style=cs.style|WS_HSCROLL|WS_VSCROLL;
  162. return CView::PreCreateWindow(cs);
  163. }
  165. /////////////////////////////////////////////////////////////////////////////
  166. // CDrawView drawing
  168. //视图类中的绘制函数，通过窗口激发完成视图的自动绘制
  169. void CDrawView::OnDraw(CDC* pDC)
  170. {
  171. CRect rr;
  172. CDrawDoc* pDoc = GetDocument();
  173. p_Doc=pDoc;
  174. ASSERT_VALID(pDoc);
  175. xMinScreen=m_xStart;
  176. yMinScreen=m_yStart;
  177. xMaxScreen=xMinScreen+blc*m_wScreen;
  178. yMaxScreen=yMinScreen+blc*m_hScreen;
  179. // DrawBack(pDC); //以底色填充整个屏幕
  180. if(pDC->GetDeviceCaps(TECHNOLOGY)==DT_RASDISPLAY)
  181. {
  182. if(m_pDrawThread)
  183. {
  184. b_Draw=FALSE;
  185. m_pDrawThread->ResumeThread();
  186. ::WaitForSingleObject(m_pDrawThread->m_hThread,INFINITE);
  187. delete m_pDrawThread;
  188. }
  189. b_Draw=TRUE;
  190. m_PDrawThread=AfxBeginThread(DrawFunction,&m_hWnd,THREAD_PRIORITY_BELOW_NORMAL,0,CREATE_SUSPENDED);
  191. m_PDrawThread->m_bAutoDelete=FALSE;
  192. m_PDrawThread->ResumeThread();
  193. }
  194. else
  195. pDoc->Draw(pDC,0,0,m_bColor);
  197. POSITION pos=pDoc->GetStartPosition();
  198. while(pos!=NULL)
  199. {
  200. CDrawCntrItem *pItem=(CDrawCntrItem *)pDoc->GetNextClientItem(pos);
  201. if(pItem!=m_pSelection)
  202. pItem->Draw(pDC);
  203. }
  205. if(m_pSelection!=NULL)
  206. {
  207. m_pSelection->Draw(pDC);
  208. CRectTracker tracker;
  209. PutTracker(m_pSelection,&tracker);
  210. tracker.Draw(pDC);
  211. }
  212. }
  214. //被函数OnDraw调用来以给定的屏幕底色填充屏幕
  215. void CDrawView::DrawBack(CDC* pDC)
  216. {
  217. CBrush brush(p_GraphPara->GetColor(m_bColor)); //得到画刷
  218. CBrush* pOldBrush=pDC->SelectObject(&brush); //选中画刷  
  219. pDC->PatBlt(0,0,m_wScreen,m_hScreen,PATCOPY); //填充屏幕
  220. pDC->SelectObject(pOldBrush);
  221. }
  223. //函数Aarc::jsarc作用：计算通过屏幕的三个点的弧的图形要素
  224. //参数：依次为三个点的屏幕坐标p1,p2,p3
  225. //通过指针变量返回圆弧的特征参数
  226. BOOL CDrawView::jsarc(CPoint p1,CPoint p2,CPoint p3,float *CircleX,float *CircleY,
  227. float *CircleR,float *Angle1,float *Angle2)
  228. {
  229. float an1,an2,an3;
  230. float x1,y1,x2,y2,x3,y3,xx1,xx2,yy1,yy2,xx,yy,rr;
  231. float k1,k2;
  232. //将三个点的坐标赋给浮点变量 
  233. x1=(float)p1.x;y1=(float)p1.y;x2=(float)p2.x;
  234. y2=(float)p2.y;x3=(float)p3.x;y3=(float)p3.y;
  235. if(x1==x2&&y1==y2||x1==x3&&y1==y3||x2==x3&&y2==y3)  //如果有两个点是同一个点
  236. return 0;  //操作不成功，返回0
  237. //得到顺三点方向的两条直线中点的坐标
  238. xx1=(x1+x2)/2; yy1=(y1+y2)/2; 
  239. xx2=(x2+x3)/2; yy2=(y2+y3)/2;
  240. if(fabs(y2-y1)>0.5) //如果第一条垂线不是垂直线
  241. k1=-(x2-x1)/(y2-y1); //得到直线的垂线的斜率
  242. //得到第二条直线垂线的斜率
  243. if(fabs(y3-y2)>0.5) 
  244. k2=-(x3-x2)/(y3-y2);
  245.   
  246. if(k1==k2&&k1==0.0)
  247. return 0;
  248. if(fabs(y2-y1)<0.5)     //如果第一条直线是平行线（即第一条垂线是垂直线）
  249. {
  250. xx=xx1;
  251. if(fabs(y3-y2)<0.5)   //如果第二条直线也是平行线
  252. {
  253. yy=y2+10000;  //给定圆弧的半径为10000
  254. rr=10000;     
  255. }
  256. else         // 如果第二条直线不是平行线（即第二条垂线不是垂直线）
  257. {
  258. yy=yy2+k2*(xx2-xx);  //求得圆心的纵坐标
  259. rr=yy-y2;
  260. if(rr<0)rr=-rr;      //得到半径
  261. }
  262. }
  263. else if(fabs(y2-y3)<0.5)   //如果第二条直线是平行线，而第一条直线不是平行线
  264. {
  265. xx=xx2;
  266. yy=yy1+k1*(xx1-xx);  //解得圆心的y坐标
  267. rr=yy-y2;
  268. if(rr<0)rr=-rr;      //得到半径
  269. }
  270. else  //如果两条直线的垂线都不是垂直线
  271. {
  272. if(k1==k2)//如果两条直线平行即三个点在一条直线上
  273. {
  274. //假定这个圆弧半径为10000个像素，求得圆心坐标
  275. xx=x2+(float)(10000/sqrt(1+k1*k1));
  276. yy=y2+(float)(10000/sqrt((1+k1*k1)/(k1*k1)));
  277. rr=10000;
  278. }
  279. else  //如果两条直线不平行
  280. {
  281. //解得两条直线的垂线的交点，即圆心的坐标
  282. xx=(yy2-yy1+k1*xx1-k2*xx2)/(k1-k2);
  283. yy=yy1+k1*(xx-xx1);
  284. rr=(float)sqrt((xx-x1)*(xx-x1)+(yy-y1)*(yy-y1)); //得到半径
  285. }
  286. }
  287. //将交点变成实际坐标，并存入结构arc1中
  288. VPtoDP((int)xx,(int)yy,CircleX,CircleY);
  289. *CircleR=VLtoDL((int)rr);
  290. //得到第一个点相对于圆心的弧度
  291. an1=(float)acos((x1-xx)/rr);
  292. if(y1-yy>0)   an1=(float)(pi*2-an1);
  293. //得到第二个点相对于圆心的弧度
  294. an2=(float)acos((x2-xx)/rr);
  295. if(y2-yy>0)     an2=(float)(pi*2-an2);
  296. //得到第三个点相对于圆心的弧度
  297. an3=(float)acos((x3-xx)/rr);
  298. if(y3-yy>0) an3=(float)(pi*2-an3);
  299. if(an2>an1&&an2<an1+pi||an2<an1&&an2+pi<an1) //如果弧是逆时针方向画的
  300. {
  301. *Angle1=an1;*Angle2=an3; //得到起终弧度
  302. }
  303. else    //如果弧是顺时针画的
  304. {
  305. *Angle1=an3;*Angle2=an1; //得到起终弧度
  306. }
  307. return 1;  //操作成功
  308. }
  310. void CDrawView::OnInitialUpdate()
  311. {
  312. CView::OnInitialUpdate();
  313. CDrawDoc* pDoc = GetDocument();
  314. m_pSelection = NULL;    // initialize selection
  315. p_View=this;
  316. m_pLinkSet=&pDoc->m_linkdata1;
  317. }
  319. /////////////////////////////////////////////////////////////////////////////
  320. // CDrawView printing
  322. BOOL CDrawView::OnPreparePrinting(CPrintInfo* pInfo)
  323. {
  324. // default preparation
  325. return DoPreparePrinting(pInfo);
  326. }
  328. void CDrawView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  329. {
  330. int mPageHeight,mPageWidth,nPage;
  331. m_MapMode=2;
  332. pDC->SetMapMode(m_MapMode);
  333. //整个图形左下角的坐标
  334. xLeft=p_Screen[0].sx;
  335. yBottom=p_Screen[0].sy;
  336. //整个图形右上角的坐标为
  337. xRight=xLeft+p_Screen[0].blc*m_wScreen;
  338. yTop=yBottom+p_Screen[0].blc*m_hScreen;
  339. //图形的横向和纵向的幅度为
  340. xWide=xRight-xLeft;
  341. yHigh=yTop-yBottom;
  343. //point.y=pDC->GetDeviceCaps(VERTRES);  //得到设备竖直方向的像素数
  344. //point.x=pDC->GetDeviceCaps(HORZRES);   //得到设备水平方向的像素数
  345. //pDC->DPtoLP(&point);
  346. pDC->DPtoLP(&(pInfo->m_rectDraw));
  347. mPageHeight=abs(pInfo->m_rectDraw.top-pInfo->m_rectDraw.bottom);
  348. mPageWidth=pInfo->m_rectDraw.right-pInfo->m_rectDraw.left;
  349. //每页的横向和纵向大小
  350. xPage=blc*mPageWidth;                     //每页的实际宽度
  351. yPage=blc*mPageHeight;                    //每页的实际高度
  352. nPageX=(int)(xWide/xPage)+(xWide>xPage*(int)(xWide/xPage));//横向页数
  353. nPageY=(int)(yHigh/yPage)+(yHigh>yPage*(int)(yHigh/yPage));//纵向页数
  354. nPage=nPageX*nPageY;       //总页数
  355. pInfo->SetMinPage(1);      //设置最小页号
  356. pInfo->SetMaxPage(nPage);  //设置最大页号
  357. m_hScreen1=m_hScreen;
  358. m_wScreen1=m_wScreen;
  359. m_hScreen=mPageHeight;    //显示窗口的高度
  360. m_wScreen=mPageWidth;     //显示窗口的宽度
  361. // TODO: add extra initialization before printing
  362. }
  364. void CDrawView::OnEndPrinting(CDC* pDC, CPrintInfo* /*pInfo*/)
  365. {
  366. CDrawDoc *pDoc=(CDrawDoc *)GetDocument();
  367.  //恢复屏幕显示的参数
  368. m_xStart=p_Screen[pDoc->m_CurrentScreen].sx;
  369. m_yStart=p_Screen[pDoc->m_CurrentScreen].sy;
  370. // TODO: add cleanup after printing
  371. m_hScreen=m_hScreen1;
  372. m_wScreen=m_wScreen1;
  373. m_MapMode=1;
  374. }
  376. void CDrawView::OnDestroy()
  377. {
  378.    CView::OnDestroy();
  379.    COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  380.    if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
  381.    {
  382.       pActiveItem->Deactivate();
  383.       ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  384.    }
  385. }
  388. /////////////////////////////////////////////////////////////////////////////
  389. // OLE Client support and commands
  391. BOOL CDrawView::IsSelected(const CObject* pDocItem) const
  392. {
  393. // The implementation below is adequate if your selection consists of
  394. //  only CDrawCntrItem objects.  To handle different selection
  395. //  mechanisms, the implementation here should be replaced.
  396. // TODO: implement this function that tests for a selected OLE client item
  397. return pDocItem == m_pSelection;
  398. }
  400. void CDrawView::OnInsertObject()
  401. {
  402. m_DrawCurrent=50; //进行插入OLE对象操作
  403. PushNumb=0;
  404. }
  406. // The following command handler provides the standard keyboard
  407. //  user interface to cancel an in-place editing session.  Here,
  408. //  the container (not the server) causes the deactivation.
  409. void CDrawView::OnCancelEditCntr()
  410. {
  411. // Close any in-place active item on this view.
  412. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  413. if (pActiveItem != NULL)
  414. {
  415. pActiveItem->Close();
  416. }
  417. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  418. }
  420. // Special handling of OnSetFocus and OnSize are required for a container
  421. //  when an object is being edited in-place.
  422. void CDrawView::OnSetFocus(CWnd* pOldWnd)
  423. {
  424. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  425. if (pActiveItem != NULL &&
  426. pActiveItem->GetItemState() == COleClientItem::activeUIState)
  427. {
  428. // need to set focus to this item if it is in the same view
  429. CWnd* pWnd = pActiveItem->GetInPlaceWindow();
  430. if (pWnd != NULL)
  431. {
  432. pWnd->SetFocus();   // don't call the base class
  433. return;
  434. }
  435. }
  437. CView::OnSetFocus(pOldWnd);
  438. }
  440. //当视图的大小变化时被调用，cx,cy为变化后屏幕顶长、宽（像素）
  441. void CDrawView::OnSize(UINT nType, int cx, int cy)
  442. {
  443. CView::OnSize(nType, cx, cy);
  444. CDrawDoc *pDoc=(CDrawDoc *)GetDocument();
  445. p_Screen=pDoc->m_Screen;
  446. m_wScreen=cx;
  447. m_hScreen=cy;
  448.     nXPage=m_hScreen/nScrollMin;  //横向一屏的滚动范围
  449.     nYPage=m_wScreen/nScrollMin; //纵向一屏的滚动范围
  450. InitVScroll();
  451. InitHScroll();
  452. }
  454. /////////////////////////////////////////////////////////////////////////////
  455. // CDrawView diagnostics
  457. #ifdef _DEBUG
  458. void CDrawView::AssertValid() const
  459. {
  460. CView::AssertValid();
  461. }
  463. void CDrawView::Dump(CDumpContext& dc) const
  464. {
  465. CView::Dump(dc);
  466. }
  468. CDrawDoc* CDrawView::GetDocument() // non-debug version is inline
  469. {
  470. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDrawDoc)));
  471. return (CDrawDoc*)m_pDocument;
  472. }
  473. #endif //_DEBUG
  475. /////////////////////////////////////////////////////////////////////////////
  476. // CDrawView message handlers
  478. void CDrawView::InitVScroll()
  479. {
  480. //得到滚动条的最大范围
  481. nVScrollMax=(int)(((float)m_hScreen*p_Screen[0].blc)/(blc*nScrollMin));
  482. //得到当前的滚动条范围
  483. nVScrollPos=nVScrollMax-(int)((m_yStart-p_Screen[0].sy)/(blc*nScrollMin));
  484. //设置滚动条最大范围和当前位置
  485. SetScrollRange(SB_VERT,0,nVScrollMax,TRUE);
  486. SetScrollPos(SB_VERT,nVScrollPos);//rrr.top=0;
  487. UpdateWindow();
  488. }
  490. void CDrawView::InitHScroll()
  491. {
  493. //得到滚动条的最大范围
  494. nHScrollMax=(int)(((float)m_hScreen*p_Screen[0].blc/blc)/nScrollMin);
  495. //得到当前的滚动条范围
  496. nHScrollPos=(int)((m_xStart-p_Screen[0].sx)/blc/nScrollMin);
  497. //设置滚动条最大范围和当前位置
  498. SetScrollRange(SB_HORZ,0,nHScrollMax,TRUE);
  499. SetScrollPos(SB_HORZ,nHScrollPos);//rrr.top=0;
  500. UpdateWindow();
  502. }
  504. //选中菜单“绘制圆弧”时被调用
  505. void CDrawView::OnDrawArc() 
  506. {
  507. PushNumb=0; //鼠标左键按下次数
  508. m_DrawCurrent=6; //标识进行圆弧绘制操作
  509. }
  511. //选中菜单“绘制圆”时被调用
  512. void CDrawView::OnDrawCircle() 
  513. {
  514. PushNumb=0; //鼠标左键按下次数
  515. m_DrawCurrent=4; //标识进行圆绘制操作
  516. }
  518. //选中菜单“绘制圆形区域”时被调用
  519. void CDrawView::OnDrawCircle1() 
  520. {
  521. PushNumb=0; //鼠标左键按下次数
  522. m_DrawCurrent=5; //标识进行圆形区域操作
  523. }
  525. //选中菜单“绘制直线”时被调用
  526. void CDrawView::OnDrawLine() 
  527. {
  528. PushNumb=0;
  529. m_DrawCurrent=1; //标识进行直线绘制操作
  530. }
  532. //选中菜单“绘制连续直线”时被调用
  533. void CDrawView::OnDrawPline() 
  534. {
  535. PushNumb=0;
  536. m_DrawCurrent=2; //标识进行连续直线绘制操作
  537. }
  539. //选中菜单“绘制多边形区域”时被调用
  540. void CDrawView::OnDrawRgn() 
  541. {
  542. PushNumb=0;
  543. m_DrawCurrent=3; //标识进行多边形区域绘制操作
  544. }
  546. //选中菜单“标注文字”时被调用
  547. void CDrawView::OnDrawText() 
  548. {
  549. PushNumb=0;
  550. m_DrawCurrent=7; //标识进行文字标注操作
  551. }
  553. //在标注文字对话框中填入文字时被调用在屏幕上写文字
  554. void CDrawView::DrawText()
  555. {
  556. CClientDC ht(this);
  557. //以下从标注文字对话框中得到字体参数
  558. m_TextString=pTextDlg->m_Text;
  559. m_FontHeight=pTextDlg->m_FontHeight;
  560. m_FontWide=pTextDlg->m_FontWide;
  561. m_TextAngle=pTextDlg->m_Angle1;
  562. m_FontAngle=pTextDlg->m_Angle2;
  563. m_FontBetween=pTextDlg->m_FontBetween;
  564. //对一个字体类的参数重新进行辅值
  565. m_Text1->Init(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,m_TextX,m_TextY
  566. ,m_TextAngle,m_FontAngle,m_FontHeight,m_FontWide,m_FontBetween,0,m_TextString);
  567. m_Text1->Draw(&ht,0,0,m_bColor);//绘制标注信息
  568. }
  570. //按‘确定'退出标注文字对话框时被调用的函数，用来增加一个标注文字项
  571. void CDrawView::DrawTextOnOk()
  572. {
  573. CDrawDoc* pDoc = GetDocument();
  574.     CClientDC ht(this);    
  575. int TextLong;
  576. PushNumb=0;
  577. m_TextString=pTextDlg->m_Text; //得到标注的文字信息
  578. TextLong=m_TextString.GetLength(); //标注文字的长度
  579. if(TextLong>0)
  580. {
  581. //增加并重新绘制标注的文字
  582. int id=pDoc->GetTextId();
  583. pDoc->AddText(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,id,m_TextX,
  584. m_TextY,m_TextAngle,m_FontAngle,m_FontHeight,m_FontWide,
  585. m_FontBetween,0,TextLong,m_TextString)
  586. ->Draw(&ht,0,0,m_bColor);
  587. pTextDlg->m_Text.Empty(); //清空标注文字对话框中编辑框中顶文字
  588. pTextDlg->SendMessage(WM_INITDIALOG);
  589. //以下是记录增加标注信息这一操作，供逆操作时用
  590. GraphUndo[0].Index=pDoc->GetMaxIndex(5);//此标注文字的位置
  591. GraphUndo[0].Lb=5; //标注文字
  592. pDoc->AddUndo(2,1,GraphUndo);
  593. ReleaseCapture(); //释放捕捉的鼠标
  594. }
  595. }
  597. //按‘放弃'退出标注文字对话框时被调用的函数
  598. void CDrawView::DrawTextOnCancel()
  599. {
  600. pTextDlg->m_Text.Empty(); ////清空标注文字对话框中编辑框中顶文字
  601. pTextDlg->SendMessage(WM_INITDIALOG);
  602. }
  604. //按下鼠标左键时被调用，ON_WM_LBUTTONDOWN消息的映射函数
  605. void CDrawView::OnLButtonDown(UINT nFlags, CPoint point) 
  606. {
  607. // TODO: Add your message handler code here and/or call default
  608.     float r;
  609.     float xx1,yy1,xx2,yy2;
  610. int x1,x2,y1,y2,Lb,Index,pbh;
  611. BOOL m_Fill;
  612. CDrawDoc* pDoc = GetDocument(); //得到文档指针
  613.     CClientDC ht(this);    
  614.     if(m_DrawCurrent==1) //如果正在绘制直线
  615. {
  616. if(PushNumb==0) //如果是第一次按下左鼠标键
  617. {
  618. PushNumb++; //做标记表示按下鼠标左键一次
  619. mPointOrign=point; //直线的第一点等于点中点
  620. mPointOld=point; //记录本次点中点
  621. SetCapture(); //捕捉鼠标输入
  622. }
  623. else if(PushNumb==1) //第二次按下左鼠标键(即按下直线的结束点时)
  624. {
  625. //以下得到直线起终点的实际坐标
  626. VPtoDP(mPointOrign.x,mPointOrign.y,&xx1,&yy1);
  627. VPtoDP(point.x,point.y,&xx2,&yy2);
  628. int id=pDoc->GetLineId(); //得到直线的唯一识别号
  629. //增加一条直线并重新绘画此直线
  630. pDoc->AddLine(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,id,
  631. xx1,yy1,xx2,yy2)
  632. ->Draw(&ht,0,0,m_bColor);
  633. PushNumb=0; //鼠标按键次数为0，重新进行直线的绘制
  634. //以下是记录增加直线这一操作，供逆操作时用
  635. GraphUndo[0].Index=pDoc->GetMaxIndex(1);//得到此直线的序号
  636. GraphUndo[0].Lb=1; //直线
  637. pDoc->AddUndo(2,1,GraphUndo);
  638. ReleaseCapture();
  639. }
  640. }
  642. else if(m_DrawCurrent==2||m_DrawCurrent==3)//正在绘制连续直线或者多边形区域
  643. {
  644. //将点的坐标存入Pointxy中
  645. PointXyz[PushNumb].x=m_xStart+blc*point.x;
  646. PointXyz[PushNumb].y=m_yStart+blc*(m_hScreen-point.y);
  647. if(PushNumb==0)      //如果是第一次按下左鼠标键
  648. {
  649. SetCapture();     //捕捉鼠标
  650. mPointOrign=point;//原点等于点中点
  651. mPointOld=point;  //将前一个点设为点中点的坐标
  652. }
  653. else                 //二次以上按下鼠标左键时
  654. {
  655. mPointOrign=mPointOld; //将上一个点设为原点
  656. mPointOld=point;       //将点中点设为原点
  657. }
  658. PushNumb++; //记录按下点的数目
  659. }
  661. else if(m_DrawCurrent==4||m_DrawCurrent==5)  //如果正在绘制普通圆或者填充圆
  662. {
  663. if(PushNumb==0) //如果是第一次按下左鼠标键
  664. {
  665. mPointOrign=point; //原点等于点中点
  666. mPointOld=point; //上一个点也等于点中点
  667. PushNumb++;
  668. SetCapture(); //捕捉鼠标
  669. }
  670. else //二次以上按下鼠标左键时
  671. {
  672. PushNumb=0; //鼠标按键次数为0，重新进行直线的绘制
  673. //保存圆或填充圆
  674. r=(float)sqrt(pow((float)(mPointOrign.x-mPointOld.x),2)+pow((float)(mPointOrign.y-mPointOld.y),2));
  675. VPtoDP(mPointOrign.x,mPointOrign.y,&xx1,&yy1);
  676. if(m_DrawCurrent==4) //如果是绘制一般圆
  677. m_Fill=0;
  678. else
  679. m_Fill=1;
  680. //保存圆并以覆盖模式重画圆
  681. int id=pDoc->GetCircleId();
  682. pDoc->AddCircle(m_pColor,m_brColor,m_LineWide,m_LineType,
  683. m_Layer,id,xx1,yy1,r,m_Fill)
  684. ->Draw(&ht,0,0,m_bColor);
  685. ReleaseCapture();  //释放捕捉的鼠标 
  686. //以下是记录增加圆这一操作，供逆操作时用
  687. GraphUndo[0].Index=pDoc->GetMaxIndex(3); //此圆的序号
  688. GraphUndo[0].Lb=3; //类别是圆
  689. pDoc->AddUndo(2,1,GraphUndo);
  690. ReleaseCapture();
  691. }
  692. }
  694. else if(m_DrawCurrent==6)//正在绘制圆弧
  695. {
  696. if(PushNumb==0) //第一次按下鼠标左键
  697. {
  698. SetCapture();
  699. DrawArcYes=0;
  700. mPointOrign1=point; //记录圆弧第一点
  701. PushNumb++;
  702. }
  703. else if(PushNumb==1) //第二次按下鼠标左键
  704.         {
  705. mPointOrign=point; //记录下圆弧的第二点
  706. PushNumb++;
  707. }
  708. else //第三次按下鼠标键
  709. {
  710. //计算圆弧的特征参数
  711. jsarc(mPointOrign1,mPointOrign,point,&m_CircleX,&m_CircleY,
  712. &m_CircleR,&m_Angle1,&m_Angle2);
  713. //增加一个圆弧并重新绘制圆弧
  714. int id=pDoc->GetArcId();
  715. pDoc->AddArc(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,id,
  716. m_CircleX,m_CircleY,m_CircleR,0,m_Angle1,m_Angle2)
  717. ->Draw(&ht,0,0,m_bColor);
  718. PushNumb=0;         ////鼠标按键次数为0，重新进行圆弧的绘制
  719. ReleaseCapture();   //释放捕捉的鼠标
  720. //以下是记录增加圆弧这一操作，供逆操作时用
  721. GraphUndo[0].Index=pDoc->GetMaxIndex(4); //此圆弧的序号
  722. GraphUndo[0].Lb=4; //类别是圆弧
  723. pDoc->AddUndo(2,1,GraphUndo);
  724. ReleaseCapture();
  725. }
  726. }
  727. else if(m_DrawCurrent==7) //进行标注文字的操作
  728. {
  729. VPtoDP(point.x,point.y,&m_TextX,&m_TextY);
  730. if(!pTextDlg) //如果标注文字对话框不存在，产生对话框
  731. {
  732. //初始画形成一个标注文字对话框
  733. pTextDlg=new TextWriteDlg(this,m_TextString,m_FontHeight,m_FontWide,
  734. m_TextAngle,m_FontAngle,m_FontBetween);
  735. ASSERT(pTextDlg);
  736. }
  737. if(!(pTextDlg->IsOpen())) //如果对话框没有打开
  738. {
  739. pTextDlg->Create(ID_WRITE_TEXT,this);
  740. }
  741. if(!(pTextDlg->IsVisible()))//如果对话框当前不可见
  742. {
  743. pTextDlg->ShowWindow(SW_SHOW); //使标注文字对话框可见
  744. }
  745. }
  746. else if(m_DrawCurrent==11||m_DrawCurrent==12||m_DrawCurrent==50) //正在进行图形放大或图形移动
  747.     {
  748. if(PushNumb==0) //如果第一次按下鼠标左键
  749.         {
  750. mPointOrign=point; //原点等于点中点
  751. mPointOld=point;   //上一个点等于点中点
  752. PushNumb++;        //按键数增加1
  753. SetCapture();      //捕捉鼠标
  754. }
  755. else if(PushNumb==1)//第二次按下左键
  756. {
  757. if(m_DrawCurrent==11)  //图形放大
  758. {
  759. //得到左下点和右上点
  760. x1=min(mPointOrign.x,point.x);
  761. y1=max(mPointOrign.y,point.y);
  762. x2=max(mPointOrign.x,point.x);
  763. y2=min(mPointOrign.y,point.y); 
  764. //改变原点的坐标
  765. VPtoDP(x1,y1,&m_xStart,&m_yStart);
  766. //改变比例
  767. float bl1=(float)m_wScreen/(float)(x2-x1); //横向放大比例
  768. float bl2=(float)m_hScreen/(float)(y1-y2); //纵向放大比例
  769. if(bl2<bl1)
  770. bl1=bl2; //取较小的变化比例
  771. if(bl1>0)   
  772. blc=blc/bl1; //改变显示比例
  773. pDoc->AddScreen(m_xStart,m_yStart,blc); //保存本屏的参数
  774. InitVScroll();
  775. InitHScroll();
  776. Invalidate(); //使图形重画
  777. }
  778. else if(m_DrawCurrent==12) //图形移动操作
  779. {
  780. //改变原点（左下角点）的实际坐标
  781. m_xStart=m_xStart-blc*(point.x-mPointOrign.x);
  782. m_yStart=m_yStart+blc*(point.y-mPointOrign.y);
  783. pDoc->AddScreen(m_xStart,m_yStart,blc); //保存本屏的参数
  784. InitVScroll();
  785. InitHScroll();
  786. Invalidate(); //使图形重画
  787. }
  788. else if(m_DrawCurrent==50) //如果是插入OLE对象操作
  789. {
  790. //得到左下点和右上点
  791. x1=min(mPointOrign.x,point.x);
  792. y1=max(mPointOrign.y,point.y);
  793. x2=max(mPointOrign.x,point.x);
  794. y2=min(mPointOrign.y,point.y); 
  795. COleInsertDialog dlg;
  796. if (dlg.DoModal() != IDOK)
  797. return;
  798. BeginWaitCursor();
  799. CDrawCntrItem* pItem = NULL;
  800. TRY
  801. {
  802. pItem = new CDrawCntrItem(pDoc);
  803. ASSERT_VALID(pItem);
  804. if (!dlg.CreateItem(pItem))
  805. AfxThrowMemoryException();  // any exception will do
  806. ASSERT_VALID(pItem);
  808. if (dlg.GetSelectionType()==COleInsertDialog::createNewItem)
  809. pItem->DoVerb(OLEIVERB_SHOW, this);
  810. ASSERT_VALID(pItem);
  811. m_pSelection = pItem;   // set selection to last inserted item
  812. VPtoDP(x1,y1,&pItem->m_X1,&pItem->m_Y1);
  813. VPtoDP(x2,y2,&pItem->m_X2,&pItem->m_Y2);
  814. pDoc->UpdateAllViews(NULL);
  815. }
  816. CATCH(CException, e)
  817. {
  818. if (pItem != NULL)
  819. {
  820. ASSERT_VALID(pItem);
  821. pItem->Delete();
  822. }
  823. AfxMessageBox(IDP_FAILED_TO_CREATE);
  824. }
  825. END_CATCH
  826. EndWaitCursor();
  827. }
  828. PushNumb=0; //完成操作，左键按下数置0
  829. m_DrawCurrent=0; //完成一次后，不继续运行此功能
  830. ReleaseCapture(); //释放捕捉的鼠标
  831. }
  832.     }
  833. else if(m_DrawCurrent==30) //进行鼠标选择图形操作
  834. {
  835. if(pDoc->n_GraphSelect==2000) //如果选中的图形元素数是2000则不再选中
  836. {
  837. AfxMessageBox("最多只能选择2000个图形元素");
  838. return;
  839. }
  840. xx1=m_xStart+blc*point.x;               //点中点的实际x坐标
  841. yy1=m_yStart+blc*(m_hScreen-point.y);  //点中点的实际y坐标
  842. float jl=blc*4;            //点中范围（4个像素的实际距离）
  843. //以下对各种元素进行检查，计算是否点中（线，连续直线，圆和圆弧）
  845. BOOL pb=pDoc->PointSelect(xx1,yy1,jl,blc,&Lb,&Index,&pbh);
  846. if(pb) //如果选中了图形元素，记录下选中顶图形元素，特殊显示此图形元素
  847. {  
  848. BOOL pb1=pDoc->AddSelectList(Lb,Index,pbh);
  849. if(pb1)
  850. pDoc->DrawGraph(&ht,Lb,Index,0,1,m_bColor);
  851. }
  852. else
  853. {
  854. CDrawCntrItem* pItemHit=NULL;
  855. POSITION pos=pDoc->GetStartPosition();
  856. while(pos!=NULL)
  857. {
  858. CDrawCntrItem* pItem=(CDrawCntrItem*)pDoc->GetNextItem(pos);
  859. if(pItem->IsPoint(point))
  860. pItemHit=pItem;
  861. }
  862. if(pItemHit==NULL||m_pSelection!=pItemHit)
  863. {
  864. COleClientItem * pActiveItem=GetDocument()->GetInPlaceActiveItem(this);
  865. if(pActiveItem!=NULL&&pActiveItem!=pItemHit)
  866. pActiveItem->Close();
  867. }
  868. Invalidate();
  869. m_pSelection=pItemHit;
  870. if(pItemHit!=NULL)
  871. {
  872. pDoc->b_IsOleSelect=TRUE;
  873. pItemHit->b_Select=TRUE;
  874. CRectTracker tracker;
  875. PutTracker(pItemHit,&tracker);
  876. UpdateWindow();
  877. if(tracker.Track(this,point))
  878. {
  879. Invalidate();
  880. VPtoDP(tracker.m_rect.left,tracker.m_rect.bottom,&pItemHit->m_X1,&pItemHit->m_Y1);
  881. VPtoDP(tracker.m_rect.right,tracker.m_rect.top,&pItemHit->m_X2,&pItemHit->m_Y2);
  882. GetDocument()->SetModifiedFlag();
  883. }
  884. }
  885. }
  886. }
  887. else if(m_DrawCurrent==31) //进行鼠标选择图形操作
  888. {
  889. CString m_str;
  890. char p1[9];
  891. xx1=m_xStart+blc*point.x;               //点中点的实际x坐标
  892. yy1=m_yStart+blc*(m_hScreen-point.y);  //点中点的实际y坐标
  893. float jl=blc*4;            //点中范围（4个像素的实际距离）
  894. BOOL pb=pDoc->PointSelect(xx1,yy1,jl,blc,&Lb,&Index,&pbh);
  895. if(pb)
  896. {
  897. if(m_pLinkSet->IsOpen())
  898. m_pLinkSet->Close();
  899. m_str="(graph_id=";
  900. sprintf(p1,"%d",Lb);
  901. m_str+=p1;
  902. m_str+=") AND (element_id=";
  903. sprintf(p1,"%d",pbh);
  904. m_str+=p1;
  905. m_str+=")";
  906. m_pLinkSet->m_strFilter=m_str;
  907. m_pLinkSet->Open();
  908. if(m_pLinkSet->IsBOF())
  909. {
  910. m_pLinkSet->Close();
  911. return;
  912. }
  913. CDataLinkDlg pDg1(pDoc,m_pLinkSet);
  914. pDg1.DoModal();
  915. }
  916. }
  917. else if(m_DrawCurrent==20) //进行图形粘贴操作
  918. {
  919. OnSelectClear();
  920. xx1=m_xStart+blc*point.x; //点中点的实际x坐标
  921. yy1=m_yStart+blc*(m_hScreen-point.y); //点中点的实际y坐标
  922. if(pDoc->ReadClipBoard(xx1,yy1))
  923. {
  924. // for(int i=0;i<pDoc->n_GraphSelect;i++) //删除图形
  925. // Delete(&ht,pDoc->GraphSelect[i].Lb,pDoc->GraphSelect[i].Index);
  926. //以下是记录删除图形这一操作，供逆操作时用
  927. pDoc->AddUndo(2,pDoc->n_GraphSelect,pDoc->GraphSelect);
  928. pDoc->n_GraphSelect=0; //选中的图形元素为0
  929. Invalidate();
  930. }
  931. }
  932. CView::OnLButtonDown(nFlags, point);
  933. }
  935. //鼠标移动时被调用，ON_WM_MOUSEMOVE消息的映射函数
  936. void CDrawView::OnMouseMove(UINT nFlags, CPoint point) 
  937. {
  938. // TODO: Add your message handler code here and/or call default
  939. CDrawDoc* pDoc = GetDocument(); //得到文档的指针
  940. CClientDC ddd(this);
  941. CPen pen(0,0,RGB(0,0,0));
  942. CPen* pOldPen=ddd.SelectObject(&pen);
  943. ddd.SetROP2(R2_NOT); //选择反色的绘画模式
  944. int r;
  945. BOOL pb;
  946. float x1,y1;
  947. char p1[20];
  948. CMainFrame* pFrame=(CMainFrame*)(AfxGetApp()->m_pMainWnd);
  950. VPtoDP(point.x,point.y,&x1,&y1);
  951.     sprintf(p1,"%f",x1);                  //将横坐标变为字符串
  952.     pFrame->m_wndStatusBar.SetPaneText(2,p1,TRUE);//在状态条的第3个指示器写入
  953.     sprintf(p1,"%f",y1);                  //将总坐标转为字符串
  954.     pFrame->m_wndStatusBar.SetPaneText(3,p1,TRUE);//在状态条的第4个指示器写入
  956. if(m_DrawCurrent==1&&PushNumb==1)//如果是绘制直线并且已经按下第一点
  957. {
  958. if(mPointOld!=point)//如果鼠标的现在移动点与上一个点不相同
  959.         //将起点到上一个移动点的直线擦除，绘制从起点到现在移动点的直线
  960. {
  961. ddd.MoveTo(mPointOrign); 
  962. ddd.LineTo(mPointOld);  //擦除上一条线
  963. ddd.MoveTo(mPointOrign);
  964. ddd.LineTo(point);      //画到鼠标移动点的直线
  965. mPointOld=point;  
  966. }
  967. }
  968. else if((m_DrawCurrent==2||m_DrawCurrent==3)&&PushNumb>=1)
  969. //如果是绘制连续直线或封闭多边形，并且已经按下第一点
  970. {
  971. if(mPointOld!=point)//如果鼠标的现在移动点与上一个点不相同
  972.        //将上一个顶点到上一个移动点的直线擦除，绘制从上一个顶点到移动点的直线
  973. {
  974. ddd.MoveTo(mPointOrign); 
  975. ddd.LineTo(mPointOld);   //擦除原来的直线
  976. ddd.MoveTo(mPointOrign);
  977. ddd.LineTo(point);       //重画移动到点的直线
  978. mPointOld=point;  
  979. }
  980. }
  981. else if((m_DrawCurrent==4||m_DrawCurrent==5)&&PushNumb>=1)
  982. //如果是绘制圆或圆形区域，并且已经按下第一点
  983. {
  984. if(mPointOld!=point)//如果鼠标的现在移动点与上一个点不相同
  985.         //将原来的圆擦掉，重新绘制圆
  986.         {
  987. if(m_DrawCurrent==4)
  988. ddd.SelectStockObject(NULL_BRUSH); //如果是普通圆，设置不填充状态
  989. //上一个圆的半径  
  990. r=(int)sqrt(pow((float)(mPointOrign.x-mPointOld.x),2)+pow((float)(mPointOrign.y-mPointOld.y),2));
  991. //擦除上一个圆
  992. ddd.Ellipse(mPointOrign.x-r,mPointOrign.y-r,mPointOrign.x+r,mPointOrign.y+r);
  993. //移动点所在圆的半径
  994. r=(int)sqrt(pow((long)(mPointOrign.x-point.x),2)+pow((float)(mPointOrign.y-point.y),2));
  995. //绘制一个新圆
  996. ddd.Ellipse(mPointOrign.x-r,mPointOrign.y-r,mPointOrign.x+r,mPointOrign.y+r);
  997. mPointOld=point;  
  998. }
  999. }
  1000. else if(m_DrawCurrent==6) //在绘制圆弧操作
  1001. {
  1002. if(PushNumb==2&&mPointOld!=point) //按下第二个点后
  1003. {
  1004. if(DrawArcYes>0) //如果不是第一次画弧
  1005. m_Arc1.Draw(&ddd,1,0,m_bColor); //擦掉原来的圆弧
  1006. pb=jsarc(mPointOrign1,mPointOrign,point,&m_CircleX,&m_CircleY,
  1007. &m_CircleR,&m_Angle1,&m_Angle2); //计算目前圆弧的参数
  1008. if(pb) //如果三点能够形成圆弧，则以反色模式重新绘制实际是擦除圆弧
  1009. {
  1010. m_Arc1.Init(m_pColor,m_brColor,m_LineWide,m_LineType,
  1011. m_Layer,m_CircleX,m_CircleY,m_CircleR,0,m_Angle1,m_Angle2);
  1012. m_Arc1.Draw(&ddd,1,0,m_bColor);
  1013. }
  1014. DrawArcYes=pb;               //判断下一次绘制弧时要先删除弧
  1015. mPointOld=point;
  1016. }
  1017. }
  1018. else if((m_DrawCurrent==11||m_DrawCurrent==12||m_DrawCurrent==50)&&PushNumb==1)
  1019. //如果是图形放大或移动并且按下了第一点
  1020.     {
  1021. if(point!=mPointOld) //如果鼠标移动了
  1022. {
  1023. if(m_DrawCurrent==11||m_DrawCurrent==50) //如果是图形放大操作
  1024. {
  1025. ddd.SelectStockObject(NULL_BRUSH); //设置不填充状态
  1026. //擦除原来的矩形
  1027. ddd.Rectangle(mPointOrign.x,mPointOrign.y,mPointOld.x,mPointOld.y);
  1028. //画新的矩形
  1029. ddd.Rectangle(mPointOrign.x,mPointOrign.y,point.x,point.y);
  1030. }
  1031. else //如果是图形移动操作
  1032. {
  1033. //擦除原来的橡皮线
  1034. ddd.MoveTo(mPointOrign); ddd.LineTo(mPointOld);
  1035. //画新的橡皮线
  1036. ddd.MoveTo(mPointOrign); ddd.LineTo(point);
  1037. }
  1038. mPointOld=point;  //将本次移动点作为下次移动的上一点
  1039. }
  1040.     }
  1041. ddd.SelectObject(pOldPen); //选出画笔
  1042. CView::OnMouseMove(nFlags, point);
  1043. }
  1045. //按下鼠标右键时被调用，ON_WM_RBUTTONDOWN消息的映射函数
  1046. void CDrawView::OnRButtonDown(UINT nFlags, CPoint point) 
  1047. {
  1048. // TODO: Add your message handler code here and/or call default
  1049. int r;
  1050. CDrawDoc* pDoc = GetDocument();
  1051. CClientDC ddd(this);
  1052. CPen pen(0,0,RGB(0,0,0)); //定义一个画笔
  1053. CPen* pOldPen=ddd.SelectObject(&pen); //选择一个画笔
  1054. ddd.SetROP2(R2_NOT); //设置反色的绘画模式
  1055. if(m_DrawCurrent==1&&PushNumb==1) //如果正在绘制直线并且已经按下了起点
  1056. {
  1057. //将直线从屏幕上擦除并使绘制处于起始状态
  1058. ddd.MoveTo(mPointOrign);
  1059. ddd.LineTo(mPointOld);  //擦除屏幕上的拖动线
  1060. PushNumb=0;             //结束绘制
  1061. ReleaseCapture();       //释放捕捉的鼠标
  1062. }
  1063. else if((m_DrawCurrent==2||m_DrawCurrent==3)&&PushNumb>0)
  1064. {
  1065. //如果正在绘制连续直线或多边形区域并且已经按下了一次以上鼠标左键
  1066. //擦除最后一段直线
  1067. ddd.MoveTo(mPointOrign); 
  1068. ddd.LineTo(mPointOld);
  1069. if(m_DrawCurrent==2&&PushNumb>1) //如果顶点数大于1并在绘制直线
  1070. {
  1071. //保存连续直线并重新绘制连续直线
  1072. int id=pDoc->GetPLineId();
  1073. pDoc->AddPLine(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,id,
  1074. PushNumb,PointXyz,0)
  1075. ->Draw(&ddd,0,0,m_bColor);
  1076. //以下是记录增加连续直线这一操作，供逆操作时用
  1077. GraphUndo[0].Index=pDoc->GetMaxIndex(2);
  1078. GraphUndo[0].Lb=2;
  1079. pDoc->AddUndo(2,1,GraphUndo);
  1080. ReleaseCapture();
  1081. }
  1082. else if(m_DrawCurrent==3&&PushNumb>2)//如果顶点数大于1并在绘制多边形区域
  1083. {
  1084. //保存封闭多边形并重新绘制封闭多边形
  1085. int id=pDoc->GetPLineId();
  1086. pDoc->AddPLine(m_pColor,m_brColor,m_LineWide,m_LineType,m_Layer,id,PushNumb,PointXyz,1)
  1087. ->Draw(&ddd,0,0,m_bColor);
  1088. //以下是记录增加多边形区域这一操作，供逆操作时用
  1089. GraphUndo[0].Index=pDoc->GetMaxIndex(2);
  1090. GraphUndo[0].Lb=2;
  1091. pDoc->AddUndo(2,1,GraphUndo);
  1092. ReleaseCapture();
  1093. }
  1094. PushNumb=0;
  1095. ReleaseCapture(); //释放捕捉的鼠标
  1096. }
  1098. else if((m_DrawCurrent==4||m_DrawCurrent==5)&&PushNumb>0)
  1099. //如果是绘制圆或圆形区域，并且已经按下第一点
  1100. {
  1101. if(m_DrawCurrent==4)
  1102. ddd.SelectStockObject(NULL_BRUSH); //如果是普通圆，设置不填充状态
  1103. //得到上一个圆的半径 
  1104. r=(int)sqrt(pow((float)(mPointOrign.x-mPointOld.x),2)+pow((float)(mPointOrign.y-mPointOld.y),2));
  1105. //重画以擦除圆
  1106. ddd.Ellipse(mPointOrign.x-r,mPointOrign.y-r,mPointOrign.x+r,mPointOrign.y+r);
  1107. ReleaseCapture();  //释放捕捉的鼠标
  1108. PushNumb=0;
  1109. }
  1110.     
  1111. else if(m_DrawCurrent==6&&PushNumb>0)//正在绘制弧并且按下了第一点
  1112. {
  1113. if(PushNumb==2)//已经按下两个点正在拖动弧
  1114. m_Arc1.Draw(&ddd,1,0,m_bColor); //擦掉原来的弧
  1115. PushNumb=0; //没有按中键
  1116. ReleaseCapture();
  1117. }
  1119. else if((m_DrawCurrent==11||m_DrawCurrent==12||m_DrawCurrent==50)&&PushNumb==1)
  1120. //如果在进行图形放大或图形移动并且按下了一次鼠标左键
  1121. {
  1122. ddd.SelectStockObject(NULL_BRUSH); //设置不填充状态
  1123. if(m_DrawCurrent==11||m_DrawCurrent==50)     //如果是在“图形放大”，擦除矩形框
  1124. ddd.Rectangle(mPointOrign.x,mPointOrign.y,point.x,point.y);
  1125. else //如果是在“图形移动”，擦除橡皮线
  1126. {
  1127. ddd.MoveTo(mPointOrign);
  1128. ddd.LineTo(point);
  1129. }
  1130. ReleaseCapture();  //释放捕捉的鼠标
  1131. PushNumb=0;        //放弃操作，使左键按下数置0
  1132. }
  1133. ddd.SelectObject(pOldPen);
  1134. CView::OnRButtonDown(nFlags, point);
  1135. }
  1138. //“图形重画”菜单项的映射函数
  1139. void CDrawView::OnGraphRedraw() 
  1140. {
  1141. CDrawDoc* pDoc = GetDocument(); //得到文档的指针
  1142. Invalidate();
  1143. pDoc->UpdateAllViews(this);
  1144. }
  1146. //“图形放大”菜单项的映射函数
  1147. void CDrawView::OnGraphZoom() 
  1148. {
  1149. m_DrawCurrent=11; //标识进行图形放大操作
  1150. PushNumb=0;
  1151. }
  1153. //“图形移动”菜单项的对应函数
  1154. void CDrawView::OnGraphPan() 
  1155. {
  1156. m_DrawCurrent=12; //标识进行图形移动操作
  1157. PushNumb=0;
  1158. }
  1160. //“重画上屏”菜单项的对应函数
  1161. void CDrawView::OnGraphUp() 
  1162. {
  1163. CDrawDoc *pDoc=(CDrawDoc *)GetDocument();
  1164. if(pDoc->m_CurrentScreen>0) //如果不是第一屏
  1165. pDoc->m_CurrentScreen--;
  1166. //得到上一屏的图形参数并重画
  1167. m_xStart=p_Screen[pDoc->m_CurrentScreen].sx;
  1168. m_yStart=p_Screen[pDoc->m_CurrentScreen].sy;
  1169. blc=p_Screen[pDoc->m_CurrentScreen].blc;
  1170. InitVScroll();
  1171. InitHScroll();
  1172. Invalidate();
  1173. }
  1175. //“重画首屏”菜单项的对应函数
  1176. void CDrawView::OnGraphFirst() 
  1177. {
  1178. CDrawDoc *pDoc=(CDrawDoc *)GetDocument();
  1179. if(pDoc->m_CurrentScreen==0)
  1180. return;
  1181. m_xStart=p_Screen[0].sx;
  1182. m_yStart=p_Screen[0].sy;
  1183. blc=p_Screen[0].blc;
  1184. pDoc->AddScreen(m_xStart,m_yStart,blc);
  1185. InitVScroll();
  1186. InitHScroll();
  1187. Invalidate();
  1188. }
  1190. //“重画全屏”菜单项的对应函数
  1191. void CDrawView::OnGraphAll() 
  1192. {
  1193. float minx,miny,maxx,maxy,bl1;
  1194. CDrawDoc* pDoc = GetDocument();
  1195. //捕捉光标，并使光标成沙漏等待光标
  1196. //把最小值给非常大，把最大值给非常小，为了对变量进行初试化
  1197. minx=(float)1E20;miny=(float)1E20;maxx=-(float)1E20;maxy=-(float)1E20;
  1198. SetCapture();
  1199. SetCursor(LoadCursor(NULL,IDC_WAIT));
  1200. BOOL pb=pDoc->GetRect(&minx,&miny,&maxx,&maxy);
  1201. //将光标变为箭头形，放弃捕捉的光标
  1202.     SetCursor(LoadCursor(NULL,IDC_ARROW));
  1203.     ReleaseCapture();
  1204. if(!pb) //没有图形元素,程序返回
  1205. return;
  1206. bl1=(maxx-minx)/(m_wScreen-20);//横向的比例
  1207. blc=(maxy-miny)/(m_hScreen-20);//实际纵向比例
  1208. if(bl1>blc)blc=bl1;  //取较大的一个作为比例尺
  1209. /*以下确定屏幕左下角的实际坐标，即在左侧和下侧都留了10点阵的区域
  1210. （minx,miny)在屏幕的左下角向右10点阵同时向上10点阵处。*/
  1211. m_xStart=minx-10*blc;
  1212. m_yStart=miny-10*blc;
  1213. //将全图的显示比例放在首屏，并把屏幕设为首屏
  1214. p_Screen[0].sx=m_xStart;
  1215. p_Screen[0].sy=m_yStart;
  1216. p_Screen[0].blc=blc;
  1217. pDoc->m_CurrentScreen=0;
  1218. InitVScroll();
  1219. InitHScroll();
  1220. Invalidate();
  1221. }
  1223. //“鼠标选中”菜单项的对应函数
  1224. void CDrawView::OnSelectMouse() 
  1225. {
  1226. m_DrawCurrent=30; //标识进行图形选中操作
  1227. PushNumb=0;
  1228. }
  1230. //“放弃选中”菜单项的对应函数，用来放弃所作的选择
  1231. void CDrawView::OnSelectClear() 
  1232. {
  1233. CDrawDoc* pDoc = GetDocument();
  1234. CClientDC ht(this);
  1235. for(int i=0;i<pDoc->n_GraphSelect;i++) //将选中的图形元素原样进行绘制
  1236. pDoc->DrawGraph(&ht,pDoc->GraphSelect[i].Lb,pDoc->GraphSelect[i].Index,0,0,m_bColor);
  1237. pDoc->n_GraphSelect=0;
  1238. if(pDoc->b_IsOleSelect)
  1239. {
  1240. POSITION pos=pDoc->GetStartPosition();
  1241. while(pos!=NULL)
  1242. {
  1243. CDrawCntrItem *pItem=(CDrawCntrItem *)pDoc->GetNextClientItem(pos);
  1244. if(pItem!=NULL)
  1245. pItem->b_Select=FALSE;
  1246. }
  1247. pDoc->b_IsOleSelect=0;
  1248. Invalidate();
  1249. }
  1250. }
  1252. //用来删除一个图形元素的函授数
  1253. //Lb-删除图形的类别 Index-删除图形顶序列号
  1254. void CDrawView::Delete(CDC* pDC,int Lb,int Index)
  1255. {
  1256. float x1,y1,x2,y2;
  1257. CDrawDoc* pDoc = GetDocument();
  1258. if(Lb==1) //如果是直线，得到直线指针并以屏幕底色重画达到删除的效果
  1259. {
  1260. CLine* p_Line=pDoc->GetLine(Index);
  1261. p_Line->Draw(pDC,0,2,m_bColor);
  1262. p_Line->Delete(1); //做删除标识
  1263. }
  1264. else if(Lb==2) //如果是连续直线或多边形
  1265. {
  1266. CPline* p_PLine=pDoc->GetPLine(Index); //得到连续直线（多边形）的指针
  1267. if(p_PLine->IsPLine()) //如果是连续直线，以屏幕底色重画达到删除的效果
  1268. p_PLine->Draw(pDC,0,2,m_bColor);
  1269. else //如果是多边形区域
  1270. {
  1271. p_PLine->GetRect(&x1,&y1,&x2,&y2); //得到多边形区域的边界矩形
  1272. ReDrawRect(x1,y1,x2,y2); //重画多边形区域所在顶区域
  1273. }
  1274. p_PLine->Delete(1); //做删除标识
  1275. }
  1276. else if(Lb==3) //如果是圆或圆形区域
  1277. {
  1278. CCircle* p_Circle=pDoc->GetCircle(Index);//得到圆（圆形区域）的指针
  1279. if(p_Circle->IsCircle()) //如果是圆，则以屏幕底色进行重画
  1280. p_Circle->Draw(pDC,0,2,m_bColor);
  1281. else //如果是圆形区域，则得到其边界矩形并重画这个区域
  1282. {
  1283. p_Circle->GetRect(&x1,&y1,&x2,&y2);
  1284. ReDrawRect(x1,y1,x2,y2);
  1285. }
  1286. p_Circle->Delete(1); //做删除标识
  1287. }
  1288. else if(Lb==4) //如果是圆弧，则以屏幕底色进行重画
  1289. {
  1290. CArc* p_Arc=pDoc->GetArc(Index); //得到圆弧的指针
  1291. p_Arc->Draw(pDC,0,2,m_bColor);
  1292. p_Arc->Delete(1); //做删除标识
  1293. }
  1294. else if(Lb==5) //如果是标注文字，则得到其边界矩形并重画这个区域
  1295. {
  1296. CText* p_Text=pDoc->GetText(Index); //得到标注文字的指针
  1297. p_Text->GetRect(&x1,&y1,&x2,&y2);
  1298. p_Text->Delete(1); //做删除标识
  1299. ReDrawRect(x1,y1,x2,y2);//重画屏幕区域
  1300. }
  1301. }
  1303. //此函数用来重画由点（X1,Y1)和点(X2,Y2)确定的区域
  1304. void CDrawView::ReDrawRect(float X1, float Y1, float X2, float Y2)
  1305. {
  1306. float xx1,xx2,yy1,yy2;
  1307. CRect r1;
  1308. xx1=m_xStart; xx2=m_xStart+blc*m_wScreen;
  1309. yy1=m_yStart; yy2=m_yStart+blc*m_hScreen;
  1310. //得到区域与视图区域相交的矩形
  1311. BOOL IsCross=RectCross(&xx1,&yy1,&xx2,&yy2,X1,Y1,X2,Y2);
  1312. if(IsCross) //如果相交，则重画这一区域
  1313. {
  1314. //以下得到这个区域顶像素坐标
  1315. r1.left=(int)((xx1-m_xStart)/blc)-1;
  1316. r1.right=(int)((xx2-m_xStart)/blc)+1;
  1317. r1.top=m_hScreen-(int)((yy2-m_yStart)/blc)-1;
  1318. r1.bottom=m_hScreen-(int)((yy1-m_yStart)/blc)+1;
  1319. InvalidateRect(r1);
  1320. }
  1321. }
  1323. //此函数用来计算由(*x1,*y1),(*x2,*y2)和(xx1,yy1),(xx2,yy2)决定的两个区域的相交区域
  1324. //返回：TURE，两区域相交，相交区域由(*x1,*y1),(*x2,*y2)决定
  1325. BOOL CDrawView::RectCross(float* x1,float* y1,float* x2,float* y2,float xx1,
  1326.    float yy1,float xx2,float yy2)
  1327. {
  1328. float m_X1,m_Y1,m_X2,m_Y2;
  1329. m_X1=*x1; m_Y1=*y1; m_X2=*x2 ;m_Y2=*y2;
  1330. if(m_X1>xx2||m_X2<xx1||m_Y1>yy2||m_Y2<yy1) //两个矩形区域不相交
  1331. return FALSE; //如不相交函数返回0
  1332. else //两个矩形相交，得到相交矩形的坐标
  1333. {
  1334. *x1=max(m_X1,xx1);
  1335. *y1=max(m_Y1,yy1);
  1336. *x2=min(m_X2,xx2);
  1337. *y2=min(m_Y2,yy2);
  1338. return TRUE; //如果相交就返回1
  1339. }
  1340. }
  1342. //“删除图形”菜单项的对应函数，用来删除鼠标选中的图形
  1343. void CDrawView::OnSelectDelete()
  1344. {
  1345. CDrawDoc* pDoc = GetDocument();
  1346. CClientDC ht(this);
  1347. for(int i=0;i<pDoc->n_GraphSelect;i++) //删除选中的图形
  1348. Delete(&ht,pDoc->GraphSelect[i].Lb,pDoc->GraphSelect[i].Index);
  1349. //以下是记录删除图形这一操作，供逆操作时用
  1350. pDoc->AddUndo(3,pDoc->n_GraphSelect,pDoc->GraphSelect);
  1351. ReleaseCapture();
  1352. pDoc->n_GraphSelect=0; //选中的图形元素为0
  1353. if(pDoc->b_IsOleSelect)
  1354. {
  1355. POSITION pos=pDoc->GetStartPosition();
  1356. while(pos!=NULL)
  1357. {
  1358. CDrawCntrItem *pItem=(CDrawCntrItem *)pDoc->GetNextClientItem(pos);
  1359. if(pItem!=NULL)
  1360. {
  1361. if(pItem->b_Select)
  1362. {
  1363. pDoc->RemoveItem(pItem);
  1364. delete pItem;
  1365. m_pSelection =NULL;   // set selection to last inserted item
  1366. }
  1367. }
  1368. }
  1369. pDoc->UpdateAllViews(this);
  1370. }
  1371. }
  1373. //“Cut"菜单项的对应函数，用来删除鼠标选中的图形并将删除的图形放在剪裁板
  1374. void CDrawView::OnEditCut() 
  1375. {
  1376. CClientDC ht(this);
  1377. CDrawDoc* pDoc = GetDocument();
  1378. if(pDoc->WriteClipBoard())
  1379. {
  1380. for(int i=0;i<pDoc->n_GraphSelect;i++) //删除图形
  1381. Delete(&ht,pDoc->GraphSelect[i].Lb,pDoc->GraphSelect[i].Index);
  1382. //以下是记录删除图形这一操作，供逆操作时用
  1383. pDoc->AddUndo(3,pDoc->n_GraphSelect,pDoc->GraphSelect);
  1384. pDoc->n_GraphSelect=0; //选中的图形元素为0
  1385. }
  1386. }
  1389. void CDrawView::OnEditPaste() 
  1390. {
  1391. m_DrawCurrent=20;
  1392. PushNumb=0;
  1393. }
  1395. //“Copy"菜单项的对应函数，用来将选中的图形放在剪裁板
  1396. void CDrawView::OnEditCopy() 
  1397. {
  1398. CDrawDoc* pDoc = GetDocument();
  1399. pDoc->WriteClipBoard(); //将图形写入剪裁板
  1400. }
  1402. //“Undo"菜单项的对应函数，用来实现完全的逆操作
  1403. void CDrawView::OnEditUndo() 
  1404. {
  1405. CDrawDoc* pDoc = GetDocument();
  1406. CClientDC ht(this);
  1407. pDoc->OnEditUndo(); //进行一步逆操作
  1408. pDoc->UpdateAllViews(this); //重画所有视图
  1409. }
  1411. void CDrawView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1412. {
  1413. short nScrollInc;
  1414. int nNewPos;
  1415. CRect r1;
  1416. switch(nSBCode)
  1417. {
  1418. case SB_TOP:
  1419. nScrollInc=-nHScrollPos;
  1420. break;
  1421. case SB_BOTTOM:
  1422. nScrollInc=nHScrollMax-nHScrollPos;
  1423. break;
  1424. case SB_LINEUP:
  1425. nScrollInc=-nXLine;
  1426. break;
  1427. case SB_LINEDOWN:
  1428. nScrollInc=nXLine;
  1429. break;
  1430. case SB_PAGEUP:
  1431. nScrollInc=-nXPage;
  1432. break;
  1433. case SB_PAGEDOWN:
  1434. nScrollInc=nXPage;
  1435. break;
  1436. case SB_THUMBPOSITION:
  1437. nScrollInc=nPos-nHScrollPos;
  1438. break;
  1439. default:
  1440. nScrollInc=0;
  1441. }
  1442. nNewPos=max(0,min(nHScrollPos+nScrollInc,nHScrollMax));
  1443. nScrollInc=nNewPos-nHScrollPos;
  1444. if(nScrollInc) //如果产生了滚动
  1445. {
  1446. nHScrollPos=nNewPos;  //设定新的滚动位置
  1447. SetScrollPos(SB_HORZ,nHScrollPos);
  1448. UpdateWindow();//使滚动条的位置改动在屏幕上实现
  1449. m_xStart=m_xStart+blc*nScrollInc*nScrollMin;//调整纵坐标使图形产生滚动
  1450. GetClientRect(&r1);  //得到客户区的矩形边界
  1451. if(abs(nScrollInc)*nScrollMin<r1.right) //如果滚动后的屏幕与滚动前有重叠
  1452. {
  1453. if(nScrollInc>0)    //如果是图形向上滚动
  1454. r1.left=nScrollInc*nScrollMin; //得到滚动屏幕上重叠区域的矩形
  1455. else                //如果图形向下滚动
  1456. r1.right=r1.right-nScrollInc*nScrollMin; //得到重叠区域的矩形
  1457. ScrollWindow(-nScrollInc*nScrollMin,0,r1);  //滚动重叠的区域
  1458. if(nScrollInc>0)                            //如果是向上滚动
  1459. r1.left=r1.right-nScrollInc*nScrollMin;   //得到需要重画的区域
  1460. else                                        //如果是向下滚动
  1461. r1.right=-nScrollInc*nScrollMin;         //得到需要重画的区域
  1462. InvalidateRect(r1,0);                       //对图形进行局部重画
  1463. }
  1464. else //如果滚动后的区域与滚动前的区域没有重叠，则全屏重画
  1465. Invalidate();
  1466. //恢复矩形rr原来的坐标
  1467. //        r.left=0;
  1468. //      r.right=ScreenWide;
  1469. }
  1470. /*
  1471. if(nScrollInc)
  1472. {
  1473. nHScrollPos=nNewPos;
  1474. SetScrollPos(SB_HORZ,nHScrollPos);
  1475. UpdateWindow();
  1476. startx=startx+blc*nScrollInc*nScrollMin;
  1477. Screenxy[numb][0]=startx;
  1478. Invalidate();
  1479. r.top=0;
  1480. r.bottom=ScreenHigh;
  1481. }*/
  1482. CView::OnHScroll(nSBCode, nPos, pScrollBar);
  1483. }
  1485. void CDrawView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  1486. {
  1487. short nScrollInc;
  1488. int nNewPos;
  1489. CRect r1;
  1490. switch(nSBCode) //判断按键位置
  1491. {
  1492. case SB_TOP:                 //如果将滚动条滚动到顶部
  1493. nScrollInc=-nVScrollPos;   //得到相对滚动范围
  1494. break;
  1495. case SB_BOTTOM:              //如果将滚动条滚动到底部
  1496. nScrollInc=nVScrollMax-nVScrollPos; //得到相对的滚动范围
  1497. break;
  1498. case SB_LINEUP:             //如果按了滚动条中的向上的按键
  1499. nScrollInc=-nYLine;      //得到相对滚动位置
  1500. break;
  1501. case SB_LINEDOWN:           //如果按中了向下的按键
  1502. nScrollInc=nYLine;        //得到相对的滚动位置
  1503. break;
  1504. case SB_PAGEUP:             //如果按中了中间活动按钮的上部区域
  1505. nScrollInc=-nYPage;       //得到相对的滚动位置
  1506. break;                    
  1507. case SB_PAGEDOWN:           //如果按中了中间活动钮的下部位置
  1508. nScrollInc=nYPage;        //得到相对的滚动位置
  1509. break;
  1510. case SB_THUMBPOSITION:      //如果用鼠标拖动中间活动钮到一个位置
  1511. nScrollInc=nPos-nVScrollPos; //通过信息处理函数得到的按钮位置得到相对移动位置
  1512. break;
  1513. default:
  1514. nScrollInc=0;
  1515. }
  1516. //进行滚动边界检查，得到实际的滚动位置（不能超出滚动条的滚动范围）
  1517. nNewPos=max(0,min(nVScrollPos+nScrollInc,nVScrollMax));
  1518. //得到实际的相对滚动范围
  1519. nScrollInc=nNewPos-nVScrollPos;
  1520. if(nScrollInc) //如果产生了滚动
  1521. {
  1522. nVScrollPos=nNewPos;  //设定新的滚动位置
  1523. SetScrollPos(SB_VERT,nVScrollPos);
  1524. UpdateWindow();//使滚动条的位置改动在屏幕上实现
  1525. m_yStart=m_yStart-blc*nScrollInc*nScrollMin;//调整纵坐标使图形产生滚动
  1526. GetClientRect(&r1);  //得到客户区的矩形边界
  1527. if(abs(nScrollInc)*nScrollMin<r1.bottom) //如果滚动后的屏幕与滚动前有重叠
  1528. {
  1529. if(nScrollInc>0)    //如果是图形向上滚动
  1530. r1.top=nScrollInc*nScrollMin; //得到滚动屏幕上重叠区域的矩形
  1531. else                //如果图形向下滚动
  1532. r1.bottom=r1.bottom+nScrollInc*nScrollMin; //得到重叠区域的矩形
  1533. ScrollWindow(0,-nScrollInc*nScrollMin,r1);  //滚动重叠的区域
  1534. if(nScrollInc>0)                            //如果是向上滚动
  1535. r1.top=r1.bottom-nScrollInc*nScrollMin;   //得到需要重画的区域
  1536. else                                        //如果是向下滚动
  1537. r1.bottom=-nScrollInc*nScrollMin;         //得到需要重画的区域
  1538. InvalidateRect(r1,0);                       //对图形进行局部重画
  1539. //pbdy=1;
  1540. }
  1541. else //如果滚动后的区域与滚动前的区域没有重叠，则全屏重画
  1542. Invalidate();
  1543. }
  1544. CView::OnVScroll(nSBCode, nPos, pScrollBar);
  1545. }
  1547. void CDrawView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1548. {
  1549. switch(nChar)
  1550. {
  1551. case VK_HOME:
  1552. OnHScroll(SB_PAGEUP,0,NULL);
  1553. break;
  1554. case VK_END:
  1555. OnHScroll(SB_PAGEDOWN,0,NULL);
  1556. break;
  1557. case VK_PRIOR:
  1558. OnVScroll(SB_PAGEUP,0,NULL);
  1559. break;
  1560. case VK_NEXT:
  1561. OnVScroll(SB_PAGEDOWN,0,NULL);
  1562. break;
  1563. case VK_UP:
  1564. OnVScroll(SB_LINEUP,0,NULL);
  1565. break;
  1566. case VK_DOWN:
  1567. OnVScroll(SB_LINEDOWN,0,NULL);
  1568. break;
  1569. case VK_LEFT:
  1570. OnHScroll(SB_LINEUP,0,NULL);
  1571. break;
  1572. case VK_RIGHT:
  1573. OnHScroll(SB_LINEDOWN,0,NULL);
  1574. break;
  1575. }
  1576. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  1577. }
  1579. void CDrawView::OnChangeDlgEdit()
  1580. {
  1581. char p1[7];
  1582. CMainFrame* p_Wnd=(CMainFrame *)(AfxGetApp()->m_pMainWnd);
  1583. p_Wnd->m_wndDlgBar.GetDlgItemText(IDC_EDIT1,p1,6);
  1584. m_LineWide=(unsigned char)atoi(p1);
  1585. }
  1587. void CDrawView::OnChangeDlgCom()
  1588. {
  1589. CMainFrame* p_Wnd=(CMainFrame *)(AfxGetApp()->m_pMainWnd);
  1590. CComboBox* plist=(CComboBox*)(p_Wnd->m_wndDlgBar.GetDlgItem(IDC_COMBO1));
  1591. m_LineType=(unsigned char)plist->GetCurSel();
  1592. }
  1594. void CDrawView::OnBitmapCut() 
  1595. {
  1596. CBitmap Bitmap;
  1597. CClientDC ht(this);
  1598. CDC MemDC;
  1599. RECT r1;
  1600. GetClientRect(&r1);
  1601. Bitmap.CreateCompatibleBitmap(&ht,r1.right-r1.left,r1.bottom-r1.top);
  1602. MemDC.CreateCompatibleDC(&ht);
  1603. MemDC.SelectObject(&Bitmap);
  1604. MemDC.BitBlt(0,0,r1.right-r1.left,r1.bottom-r1.top,&ht,0,0,SRCCOPY);
  1605. ht.BitBlt(0,0,r1.right-r1.left,r1.bottom-r1.top,&MemDC,100,100,SRCCOPY);
  1606. if(!OpenClipboard())
  1607. return;
  1608. EmptyClipboard();
  1609. ::SetClipboardData(CF_BITMAP,Bitmap.m_hObject);
  1610. Bitmap.Detach();
  1611. CloseClipboard();
  1612. }
  1614. void CDrawView::OnBitmapPaste() 
  1615. {
  1616. CClientDC ht(this);
  1617. CBitmap Bitmap;
  1618. BITMAP BitmapInfo;
  1619. HANDLE HBitmap;
  1620. CDC MemDC;
  1621. if(!OpenClipboard())
  1622. return;
  1623. HBitmap=::GetClipboardData(CF_BITMAP);
  1624. if(HBitmap==NULL)
  1625. {
  1626. CloseClipboard();
  1627. return;
  1628. }
  1629. Bitmap.Attach(HBitmap);
  1630. Bitmap.GetObject(sizeof(BITMAP),&BitmapInfo);
  1632. MemDC.CreateCompatibleDC(&ht);
  1633. MemDC.SelectObject(&Bitmap);
  1634. ht.BitBlt(0,0,BitmapInfo.bmWidth,BitmapInfo.bmHeight,&MemDC,0,0,SRCCOPY);
  1635. Bitmap.Detach();
  1636. ::CloseClipboard();
  1637. }
  1639. void CDrawView::OnUpdateEditPaste(CCmdUI* pCmdUI) 
  1640. {
  1642. }
  1644. void CDrawView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
  1645. {
  1646. char p1[6];
  1647. p_View=this;
  1648. CDrawDoc *pDoc=(CDrawDoc *)GetDocument();
  1649. p_Screen=pDoc->m_Screen;
  1650. CMainFrame* p_Wnd=(CMainFrame *)(AfxGetApp()->m_pMainWnd);
  1651. CComboBox* plist=(CComboBox*)(p_Wnd->m_wndDlgBar.GetDlgItem(IDC_COMBO1));
  1652. plist->SetCurSel(m_LineType);
  1653. sprintf(p1,"%d",(int)m_LineWide);
  1654. p_Wnd->m_wndDlgBar.SetDlgItemText(IDC_EDIT1,p1);
  1655. CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
  1656. }
  1658. void CDrawView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo) 
  1659. {
  1660.  if(pInfo==NULL)  //如果是屏幕显示
  1661. return;
  1662. //当前打印页所在的行
  1663. pDC->SetMapMode(m_MapMode);
  1664.  int nRow=pInfo->m_nCurPage/nPageX+(pInfo->m_nCurPage%nPageX);
  1665. //当前打印页所在的列
  1666. int nCol=(pInfo->m_nCurPage-1)%nPageX+1;
  1667. m_xStart=xLeft+(nCol-1)*xPage;  //当前页输出的图形左下角的实际横坐标
  1668. m_yStart=yTop-nRow*yPage;   //当前页输出的图形左下角的实际纵坐标
  1669. pDC->SetWindowOrg(0,0);
  1670. CView::OnPrepareDC(pDC, pInfo);
  1671. }
  1673. void CDrawView::OnPrint(CDC* pDC, CPrintInfo* pInfo) 
  1674. {
  1675. char p1[4];
  1676. CString strHeader=GetDocument()->GetTitle();
  1677. sprintf(p1,"%d",pInfo->m_nCurPage);
  1678. strHeader+=" 第";
  1679. strHeader+=p1;
  1680. strHeader+="页";
  1681. POINT point;
  1682. m_MapMode=pDC->GetMapMode();
  1683. point.x=0;point.y=25;
  1684. pDC->DPtoLP(&point);
  1685. pDC->SetTextAlign(TA_LEFT);
  1686. pDC->TextOut(0,point.y,strHeader);
  1687. TEXTMETRIC textMetric;
  1688. pDC->GetTextMetrics(&textMetric);
  1689. int y;
  1690. if(m_MapMode==1)
  1691. y=point.y+textMetric.tmHeight;
  1692. else
  1693. y=point.y-textMetric.tmHeight;
  1694. pDC->MoveTo(0,y);
  1695. pDC->LineTo(pInfo->m_rectDraw.right,y);
  1696. OnDraw(pDC);
  1697. }
  1699. void CDrawView::DrawBmp1(CDC* pDC,int x,int y,int wide,int high,UINT idCBitmap,int DrawMode)
  1700. {
  1701. int wide1,high1;
  1702. int w_CBitmap,h_CBitmap;
  1703. CBitmap Bitmap;
  1704. BITMAP BM;      //定义一个BITMAP型的结构
  1705. CDC pDC1;       //定义一个绘图设备对象
  1706. //将资源文件中定义的位图资源选入位图对象
  1707. Bitmap.LoadBitmap(idCBitmap);
  1708. Bitmap.GetObject(sizeof(BM),&BM); //得到位图对象的信息
  1709. w_CBitmap=BM.bmWidth;   //得到位图的宽度（像素）    
  1710. h_CBitmap=BM.bmHeight;  //得到位图的高度（像素）    
  1711. if(DrawMode==1) //原样大小显示
  1712. {
  1713. wide1=w_CBitmap;
  1714. high1=h_CBitmap;
  1715. }
  1716. else if(DrawMode==2)//按参数给定的区域显示，纵横伸缩比例一样
  1717. {
  1718. float bl1=(float)wide/w_CBitmap;
  1719. float bl2=(float)high/h_CBitmap;
  1720. if(bl1>bl2)
  1721. {
  1722. high1=high;
  1723. wide1=(int)(bl2*wide);
  1724. }
  1725. else
  1726. {
  1727. wide1=wide;
  1728. high1=(int)(bl1*high);
  1729. }
  1730. }
  1731. else if(DrawMode==3) //严格按参数给定的区域显示
  1732. {
  1733. wide1=wide;
  1734. high1=high;
  1735. }
  1736. //创建一个与绘图设备兼容的内存设备描述对象
  1737. pDC1.CreateCompatibleDC(pDC);
  1738. pDC1.SelectObject(&Bitmap); //将位图选入内存设备描述对象
  1739. //将内存设备描述对象的位图拷贝到屏幕上
  1740. pDC->StretchBlt(x,y,wide1,high1,&pDC1,0,0,w_CBitmap,h_CBitmap,SRCCOPY);
  1741. Bitmap.DeleteObject(); //删除位图对象
  1742. }
  1745. void CDrawView::DrawBmp2(CDC* pDC,int x,int y,int wide,int high,char *fName,int DrawMode)
  1746. {
  1747. char p1[80];
  1748. BITMAPFILEHEADER fileh;  //定义一个文件标题结构
  1749. LPBITMAPINFOHEADER fileh1; //定义一个信息标题结构
  1750. CFile FileBmp;
  1751. CBitmap* pOldMap;
  1752. CDC pDC1;               //定义一个设备描述表
  1753. int i,wide1,high1,maxread;
  1754. short int bytes_per_line;
  1755. unsigned char *BmpChar; 
  1756. long bmpsize;
  1757. maxread=64*512;
  1758. BOOL YN=FileBmp.Open(fName,CFile::typeBinary|CFile::modeRead);
  1759. if(YN==0) //如果文件打开错误,给出出错信息
  1760. {
  1761.     strcpy(p1,"位图文件");
  1762.     strcpy(p1,fName);
  1763.     strcat(p1,"不存在");
  1764.     AfxMessageBox(p1);
  1765. return;
  1766. }
  1767. //以下读入位图的文件标题
  1768. FileBmp.Read((unsigned char *)&fileh,sizeof(fileh));
  1769. if(fileh.bfType!=19778) //判断是否是一个位图文件，19778是"BM"的数值
  1770. {
  1771.         //如果不是一个位图文件，加入提示信息，关闭文件退出
  1772. FileBmp.Close();
  1773. strcpy(p1,"文件");
  1774. strcat(p1,fName);
  1775. strcat(p1,"不是一个位图文件");
  1776. AfxMessageBox(p1);
  1777. return;
  1778. }
  1779. bmpsize=fileh.bfSize-sizeof(BITMAPFILEHEADER);
  1780. bmpdata=GlobalAllocPtr(GHND,bmpsize);
  1781. if(bmpdata==0)
  1782. return;
  1783. BmpChar=new unsigned char[maxread];
  1784. if(BmpChar==NULL)
  1785. {
  1786. GlobalFreePtr(bmpdata);
  1787. return;
  1788. }
  1789. unsigned char *data=(unsigned char *)bmpdata;
  1790. int chunksize;
  1791. while(bmpsize)
  1792. {
  1793. if(bmpsize>maxread)
  1794. chunksize=maxread;
  1795. else
  1796. chunksize=bmpsize;
  1797. FileBmp.Read(BmpChar,chunksize);
  1798. for(i=0;i<chunksize;i++)
  1799. data[i]=BmpChar[i];
  1800. bmpsize-=chunksize;
  1801. data+=chunksize;
  1802. }
  1803. fileh1=(LPBITMAPINFOHEADER)bmpdata;
  1804. bytes_per_line=((long)fileh1->biWidth*(long)fileh1->biBitCount+31L)/32*4;
  1805. if(fileh1->biSize==12)
  1806. return;
  1808. if(fileh1->biClrUsed!=0)
  1809. nPalate=fileh1->biClrUsed;
  1810. else
  1811. {
  1812. switch(fileh1->biBitCount)
  1813. {
  1814. case 1:
  1815. nPalate=2;
  1816. break;
  1817. case 4:
  1818. nPalate=16;
  1819. break;
  1820. case 8:
  1821. nPalate=256;
  1822. break;
  1823. case 24:
  1824. nPalate=0;
  1825. break;
  1826. default:
  1827. nPalate=2;
  1828. break;
  1829. }
  1830. }
  1831. bhm_ddb=0;
  1832. if(fileh1!=NULL)
  1833. {
  1835. if(hpal==0&&nPalate>0)//如果调色板颜色数量大于0
  1836. {
  1837. make_palette();
  1838. }
  1839. if(bhm_ddb==0)
  1840. DIBtoDDB(pDC->GetSafeHdc());
  1841. }
  1843. if(DrawMode==1) //原样大小显示
  1844. {
  1845. wide1=fileh1->biWidth;
  1846. high1=fileh1->biHeight;
  1847. }
  1848. else if(DrawMode==2)//按参数给定的区域显示，纵横伸缩比例一样
  1849. {
  1850. float bl1=(float)wide/fileh1->biWidth;
  1851. float bl2=(float)high/fileh1->biHeight;
  1852. if(bl1>bl2)
  1853. {
  1854. high1=high;
  1855. wide1=(int)(bl2*wide);
  1856. }
  1857. else
  1858. {
  1859. wide1=wide;
  1860. high1=(int)(bl1*high);
  1861. }
  1862. }
  1863. else if(DrawMode==3) //严格按参数给定的区域显示
  1864. {
  1865. wide1=wide;
  1866. high1=high;
  1867. }
  1868. if(bhm_ddb!=0)
  1869. {
  1870. pDC1.CreateCompatibleDC(pDC);
  1871. pOldMap=pDC1.SelectObject(CBitmap::FromHandle(bhm_ddb));
  1872. //将内存设备描述对象中的图像映射到在屏幕中的显示区域
  1873. pDC->StretchBlt(x,y,wide1,high1,&pDC1,0,0,fileh1->biWidth,fileh1->biHeight,SRCCOPY);
  1874. pDC1.SelectObject(pOldMap);
  1875. }
  1876. delete BmpChar;        //释放字符串空间 
  1877. FileBmp.Close();      //关闭文件
  1878. return ;
  1879. }
  1881. void CDrawView::DIBtoDDB(HDC hdc)
  1882. {
  1883. LPBITMAPINFOHEADER p_bminfo=(LPBITMAPINFOHEADER)(bmpdata);
  1884. if(p_bminfo==0)
  1885. return;
  1886. if(bhm_ddb!=0)
  1887. DeleteBitmap(bhm_ddb);
  1889. LPSTR p_image=(LPSTR)p_bminfo+sizeof(BITMAPINFOHEADER)+nPalate*sizeof(RGBQUAD);
  1890. HPALETTE hpalold=NULL;
  1891. if(hpal)
  1892. {
  1893. hpalold=SelectPalette(hdc,hpal,FALSE);
  1894. RealizePalette(hdc);
  1895. }
  1896. bhm_ddb=CreateDIBitmap(hdc,p_bminfo,CBM_INIT,p_image,(LPBITMAPINFO)p_bminfo,DIB_RGB_COLORS);
  1897. if(hpalold)
  1898. SelectPalette(hdc,hpalold,FALSE);
  1899. }
  1901. void CDrawView::make_palette()
  1902. {
  1903. LPBITMAPINFOHEADER p_bminfo=(LPBITMAPINFOHEADER)bmpdata;
  1904. if(hpal!=0)DeletePalette(hpal);
  1905. if(nPalate>0)
  1906. {
  1907. LPLOGPALETTE cp=(LPLOGPALETTE)GlobalAllocPtr(GHND,sizeof(LOGPALETTE)+nPalate*sizeof(PALETTEENTRY));
  1908. if(cp!=NULL)
  1909. {
  1910. cp->palVersion=0x0300;
  1911. cp->palNumEntries=nPalate; //设置调色板入口
  1912. LPBITMAPINFO p_bi=(LPBITMAPINFO)p_bminfo;
  1913. for(int i=0;i<nPalate;i++) //将调色板信息装入RGBQUAD结构，注意颜色的顺序变化
  1914. {
  1915. cp->palPalEntry[i].peRed=p_bi->bmiColors[i].rgbRed;
  1916. cp->palPalEntry[i].peGreen=p_bi->bmiColors[i].rgbGreen;
  1917. cp->palPalEntry[i].peBlue=p_bi->bmiColors[i].rgbBlue;
  1918. }
  1919. hpal=CreatePalette(cp); //创建逻辑调色板
  1920. GlobalFreePtr(cp);
  1921. }
  1922. }
  1923. }
  1925. void CDrawView::DrawBmp3(CDC* pDC,int x,int y,int wide,int high,char *fName,int DrawMode)
  1926. {
  1927. char p1[80];
  1928. CRect r;
  1929. BITMAPFILEHEADER fileh;  //定义一个文件标题结构
  1930. BITMAPINFOHEADER fileh1; //定义一个信息标题结构
  1931. CBitmap Bitmap,*pOldMap;         //定义一个位图对象
  1932. CDC pDC1;               //定义一个设备描述表
  1933. unsigned char *BmpChar; 
  1934. int minx,miny,maxx,maxy,BmpStartX,BmpStartY,BmpEndX,BmpEndY;
  1935. int i,j,xh,i1,j1,c1,c2,c3,nPalate;
  1936. int IsCompress,bicount,bytes_per_line,wide1,high1;
  1937. long filecd,boff,boxmfile1;
  1938. float pbX,pbY;
  1939. CPalette palatte,*pOldPalatte;      //定义一个调色板结构
  1940. LOGPALETTE* cp; //定义一个逻辑调色板结构
  1941. RGBQUAD bmicolors[256]; //
  1942. CFile FileBmp;
  1943. BOOL YN=FileBmp.Open(fName,CFile::typeBinary|CFile::modeRead);
  1944. if(YN==0) //如果文件打开错误,给出出错信息
  1945. {
  1946.     strcpy(p1,"位图文件"); strcpy(p1,fName);
  1947.     strcat(p1,"不存在");
  1948.     AfxMessageBox(p1);
  1949. return;
  1950. }
  1951. //以下读入位图的文件标题
  1952. FileBmp.Read((unsigned char *)&fileh,sizeof(fileh));
  1953. if(fileh.bfType!=19778) //判断是否是一个位图文件，19778是"BM"的数值
  1954. {
  1955. FileBmp.Close();
  1956. strcpy(p1,"文件"); strcat(p1,fName);
  1957. strcat(p1,"不是一个位图文件");
  1958. AfxMessageBox(p1);
  1959. return;
  1960. }
  1961. boff=fileh.bfOffBits; //文件头的长度，文件从开始到实际位图起点的字节偏移量
  1962. filecd=fileh.bfSize; //位图文件的大小
  1963. FileBmp.Read((unsigned char *)&fileh1,sizeof(fileh1));//读入信息标题
  1964. GetClientRect(&r);
  1965. if(DrawMode==1) //原样大小显示
  1966. {
  1967. wide1=fileh1.biWidth;
  1968. high1=fileh1.biHeight;
  1969. }
  1970. else if(DrawMode==2)//按参数给定的区域显示，纵横伸缩比例一样
  1971. {
  1972. float pbX=(float)wide/fileh1.biWidth;
  1973. float pbY=(float)high/fileh1.biHeight;
  1974. if(pbX>pbY)
  1975. {
  1976. high1=high;
  1977. wide1=(int)(pbY*wide);
  1978. }
  1979. else
  1980. {
  1981. wide1=wide;
  1982. high1=(int)(pbX*high);
  1983. }
  1984. }
  1985. else if(DrawMode==3) //严格按参数给定的区域显示
  1986. {
  1987. wide1=wide;
  1988. high1=high;
  1989. }
  1990. bicount=fileh1.biBitCount;       //位图的位面数
  1991. IsCompress=fileh1.biCompression; //是否进行压缩
  1992. filecd=fileh1.biSizeImage;       //图像尺寸大小
  1993. bytes_per_line=((long)fileh1.biWidth*bicount+31L)/32*4;
  1994. if(fileh1.biClrUsed==0) //如果颜色索引数等于0
  1995. {
  1996. if(bicount!=24)     //如果不是24位位图
  1997. nPalate=(int)(pow(2,bicount)); //得到调色板颜色数
  1998. else
  1999. nPalate=0;        //如果是24位位图，调色板颜色数为0
  2000. }
  2001. else //如果颜色索引数不等于0
  2002. {
  2003. if(bicount!=24)
  2004. nPalate=fileh1.biClrUsed;//直接得到调色版数量
  2005. else
  2006. nPalate=0;
  2007. }
  2008. if(nPalate>0)//如果调色板颜色数量大于0
  2009. {
  2010.     for(i=0;i<nPalate;i++) //读入调色板信息
  2011. FileBmp.Read((unsigned char *)&bmicolors[i],sizeof(bmicolors[i]));
  2012. //以下是装入逻辑调色板的工作
  2013. cp=(LOGPALETTE *)malloc(sizeof(LOGPALETTE)+nPalate*sizeof(PALETTEENTRY));
  2014. cp->palNumEntries=nPalate; //设置调色板入口
  2015. cp->palVersion=0x0300;
  2016. for(i=0;i<nPalate;i++) //将调色板信息装入RGBQUAD结构，注意颜色的顺序变化
  2017. {
  2018. cp->palPalEntry[i].peRed=bmicolors[i].rgbRed;
  2019. cp->palPalEntry[i].peGreen=bmicolors[i].rgbGreen;
  2020. cp->palPalEntry[i].peBlue=bmicolors[i].rgbBlue;
  2021. }
  2022. palatte.CreatePalette(cp); //创建逻辑调色板
  2023. pOldPalatte=pDC1.SelectPalette(&palatte,FALSE);
  2024. pDC1.RealizePalette();//从当前的调色板影射入口到系统调色板
  2025. }
  2026. //分配一个用来读入位图一行位图数据的字符串
  2027. BmpChar=new unsigned char[bytes_per_line];
  2028. if(IsCompress!=0)
  2029. {
  2030. //如果位图是采用压缩方式的,我们不进行处理退出
  2031. strcpy(p1,"不处理压缩格式的位图文件");
  2032. AfxMessageBox(p1);
  2033. FileBmp.Close();
  2034. delete BmpChar;
  2035. return ;
  2036. }
  2037. //GetClientRect(&rr);  //得到客户区的矩形边界
  2038. //如果两个图像绘制区域完全不在客户区内。
  2039. if(y+high1<r.top||y>r.bottom||x+wide1<r.left||x>r.right)
  2040.     {
  2041. FileBmp.Close();
  2042. delete BmpChar;
  2043. return ;
  2044. }
  2045. //得到在客户区上实际图像绘制区域的大小
  2046. minx=max(x,r.left);  //右上角横坐标
  2047. maxx=min(x+wide1,r.right);
  2048. miny=max(y,r.top);
  2049. maxy=min(y+high1,r.bottom);//右下角纵坐标
  2050. //以下得到能够显示到屏幕部分的图像在图像文件中的具体位置
  2051. BmpStartX=(int)((float)fileh1.biWidth*(float)(minx-x)/(float)wide1); //每行起点
  2052. BmpEndX=fileh1.biWidth-1-(int)((float)fileh1.biWidth*(float)(x+wide1-maxx)/(float)wide1);//终点
  2053. BmpEndY=fileh1.biHeight-1-(int)(((float)fileh1.biHeight*(y+high1-maxy)/(float)high1));//起始行
  2054. BmpStartY=(int)((float)fileh1.biHeight*(miny-y)/(float)high1); //终止行
  2055. pbX=(float)fileh1.biWidth/wide1; //得到水平方向图像像素与要显示像素的比例
  2056. pbY=(float)fileh1.biHeight/high1; //竖直方向
  2057. if(pbX>1.5)              //如果比例较大
  2058. {
  2059. BmpStartX=minx;        //将屏幕上图像显示区的起点作为起点
  2060. BmpEndX=maxx-1;          //终点作为终点
  2061. }
  2062. if(pbY>1.5)              //如果竖直方向比例较大
  2063. {
  2064. BmpStartY=miny;        //起始行
  2065. BmpEndY=maxy-1;          //结束行
  2066. }
  2067. //建立一个空白位图
  2068. Bitmap.CreateCompatibleBitmap(pDC,BmpEndX-BmpStartX+1,BmpEndY-BmpStartY+1);
  2069. pDC1.CreateCompatibleDC(pDC);//建立一个与当前设备兼容的内存设备描述对象
  2070. pOldMap=pDC1.SelectObject(&Bitmap);  //将空白位图选入内存设备描述对象
  2071. //对所有行进行循环，将图像的实际内容装入空白位图
  2072. for(i=BmpEndY;i>=BmpStartY;i--) 
  2073. {
  2074. if(pbY>1.5) //如果图像纵向压缩比例较大
  2075. i1=(int)(pbY*(i-y)); //得到图像文件中实际起始行
  2076. else  
  2077. i1=i;
  2078. //以下得到实际起始行在文件中的位置，将这一行信息读入BmpChar中
  2079. boxmfile1=boff+(long)bytes_per_line*(fileh1.biHeight-1-i1);
  2080. FileBmp.Seek(boxmfile1,0);
  2081. FileBmp.Read((unsigned char *)BmpChar,bytes_per_line);
  2082. for(j=BmpStartX;j<=BmpEndX;j++) //对一行中所有要显示的像素循环
  2083. {
  2084. if(pbX>1.5) //如果横向压缩较大，得到像素点在一行中的实际位置
  2085. i1=(int)(pbX*(j-x));
  2086. else        //否则，j的位置就是像素点在一行中的实际位置
  2087. i1=j;  
  2088. if(bicount==1) //如果是1位面位图
  2089. {
  2090. //以下得到像素点的实际值，并在内存设备描述对象中写入点
  2091. j1=i1/8;
  2092. xh=*(BmpChar+j1);
  2093. j1=(int)(fmod(j,8));
  2094. j1=(int)(pow(2,7-j1));
  2095. //在内存描述对象中写入点
  2096. if(xh&j1)
  2097. pDC1.SetPixel(j-BmpStartX,i-BmpStartY,RGB(bmicolors[1].rgbRed,
  2098. bmicolors[1].rgbGreen,bmicolors[1].rgbBlue));
  2099. else
  2100. pDC1.SetPixel(j-BmpStartX,i-BmpStartY,RGB(bmicolors[0].rgbRed,
  2101. bmicolors[0].rgbGreen,bmicolors[0].rgbBlue));
  2102. }
  2103. else if(bicount==4)//如果是4位面位图
  2104. {
  2105. //以下得到像素的实际值
  2106. j1=i1/2;
  2107. xh=*(BmpChar+j1);
  2108. if(j1*2!=j)
  2109. j1=xh-xh/16*16;
  2110. else
  2111. j1=xh/16;
  2112. pDC1.SetPixel(j-BmpStartX,i-BmpStartY,RGB(bmicolors[j1].rgbRed,
  2113. bmicolors[j1].rgbGreen,bmicolors[j1].rgbBlue));
  2114. }
  2115.     
  2116. else if(bicount==8) //如果是8位面位图
  2117. {
  2118. j1=*(BmpChar+i1);
  2119. pDC1.SetPixel(j-BmpStartX,i-BmpStartY,RGB(bmicolors[j1].rgbRed,
  2120. bmicolors[j1].rgbGreen,bmicolors[j1].rgbBlue));
  2121. }
  2122. else if(bicount==24)
  2123. {
  2124. c1=*(BmpChar+3*(int)i1);
  2125. c2=*(BmpChar+3*(int)i1+1);
  2126. c3=*(BmpChar+3*(int)i1+2);
  2127. pDC1.SetPixel(j-BmpStartX,i-BmpStartY,RGB(c3,c2,c1));
  2128. }
  2129. }
  2130. }
  2131. //将内存设备描述对象中的图像映射到在屏幕中的显示区域
  2132. pDC->StretchBlt(minx,miny,maxx-minx,maxy-miny,
  2133. &pDC1,0,0,BmpEndX-BmpStartX+1,BmpEndY-BmpStartY+1,SRCCOPY);
  2134. pDC1.SelectObject(pOldMap);
  2135. Bitmap.DeleteObject(); //删除位图
  2136. delete BmpChar; //释放字符串空间 
  2137. FileBmp.Close(); //关闭文件
  2138. if(nPalate>0) //如果调色板颜色数量大于0
  2139. {
  2140. free(cp);
  2141. pDC1.SelectPalette(pOldPalatte,0);
  2142. }
  2143. return ;
  2144. }
  2146. void CDrawView::OnGraphDraw() 
  2147. {
  2148. // TODO: Add your command handler code here
  2149. CClientDC ht(this);
  2150. DrawBmp3(&ht,100,100,300,200,"d:\scan\sharp\cjc1.bmp",1);
  2152. }
  2154. void CDrawView::PutTracker(CDrawCntrItem *pItem,CRectTracker *pTracker)
  2155. {
  2156. int x1,y1,x2,y2;
  2157. DPtoVP(pItem->m_X1,pItem->m_Y1,&x1,&y1);
  2158. DPtoVP(pItem->m_X2,pItem->m_Y2,&x2,&y2);
  2159. pTracker->m_rect.SetRect(x1-5,y2-5,x2+5,y1+5);
  2160. if(pItem==m_pSelection)
  2161. pTracker->m_nStyle|=CRectTracker::resizeInside;
  2162. if(pItem->GetType()==OT_LINK)
  2163. pTracker->m_nStyle|=CRectTracker::dottedLine;
  2164. else
  2165. pTracker->m_nStyle|=CRectTracker::solidLine;
  2166. if(pItem->GetItemState()==COleClientItem::openState||
  2167. pItem->GetItemState()==COleClientItem::activeUIState)
  2168. {
  2169. pTracker->m_nStyle|=CRectTracker::hatchInside;
  2170. }
  2171. }
  2173. void CDrawView::OnLButtonDblClk(UINT nFlags, CPoint point) 
  2174. {
  2175. // TODO: Add your message handler code here and/or call default
  2176. m_DrawCurrent=30;
  2177. OnLButtonDown(nFlags,point);
  2178. if(m_pSelection!=NULL)
  2179. {
  2180. m_pSelection->DoVerb(GetKeyState(VK_CONTROL)<0?OLEIVERB_OPEN:OLEIVERB_PRIMARY,this);
  2181. }
  2182. CView::OnLButtonDblClk(nFlags, point);
  2183. }
  2185. void CDrawView::OnDataSeacher() 
  2186. {
  2187. m_DrawCurrent=31; //标识进行图形连接的查询操作
  2188. PushNumb=0;
  2189. }