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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
WmfModule.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：23k
源码类别：

图形图象

开发平台：

Visual C++

WmfModule.cpp：源码内容
  1. /********************************************************************
  3. WmfModule.cpp - ISee图像浏览器—WMF图像读写模块实现文件
  4.           
  5.     版权所有(C) 2000 VCHelp-coPathway-ISee workgroup member - YZ
  7.     这一程序是自由软件，你可以遵照自由软件基金会出版的GNU 通用公共许
  8. 可证条款来修改和重新发布这一程序。或者用许可证的第二版，或者（根
  9. 据你的选择）用任何更新的版本。
  11.     发布这一程序的目的是希望它有用，但没有任何担保。甚至没有适合特定
  12. 目地的隐含的担保。更详细的情况请参阅GNU通用公共许可证。
  14.     你应该已经和程序一起收到一份GNU通用公共许可证的副本。如果还没有，
  15. 写信给：
  16.     The Free Software Foundation, Inc.,  675  Mass Ave,  Cambridge,
  17.     MA02139,  USA
  19. 如果你在使用本软件时有什么问题或建议，用以下地址可以与我们取得联
  20. 系：
  21. http://isee.126.com
  22. http://www.vchelp.net
  23. 或：
  24. iseesoft@china.com
  26. 编写人：YZ
  27. E-Mail：yzfree@sina.com 或 yzfree@yeah.net
  29. 文件版本：
  30. Beta 1.1
  31. Build 00622
  32. Date  2000-6-22
  34. ********************************************************************/
  37. #include "stdafx.h"
  38. #include "WmfModule.h"
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  47. static char ModuleProcessImgType[]="WMF"; // 本模块能处理的图像类型
  48. static char WriterList[]="YZ"; // 本模块的作者列表
  49. static char WriterMess[]="很高兴能在自由软件开发组作矢量图的工作，这使我学到了不少元文件的知识^_^"; // 作者留言
  52. //
  53. // Note!
  54. //
  55. // If this DLL is dynamically linked against the MFC
  56. // DLLs, any functions exported from this DLL which
  57. // call into MFC must have the AFX_MANAGE_STATE macro
  58. // added at the very beginning of the function.
  59. //
  60. // For example:
  61. //
  62. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  63. // {
  64. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  65. // // normal function body here
  66. // }
  67. //
  68. // It is very important that this macro appear in each
  69. // function, prior to any calls into MFC.  This means that
  70. // it must appear as the first statement within the 
  71. // function, even before any object variable declarations
  72. // as their constructors may generate calls into the MFC
  73. // DLL.
  74. //
  75. // Please see MFC Technical Notes 33 and 58 for additional
  76. // details.
  77. //
  79. /////////////////////////////////////////////////////////////////////////////
  80. // CWmfModuleApp
  82. BEGIN_MESSAGE_MAP(CWmfModuleApp, CWinApp)
  83. //{{AFX_MSG_MAP(CWmfModuleApp)
  84. // NOTE - the ClassWizard will add and remove mapping macros here.
  85. //    DO NOT EDIT what you see in these blocks of generated code!
  86. //}}AFX_MSG_MAP
  87. END_MESSAGE_MAP()
  89. /////////////////////////////////////////////////////////////////////////////
  90. // CWmfModuleApp construction
  92. CWmfModuleApp::CWmfModuleApp()
  93. {
  94. // TODO: add construction code here,
  95. // Place all significant initialization in InitInstance
  96. }
  98. /////////////////////////////////////////////////////////////////////////////
  99. // The one and only CWmfModuleApp object
  101. CWmfModuleApp theApp;
  104. // 接口函数声明 — 第一层，唯一与外界联系的接口
  105. int WINAPI AccessWMFModule(INFOSTR *pInfo)
  106. {
  107. switch(pInfo->comm)
  108. {
  109. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  110. _fnCMD_GETPROCTYPE(pInfo);
  111. break;
  112. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  113. _fnCMD_GETWRITERS(pInfo);
  114. break;
  115. case CMD_GETWRITERMESS: // 获取作者们的留言
  116. _fnCMD_GETWRITERMESS(pInfo);
  117. break;
  118. case CMD_GETBUILDID: // 获取图像模块内部版本号
  119. _fnCMD_GETBUILDID(pInfo);
  120. break;
  121. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  122. _fnCMD_IS_VALID_FILE(pInfo);
  123. break;
  124. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  125. _fnCMD_GET_FILE_INFO(pInfo);
  126. break;
  127. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  128. _fnCMD_LOAD_FROM_FILE(pInfo);
  129. break;
  130. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  131. _fnCMD_SAVE_TO_FILE(pInfo);
  132. break;
  133. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  134. _fnCMD_IS_SUPPORT(pInfo);
  135. break;
  136. case CMD_RESIZE: // 从新获取指定尺寸的图像位数据（只适用于矢量图像）
  137. _fnCMD_RESIZE(pInfo);
  138. break;
  139. default:
  140. pInfo->result = ER_ILLCOMM; // 非法命令
  141. ASSERT(FALSE); // 调用者的程序设计有问题 :-)
  142. break;
  143. }
  145. // 执行命令成功返回1, 失败返回0
  146. return (pInfo->result==ER_SUCCESS)? 1:0;
  147. }
  154. // 命令解释函数 — 第二层解释函数
  155. //********************************************************************//
  157. // 操作命令解释函数---解释：CMD_IS_SUPPORT命令
  158. // 查询某个命令是否被支持
  159. void _fnCMD_IS_SUPPORT(INFOSTR *pInfo)
  160. {
  161. ASSERT(pInfo->result == ER_EMPTY);
  163. switch(pInfo->annexdata.cmAnnData)  
  164. {
  165. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  166. pInfo->result = ER_SUCCESS;
  167. break;
  168. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  169. pInfo->result = ER_SUCCESS;
  170. break;
  171. case CMD_GETWRITERMESS: // 获取作者们的留言
  172. pInfo->result = ER_SUCCESS;
  173. break;
  174. case CMD_GETBUILDID: // 获取图像模块内部版本号
  175. pInfo->result = ER_SUCCESS;
  176. break;
  177. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  178. pInfo->result = ER_SUCCESS;
  179. break;
  180. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  181. pInfo->result = ER_SUCCESS;
  182. break;
  183. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  184. pInfo->result = ER_SUCCESS;
  185. break;
  186. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  187. pInfo->result = ER_NOTSUPPORT;
  188. break;
  189. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  190. pInfo->result = ER_SUCCESS;
  191. break;
  192. case CMD_RESIZE: // 获取指定尺寸的图像（只适用于矢量图像）
  193. pInfo->result = ER_SUCCESS;
  194. break;
  195. default:
  196. pInfo->result = ER_NOTSUPPORT;
  197. break;
  198. }
  199. }
  202. // 操作命令解释函数---解释：CMD_GETPROCTYPE命令
  203. // 获取本模块能处理的图像类型，如：BMP，PCX等等
  204. void _fnCMD_GETPROCTYPE(INFOSTR *pInfo)
  205. {
  206. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  207. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  208. ASSERT(pInfo->result == ER_EMPTY);
  209. // 复制能处理的类型字符串
  210. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)ModuleProcessImgType, 
  211. sizeof(ModuleProcessImgType));
  213. pInfo->result = ER_SUCCESS;
  214. }
  218. // 操作命令解释函数---解释：CMD_GETWRITER命令
  219. // 获取本模块的作者列表，多人时用逗号分隔
  220. void _fnCMD_GETWRITERS(INFOSTR *pInfo)
  221. {
  222. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  223. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  224. ASSERT(pInfo->result == ER_EMPTY);
  225. // 复制开发者名单串
  226. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterList, 
  227. sizeof(WriterList));
  229. pInfo->result = ER_SUCCESS;
  230. }
  233. // 操作命令解释函数---解释：CMD_GETWRITERMESS命令
  234. // 获取作者们的留言
  235. void _fnCMD_GETWRITERMESS(INFOSTR *pInfo)
  236. {
  237. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  238. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  239. ASSERT(pInfo->result == ER_EMPTY);
  240. // 复制开发者们的留言字符串
  241. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterMess, 
  242. sizeof(WriterMess));
  244. pInfo->result = ER_SUCCESS;
  245. }
  249. // 操作命令解释函数---解释：CMD_GETBUILDID命令
  250. // 获取图像模块内部版本号
  251. void _fnCMD_GETBUILDID(INFOSTR *pInfo)
  252. {
  253. // 根据接口定义，此时annexdata.dwAnnData应被设为0，所以下此断言
  254. ASSERT(pInfo->annexdata.dwAnnData == 0);
  255. ASSERT(pInfo->result == ER_EMPTY);
  256. // 填写内部版本号码
  257. pInfo->annexdata.dwAnnData = WMF_MODULE_BUILDID;
  258. pInfo->result = ER_SUCCESS;
  259. }
  263. // 操作命令解释函数---解释：CMD_IS_VALID_FILE命令
  264. // 判断指定文件是否是有效的WMF文件
  265. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  266. {
  267. CFile file;
  268. DWORD dwIsAldus;
  269. DWORD dwSeekPos;
  270. DWORD dwFileSize;
  271. ALDUSMFHEADER aldusMFHeader;
  272. METAHEADER mfHeader;
  274. // 检验入口参数是否符合接口定义
  275. ASSERT(pInfo->result == ER_EMPTY);
  276. ASSERT(pInfo->annexdata.iAnnData == 0);
  277. ASSERT(::strlen(pInfo->filename));
  278. ASSERT(pInfo->state == PKST_NOTVER);
  280. // 先判断指定的文件是否存在
  281. if (!IsFileExist(pInfo->filename))
  282. pInfo->result = ER_COMMINFOERR;
  283. else
  284. {
  285. // 打开指定文件
  286. if (!file.Open(pInfo->filename, CFile::modeRead))
  287. {
  288. pInfo->result = ER_FILERWERR; // 打开文件时出错
  289. return;
  290. }
  292. dwFileSize = file.GetLength();
  293. // 用长度判断
  294. if (dwFileSize < sizeof(METAHEADER))
  295. {
  296. pInfo->result = ER_SUCCESS; // 这不是一个WMF文件
  297. pInfo->annexdata.iAnnData = 0; // WMF文件的长度起码大于
  298. file.Close(); // METAHEADER结构的长度
  299. return;
  300. }
  302. file.Seek(0, CFile::begin);
  304. // 读取文件头的四个字节。（如果是可放置元文件，该DWORD的
  305. // 内容应该是0x9AC6CDD7
  306. if (file.Read(&dwIsAldus, sizeof(DWORD)) != sizeof(DWORD))
  307. {
  308. pInfo->result = ER_FILERWERR; // 读文件时出错
  309. file.Close();
  310. return;
  311. }
  313. if (dwIsAldus == ALDUSKEY) 
  314. {
  315. // 表明该文件是一个可放置元文件
  316. if (dwFileSize < (ALDUSMFHEADERSIZE+sizeof(METAHEADER)))
  317. {
  318. pInfo->result = ER_SUCCESS; // 这可能是一个受损的WMF文件
  319. pInfo->annexdata.iAnnData = 0;
  320. file.Close();
  321. return;
  322. }
  323. // 读去文件头部的结构。
  324. file.Seek(0, CFile::begin);
  326. if (file.Read(&aldusMFHeader, ALDUSMFHEADERSIZE) != ALDUSMFHEADERSIZE)
  327. {
  328. pInfo->result = ER_FILERWERR;
  329. file.Close();
  330. return;
  331. }
  332. dwSeekPos = ALDUSMFHEADERSIZE;
  333. }
  334. else // 老式的Windows元文件
  335. dwSeekPos = 0;
  337. file.Seek(dwSeekPos, CFile::begin);
  338. // 读windows元文件头
  339. if (file.Read(&mfHeader, sizeof(METAHEADER)) != sizeof(METAHEADER))
  340. {
  341. pInfo->result = ER_FILERWERR;
  342. file.Close();
  343. return;
  344. }
  345. // 检查头部标志（0表示是内存元文件，1表示磁盘元文件）
  346. if ((mfHeader.mtType != 0)&&(mfHeader.mtType != 1))
  347. {
  348. pInfo->result = ER_SUCCESS;
  349. pInfo->annexdata.iAnnData = 0; // 这可能是一个受损的WMF文件
  350. file.Close();
  351. return;
  352. }
  353. // 到此，表明该文件是一个有效的WMF文件，iAnnData变量设为1
  354. pInfo->annexdata.iAnnData = 1;
  355. pInfo->state = PKST_PASSVER;
  356. pInfo->result = ER_SUCCESS;
  358. file.Close();
  359. }
  360. }
  365. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  366. // 获取指定文件的信息
  367. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  368. {
  369. CFile file;
  370. DWORD dwIsAldus;
  371. ALDUSMFHEADER aldusMFHeader;
  373. // 检验入口参数是否符合接口定义
  374. ASSERT(pInfo->result == ER_EMPTY);
  375. ASSERT(::strlen(pInfo->filename));
  377. // 此时，该文件必需是一个已存在的、并且是有效的WMF文件
  378. ASSERT(pInfo->state == PKST_PASSVER);
  379. // 客户模块必需要先将imginfo清空为0
  380. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  382. // 打开指定文件
  383. if (!file.Open(pInfo->filename, CFile::modeRead))
  384. {
  385. pInfo->result = ER_FILERWERR;
  386. return;
  387. }
  388. file.Seek(0, CFile::begin);
  390. // 读取文件头的四个字节。（如果是可放置元文件，该DWORD的
  391. // 内容应该是0x9AC6CDD7
  392. if (file.Read(&dwIsAldus, sizeof(DWORD)) != sizeof(DWORD))
  393. {
  394. file.Close();
  395. pInfo->result = ER_FILERWERR;
  396. return;
  397. }
  399. if (dwIsAldus == ALDUSKEY) 
  400. {
  401. // 表明该文件是一个可放置元文件，读文件头部的结构。
  402. file.Seek(0, CFile::begin);
  403. if (file.Read(&aldusMFHeader, ALDUSMFHEADERSIZE) != ALDUSMFHEADERSIZE)
  404. {
  405. file.Close();
  406. pInfo->result = ER_FILERWERR;
  407. return;
  408. }
  409. }
  411. HWND hWnd = ::GetDesktopWindow();
  412. HDC dc = ::GetDC(hWnd);
  414. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  416. // 获取文件的长度、图像的宽度、高度等信息
  417. lpImgInfoStr->imgtype = IMT_VECTORSTATIC;
  418. lpImgInfoStr->imgformat = IMF_WMF;
  419. lpImgInfoStr->filesize = file.GetLength();
  421. // 计算WMF图像的原始尺寸。其中aldusMFHeader.bbox中存放的是文件单位的
  422. // 图像尺寸，而aldusMFHeader.inch中则是一英寸等于多少文件单位的数值。
  423. // 我们先计算出该图像的以英寸为单位的尺寸，然后再除以当前显示器的每
  424. // 英寸多少像素的值（可用GetDeviceCaps()函数取得），就可以得到图像以
  425. // 像素为单位的尺寸了。（挺麻烦的:-）
  426. float fx, fy;
  428. if (dwIsAldus == ALDUSKEY)
  429. {
  430. fx = (float)(aldusMFHeader.bbox.right-aldusMFHeader.bbox.left);
  431. fy = (float)(aldusMFHeader.bbox.bottom-aldusMFHeader.bbox.top);
  432. fx = (fx/(float)aldusMFHeader.inch)*::GetDeviceCaps(dc, LOGPIXELSX)+(float)0.5; // 此处的加上0.5是四舍五入.
  433. fy = (fy/(float)aldusMFHeader.inch)*::GetDeviceCaps(dc, LOGPIXELSY)+(float)0.5;
  434. }
  436. if (dwIsAldus == ALDUSKEY)
  437. lpImgInfoStr->width = (int)fx;
  438. // 如果是可放置的元文件,则宽度等于指定的宽度.
  439. else
  440. lpImgInfoStr->width = ::GetDeviceCaps(dc, HORZRES);
  441. // 如果是老式的Windows元文件,就默认它的宽度为屏幕宽度.因为这种
  442. // 元文件中没有保存图像尺寸的数据.
  444. if (dwIsAldus == ALDUSKEY)
  445. lpImgInfoStr->height = (int)fy;
  446. else
  447. lpImgInfoStr->height = ::GetDeviceCaps(dc, VERTRES);
  449. ::ReleaseDC(hWnd, dc);
  451. // 这是个虚值,没有意义.因为元文件中没有保存颜色数据(不针对增强型元文件).
  452. lpImgInfoStr->bitcount = 24;
  454. lpImgInfoStr->compression = ICS_GDIRECORD;
  456. // 以下这个0值没有意义,该参数只对BMP图像文件有意义.
  457. lpImgInfoStr->linesize = 0;
  459. // 静态WMF文件只有一个图像,所以设为1.
  460. lpImgInfoStr->imgnumbers = 1;
  462. // 可以被编辑，因为它是静态图像。
  463. lpImgInfoStr->imgchang = 0;
  465. // 获取文件最后的修改日期（月在高字节，日在低字节）
  466. CFileStatus status;
  468. file.GetStatus(status);
  469. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  470. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  471. lpImgInfoStr->monday <<= 8;
  472. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  474. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  475. lpImgInfoStr->time = status.m_mtime.GetHour();
  476. lpImgInfoStr->time <<= 8;
  477. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  478. lpImgInfoStr->time <<= 8;
  479. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  480. lpImgInfoStr->time &= 0xffffff;
  482. // 关闭文件
  483. file.Close();
  485. // 设置出口数据
  486. pInfo->state = PKST_PASSINFO;
  487. pInfo->result = ER_SUCCESS;
  488. }
  492. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  493. // 从指定图像文件中读取数据
  494. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  495. {
  496. // 检验入口参数是否符合接口定义
  497. ASSERT(pInfo->result == ER_EMPTY);
  498. ASSERT(::strlen(pInfo->filename));
  499. // 此时，该文件必需是一个已存在的、有效的WMF文件，并且数据包中
  500. // 含有该文件的信息（imginfo结构中）
  501. ASSERT(pInfo->state == PKST_PASSINFO);
  502. ASSERT(pInfo->imginfo.imgformat == IMF_WMF);
  503. ASSERT(pInfo->pImgInfo == NULL);
  504. // 必需设置标准图像格式信息
  505. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  506. ASSERT(pInfo->pLineAddr != NULL);
  507. ASSERT(pInfo->_pbdata != NULL);
  509. HENHMETAFILE hEnhMeta;
  510. BYTE *pby;
  511. HBITMAP bmp, oldbmp;
  512. HWND hWnd = ::GetDesktopWindow();
  513. HDC hDC = ::GetDC(hWnd);
  514. HDC hComDC;
  515. int sizeline;
  517. ASSERT(hWnd);
  519. if (pInfo->fpProgress)
  520. {
  521. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 6))
  522. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  523. ::ReleaseDC(hWnd, hDC);
  524. pInfo->result = ER_USERBREAK;
  525. return;
  526. }
  527. }
  529. if (Read(pInfo, &hEnhMeta))
  530. {
  531. ASSERT(hEnhMeta);
  532. ASSERT(pInfo->sDIBInfo.bmi.biPlanes == 1);
  533. // 可接收三中格式的图像位数据请求：16,24,32。并且要求数据包位
  534. // 数据缓冲区是DIB格式（扫描行以4字节对齐）
  535. ASSERT((pInfo->sDIBInfo.bmi.biBitCount==16)||(pInfo->sDIBInfo.bmi.biBitCount==24)||(pInfo->sDIBInfo.bmi.biBitCount==32));
  536. // 创建用于存放图像位数据的临时缓冲区
  537. bmp = ::CreateDIBSection(hDC, (CONST BITMAPINFO*)&pInfo->sDIBInfo, 
  538. DIB_RGB_COLORS, (VOID**)&pby, NULL, 0);
  539. hComDC = ::CreateCompatibleDC(hDC);
  540. if ((bmp == NULL)||(hComDC == NULL)) // 错误检查
  541. {
  542. ASSERT(pInfo->pImgInfo);
  543. ::GlobalFree(pInfo->pImgInfo);
  544. pInfo->pImgInfo = NULL;
  545. ::DeleteEnhMetaFile(hEnhMeta);
  546. ::ReleaseDC(hWnd, hDC);
  547. if (bmp) ::DeleteObject(bmp);
  548. if (hComDC) ::DeleteDC(hComDC);
  549. pInfo->result = ER_SYSERR;
  550. return;
  551. }
  553. ASSERT(pby); // 此时pby中必然存在bmp位数据缓冲区的地址
  555. oldbmp = (HBITMAP)::SelectObject(hComDC, bmp);
  556. // 设置背景色为缺省窗口色
  557. ::FillRect(hComDC, &CRect(0,0,pInfo->sDIBInfo.bmi.biWidth, pInfo->sDIBInfo.bmi.biHeight), (HBRUSH)(COLOR_WINDOW+1));
  558. // 绘制WMF图像（由Windows元文件格式转为的EMF格式）
  559. ::PlayEnhMetaFile(hComDC, hEnhMeta, CRect(0,0,pInfo->sDIBInfo.bmi.biWidth, pInfo->sDIBInfo.bmi.biHeight));
  560. ::SelectObject(hComDC, oldbmp);
  561. ::DeleteDC(hComDC);
  563. int height = pInfo->sDIBInfo.bmi.biHeight;
  564. ASSERT(height != 0);
  565. // DIB缓冲区中每一扫描行都是4字节对齐的，所以使用了DIBSCANLINE_WIDTHBYTES宏
  566. sizeline = DIBSCANLINE_WIDTHBYTES(pInfo->sDIBInfo.bmi.biWidth*pInfo->sDIBInfo.bmi.biBitCount);
  568. // 复制图像到数据包中
  569. PBYTE lpsou = pby;
  570. ASSERT(pInfo->pLineAddr[0] != NULL); // 如果数据包中的行地址没有填写，就会引发此断言
  571. if (height < 0) // 正向DIB缓冲区(top-down)
  572. {
  573. for (int i=0;i<height;i++)
  574. {
  575. ::CopyMemory((PVOID)pInfo->pLineAddr[i], (CONST VOID *)lpsou, sizeline);
  576. lpsou += sizeline;
  577. }
  578. }
  579. else // 倒向
  580. {
  581. for (int i=0;i<height;i++)
  582. {
  583. ::CopyMemory((PVOID)pInfo->pLineAddr[height-i-1], (CONST VOID *)lpsou, sizeline);
  584. lpsou += sizeline;
  585. }
  586. }
  588. ::DeleteObject(bmp);
  589. ::DeleteEnhMetaFile(hEnhMeta);
  591. // 成功
  592. pInfo->state = PKST_INFOANDBITS;
  593. pInfo->modify = 0;
  594. pInfo->result = ER_SUCCESS;
  595. }
  596. ::ReleaseDC(hWnd, hDC);
  598. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  599. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  600. }
  604. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  605. // 将数据保存到指定文件中
  606. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  607. {
  608. // WMF模块无法支持保存命令。
  609. pInfo->result = ER_NOTSUPPORT;
  610. return;
  611. }
  616. // 操作命令解释函数---解释：CMD_RESIZE命令
  617. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  618. void _fnCMD_RESIZE(INFOSTR *pInfo)
  619. {
  620. // 指定尺寸在pInfo->sDIBInfo.bmi中指定
  621. _fnCMD_LOAD_FROM_FILE(pInfo);
  622. }
  626. /*************************************************************************
  627.  *
  628.  * IsFileExist()
  629.  * 
  630.  * 参数说明：
  631.  *
  632.  * char *lpFileName - 待判断的文件路径和名称（文件名）
  633.  *
  634.  * 返回值：
  635.  *
  636.  * BOOL - 如果指定的文件存在返回TRUE，否则返回FALSE。
  637.  * 
  638.  * 描述：
  639.  *
  640.  * 判断指定的文件是否存在
  641.  * 
  642.  * 该文件必需可以被读和写
  643.  *
  644.  ************************************************************************/
  647. BOOL IsFileExist(char *lpFileName)
  648. {
  649. CFile file;
  650. BOOL bExist = FALSE; // 文件存在是TRUE，不存在是FALSE
  652. // 确定指定的文件是否存在
  653. if (file.Open(lpFileName, CFile::modeReadWrite))
  654. {
  655. bExist = TRUE;
  656. file.Close();
  657. }
  659. return bExist;
  660. }
  664. /*************************************************************************
  665.  *
  666.  * Read()
  667.  * 
  668.  * 参数说明：
  669.  *
  670.  * INFOSTR *pInfo - 图像读写数据包
  671.  * HENHMETAFILE *pHEnhMeta  - 返回的元文件句柄（如果成功的话）
  672.  *
  673.  * 返回值：
  674.  *
  675.  * BOOL - 如果读取成功返回TRUE，否则返回FALSE。
  676.  * 
  677.  * 描述：
  678.  * 如果调用成功，该函数将修改pHEnhMeta指向的值，而且申请一块内存
  679.  * 挂接到pInfo中的pImgInfo上（此内存块由客户程序负责释放）。
  680.  *
  681.  * 读取指定元文件到数据包中
  682.  * 
  683.  ************************************************************************/
  685. BOOL Read(INFOSTR *pInfo, HENHMETAFILE *pHEnhMeta)
  686. {
  687. CFile file;
  688. DWORD    dwIsAldus;
  689. ALDUSMFHEADER m_aldusMFHeader;
  690. METAHEADER mfHeader;
  691.    DWORD     dwSize;
  692. DWORD seekpos;
  694. *pHEnhMeta = NULL;
  696. // 打开指定文件
  697. if (!file.Open(pInfo->filename, CFile::modeRead))
  698. {
  699. pInfo->result = ER_FILERWERR;
  700. return FALSE;
  701. }
  702. file.Seek(0, CFile::begin);
  704. if (file.Read(&dwIsAldus, sizeof(DWORD)) != sizeof(DWORD))
  705. {
  706. file.Close();
  707. pInfo->result = ER_FILERWERR;
  708. return FALSE;
  709. }
  711. if (dwIsAldus != ALDUSKEY) // 旧的Windows元文件.
  712. {
  713. ::ZeroMemory(&m_aldusMFHeader, sizeof(m_aldusMFHeader));
  714. seekpos = 0;
  715. }
  716. else // 可放置型元文件.
  717. {
  718. file.Seek(0, CFile::begin);
  719. // 读去头部的附加结构
  720. if (file.Read(&m_aldusMFHeader, ALDUSMFHEADERSIZE) != ALDUSMFHEADERSIZE)
  721. {
  722. file.Close();
  723. pInfo->result = ER_FILERWERR;
  724. return FALSE;
  725. }
  726. seekpos = ALDUSMFHEADERSIZE;
  727. }
  729. file.Seek(seekpos, CFile::begin);
  730. // 读Windows元文件头.
  731. if (file.Read(&mfHeader, sizeof(mfHeader)) != sizeof(mfHeader))
  732. {
  733. file.Close();
  734. pInfo->result = ER_FILERWERR;
  735. return FALSE;
  736. }
  738. // 为元文件数据分配内存.(mtSize的尺寸值单位是WORD型，所以乘2）
  739. dwSize = mfHeader.mtSize*2;
  741. BYTE* lpMFBits = (BYTE*)::GlobalAlloc(GPTR, dwSize);
  742. if (lpMFBits == NULL)
  743. {
  744. file.Close();
  745. pInfo->result = ER_MEMORYERR; // 内存不足,返回.
  746. return FALSE;
  747. }
  749. // 定位元文件位数据偏移.
  750. file.Seek(seekpos, CFile::begin);
  752. int loop = dwSize/RWBLOCKSIZE; // 读的循环次数
  753. int leavings = dwSize-(loop*RWBLOCKSIZE); // 剩余尺寸
  754. BYTE *lpTmp = lpMFBits;
  756. // 将图像数据读入内存
  757. for (int i=0;i<loop;i++)
  758. {
  759. if (file.Read(lpTmp, RWBLOCKSIZE) != RWBLOCKSIZE)
  760. {
  761. file.Close();
  762. ::GlobalFree(lpMFBits);
  763. pInfo->result = ER_FILERWERR;
  764. return FALSE;
  765. }
  766. if (pInfo->fpProgress)
  767. {
  768. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 10+60/loop*(i+1)))
  769. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  770. file.Close();
  771. ::GlobalFree(lpMFBits);
  772. pInfo->result = ER_USERBREAK;
  773. return FALSE;
  774. }
  775. }
  776. lpTmp += RWBLOCKSIZE;
  777. }
  779. if (file.Read(lpTmp, leavings) != (unsigned int)leavings)
  780. {
  781. file.Close();
  782. ::GlobalFree(lpMFBits);
  783. pInfo->result = ER_FILERWERR;
  784. return FALSE;
  785. }
  786. /* 简化代码
  787. if (file.ReadHuge(lpMFBits, dwSize) != dwSize)
  788. {
  789. file.Close();
  790. delete [] lpMFBits;
  791. pInfo->result = ER_FILERWERR;
  792. return FALSE;
  793. }
  794. */
  796. // 获得元文件句柄
  797. *pHEnhMeta = ::SetWinMetaFileBits(dwSize, lpMFBits, NULL, NULL);
  799. // 此时lpMFBits中的数据已经无用,删除.
  800. ASSERT(lpMFBits);
  801. ::GlobalFree(lpMFBits);
  803. file.Close();
  805. if (!(*pHEnhMeta))
  806. {
  807. pInfo->result = ER_SYSERR;
  808. return FALSE;
  809. }
  811. if (pInfo->fpProgress)
  812. {
  813. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 80))
  814. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  815. ::DeleteEnhMetaFile(*pHEnhMeta);
  816. *pHEnhMeta = NULL;
  817. pInfo->result = ER_USERBREAK;
  818. return FALSE;
  819. }
  820. }
  822. // 分配原始图像信息块
  823. LPWMFADDINFO lpWmfAddInfo;
  824. lpWmfAddInfo = (LPWMFADDINFO)::GlobalAlloc(GPTR, sizeof(WMFADDINFO));
  825. if (!lpWmfAddInfo)
  826. {
  827. ::DeleteEnhMetaFile(*pHEnhMeta);
  828. *pHEnhMeta = NULL;
  829. pInfo->result = ER_MEMORYERR;
  830. return FALSE;
  831. }
  833. HWND hWnd = ::GetDesktopWindow();
  834. HDC dc = ::GetDC(hWnd);
  836. if (dwIsAldus == ALDUSKEY) 
  837. {
  838. // 表明该文件是一个可放置元文件，读文件头部的结构。
  839. lpWmfAddInfo->format = 1; // 等于1表示它是可放置元文件
  840. lpWmfAddInfo->inchto = m_aldusMFHeader.inch; // 文件单位到英寸单位的转换因子
  841. lpWmfAddInfo->x1 = m_aldusMFHeader.bbox.left;
  842. lpWmfAddInfo->y1 = m_aldusMFHeader.bbox.top;
  843. lpWmfAddInfo->x2 = m_aldusMFHeader.bbox.right;
  844. lpWmfAddInfo->y2 = m_aldusMFHeader.bbox.bottom;
  845. lpWmfAddInfo->whgene = (float)(((float)lpWmfAddInfo->x2-lpWmfAddInfo->x1)/((float)lpWmfAddInfo->y2-lpWmfAddInfo->y1));
  846. }
  847. else
  848. {
  849. lpWmfAddInfo->format = 0; // 0表示老的Windows元文件
  850. lpWmfAddInfo->inchto = 0;
  851. lpWmfAddInfo->x1 = 0;
  852. lpWmfAddInfo->y1 = 0;
  853. // 此时x1,x2,y1,y2的单位就不是文件单位了，而是像素单位
  854. lpWmfAddInfo->x2 = ::GetDeviceCaps(dc, HORZRES);
  855. lpWmfAddInfo->y2 = ::GetDeviceCaps(dc, VERTRES);
  856. lpWmfAddInfo->whgene = (float)(((float)lpWmfAddInfo->x2-lpWmfAddInfo->x1)/((float)lpWmfAddInfo->y2-lpWmfAddInfo->y1));
  857. }
  858. // 置原始图像信息，此内存块由客户程序负责释放
  859. pInfo->pImgInfo = (void*)lpWmfAddInfo;
  861. ::ReleaseDC(hWnd, dc);
  863. if (pInfo->fpProgress)
  864. {
  865. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 90))
  866. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  867. ::DeleteEnhMetaFile(*pHEnhMeta);
  868. *pHEnhMeta = NULL;
  869. ::GlobalFree(lpWmfAddInfo);
  870. pInfo->pImgInfo = NULL;
  871. pInfo->result = ER_USERBREAK;
  872. return FALSE;
  873. }
  874. }
  876. return TRUE;
  877. }