CS2，sjz源头作者寻实力代理2名，点我下载免费试用，合作QQ：83934463 招聘-常年数据手+[全职]LUA写手+保底1W+提成 包年位置，投放QQ190959022
无忧ip 无忧sk5 注册送银牌会员，尽享9.5折优惠 手把手一站式项目开发培训，QQ:1026165915 本人在非洲开网吧代练，想招几个投资人在内地做前端，QQ1481857520
收国际服流放2  优化多开  联系QQ：767648458 寻国服火炬之光 冒险岛 内部，联系QQ958522955 全站文字广告位 点击查看报价 投放QQ190959022
发帖 回复
返回列表
  • 14569阅读
  • 9回复

[转载]MFC加载gif动态图片的方法 [复制链接]

 上一主题 下一主题
离线iokey
韶华一笑间
 

发帖
15
金钱
854
威望
759
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看楼主 倒序阅读 楼主   发表于: 2019-06-24
--------------------- Lbo8> L(  
作者：jiangqin115 .'+*>y!  
来源：CSDN @I`X{oAA  
原文：https://blog.csdn.net/jiangqin115/article/details/44241859 +@ '( N  
版权声明：本文为博主原创文章，转载请附上博文链接！ KZK9|121  
---------------------------------------------------------------------------------------- ve#*qz Y  
=e<;B_ ~.  
在一个项目中需要加入GIF动画。一个版本时通过IE浏览器显示网页的形式，js脚本、CSS他人编写较繁琐；另一个VC项目需要使用MFC直接加载GIF动画。加载GIF动画网上有多种方式，大多数是将GIF填进资源，使用PictureEx类load资源文件  如下： _3G;-iNX;  
PictureEx图片显示类支持以下格式的图片：GIF (including animated GIF87a and GIF89a), JPEG, BMP, WMF, ICO, CUR等，我特别推崇的是能够做出动画，而且轻而易举，确实很COOL。 fa~u<m   
下面是周详的编程过程： 3 M/iuu  
>o\s'i[  
1. 新建项目：在VC6中用MFC新建一个基于对话框的GifDemo应用程式，接受任何缺省选项即可； =x8F!W}Bt<  
IYJS>G%*  
2.在项目中插入文档：把PictureEx.h，PictureEx.cpp文档copy 到项目文档夹下，Project-＞Add to Project-＞Files中选上PictureEx.h，PictureEx.cpp， Insert; In%K  
3.加入图片控件：从对话框控件中把Picture Control（图片控件)拖入主对话框中，修改其属性：ID：IDC_GIF，TYPE：Rectangle，其余接受缺省选项。再在ClassWiard中为IDF_GIF加入CSatic控制变量m_GifPic, 8UA bTqB-  
注意看一下，GifDemoDlg.h中是否加上了#include "PictureEx.h"（由ClassWiard加入）。然后将CSatic m_GifPic;更改成CPictureEx m_GifPic; (6Ss k4  
%j '_I\  
4.加载动画文档：先将要加载的动画文档放到 res 资源文档夹下，再将其Import进项目中，由于MFC只支持256BMP文档的图片，因此，我们要新建一个图片类型："GIF",我在这里将我网站的宣传图片roaring.gif放进去 ，并将其ID修改成：IDR_GIFROARING。 vkQ81PEt  
yS*s[vT  
import(导入）gif动画的周详过程：  p^=>N9  
在resourceview窗口中，单击鼠标右键，在出现的环境菜单中选择“import...”命令，会出现“import resource”选择文档对话框，文档类型选择“任何文档（*.*）”，open as 选项为"auto",再选择动画文档所在目录，选上要载入的动画文档 roaring.gif,再单击 import,由于gif动画类型不是vc默认的文档类型，这时会出现"custom resource type"对话框，键入“"gif"”，再单击ok，然后再修改其id。 n9qO;X4&  
5.在程式的适当位置添入加载代码： 这里，我们在CGifDemoDlg::OnInitDialog()函数中加入如下代码： #Kr\"o1]  
// TODO: Add extra initialization here cy0 %tsB|  
if (m_GifPic.Load(MAKEINTRESOURCE(IDR_GIFROARING),_T("Gif"))) m_GifPic.Draw(); q?Jd.r5*  
但是由于我们的软件要写入硬件设备中，对文件大小有严格要求，几个软件间共用同一个GIF，必须采用动态调用GIF文件加载进MFC中。查看PictureEx类，会发现类中有多个load函数，其中一个可以Load文件名，但是调用过程不是简单的Load，在Draw的样子显示GIF动画。试验多次后来发现需要在Load文件之前 Static::Create一下。 源码如下： }8+rrzMUB  
m_GifPic.Create(NULL,WS_CHILD | WS_VISIBLE |SS_ENHMETAFILE,CRect(50,50,100,100),this,1234); ,d^ze=  
m_GifPic.Load(_T("c://1.gif")); o_!=-AWV  
m_GifPic.Draw();// OK  使用PictureEx动态加载GIF文件完成 l?_h(Cq<  
'/Y D$*,  
PictureEx.h代码如下： V !Cu%4  
复制代码
  1. #if !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)
  2. #define AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_
  4. #if _MSC_VER > 1000
  5. #pragma once
  6. #endif // _MSC_VER > 1000
  8. #include <vector>
  10. //#define GIF_TRACING  // uncomment it if you want detailed TRACEs
  12. class CPictureEx : public CStatic
  13. {
  14. public:
  16. struct TFrame    // structure that keeps a single frame info
  17. {
  18. IPicture *m_pPicture;  // pointer to the interface used for drawing
  19. SIZE     m_frameSize;
  20. SIZE     m_frameOffset;
  21. UINT     m_nDelay;     // delay (in 1/100s of a second)
  22. UINT     m_nDisposal;  // disposal method
  23. };
  25. #pragma pack(1)   // turn byte alignment on
  27. enum GIFBlockTypes
  28. {
  29. BLOCK_UNKNOWN,
  30. BLOCK_APPEXT,
  31. BLOCK_COMMEXT,
  32. BLOCK_CONTROLEXT,
  33. BLOCK_PLAINTEXT,
  34. BLOCK_IMAGE,
  35. BLOCK_TRAILER
  36. };
  38. enum ControlExtValues // graphic control extension packed field values
  39. {
  40. GCX_PACKED_DISPOSAL,  // disposal method
  41. GCX_PACKED_USERINPUT,
  42. GCX_PACKED_TRANSPCOLOR
  43. };
  45. enum LSDPackedValues  // logical screen descriptor packed field values
  46. {
  47. LSD_PACKED_GLOBALCT,
  48. LSD_PACKED_CRESOLUTION,
  49. LSD_PACKED_SORT,
  50. LSD_PACKED_GLOBALCTSIZE
  51. };
  53. enum IDPackedValues   // image descriptor packed field values
  54. {
  55. ID_PACKED_LOCALCT,
  56. ID_PACKED_INTERLACE,
  57. ID_PACKED_SORT,
  58. ID_PACKED_LOCALCTSIZE
  59. };
  61. struct TGIFHeader       // GIF header  
  62. {
  63. char m_cSignature[3]; // Signature - Identifies the GIF Data Stream
  64.         // This field contains the fixed value 'GIF'
  65. char m_cVersion[3]; // Version number. May be one of the following:
  66.       // "87a" or "89a"
  67. };
  69. struct TGIFLSDescriptor // Logical Screen Descriptor
  70. {
  71. WORD m_wWidth; // 2 bytes. Logical screen width
  72. WORD m_wHeight; // 2 bytes. Logical screen height
  74. unsigned char m_cPacked;      // packed field
  76. unsigned char m_cBkIndex;     // 1 byte. Background color index
  77. unsigned char m_cPixelAspect; // 1 byte. Pixel aspect ratio
  78. inline int GetPackedValue(enum LSDPackedValues Value);
  79. };
  81. struct TGIFAppExtension // application extension block
  82. {
  83. unsigned char m_cExtIntroducer; // extension introducer (0x21)
  84. unsigned char m_cExtLabel; // app. extension label (0xFF)
  85. unsigned char m_cBlockSize; // fixed value of 11
  86. char m_cAppIdentifier[8];   // application identifier
  87. char m_cAppAuth[3];  // application authentication code
  88. };
  90. struct TGIFControlExt // graphic control extension block
  91. {
  92. unsigned char m_cExtIntroducer; // extension introducer (0x21)
  93. unsigned char m_cControlLabel;  // control extension label (0xF9)
  94. unsigned char m_cBlockSize; // fixed value of 4
  95. unsigned char m_cPacked;    // packed field
  96. WORD m_wDelayTime; // delay time
  97. unsigned char m_cTColorIndex; // transparent color index
  98. unsigned char m_cBlockTerm;   // block terminator (0x00)
  99. public:
  100. inline int GetPackedValue(enum ControlExtValues Value);
  101. };
  103. struct TGIFCommentExt  // comment extension block
  104. {
  105. unsigned char m_cExtIntroducer; // extension introducer (0x21)
  106. unsigned char m_cCommentLabel;  // comment extension label (0xFE)
  107. };
  109. struct TGIFPlainTextExt // plain text extension block
  110. {
  111. unsigned char m_cExtIntroducer;  // extension introducer (0x21)
  112. unsigned char m_cPlainTextLabel; // text extension label (0x01)
  113. unsigned char m_cBlockSize; // fixed value of 12
  114. WORD m_wLeftPos;    // text grid left position
  115. WORD m_wTopPos;     // text grid top position
  116. WORD m_wGridWidth;  // text grid width
  117. WORD m_wGridHeight; // text grid height
  118. unsigned char m_cCellWidth;  // character cell width
  119. unsigned char m_cCellHeight; // character cell height
  120. unsigned char m_cFgColor; // text foreground color index
  121. unsigned char m_cBkColor; // text background color index
  122. };
  124. struct TGIFImageDescriptor // image descriptor block
  125. {
  126. unsigned char m_cImageSeparator; // image separator byte (0x2C)
  127. WORD m_wLeftPos; // image left position
  128. WORD m_wTopPos;  // image top position
  129. WORD m_wWidth;   // image width
  130. WORD m_wHeight;  // image height
  131. unsigned char m_cPacked; // packed field
  132. inline int GetPackedValue(enum IDPackedValues Value);
  133. };
  135. #pragma pack() // turn byte alignment off
  137. public:
  138. BOOL GetPaintRect(RECT *lpRect);
  139. BOOL SetPaintRect(const RECT *lpRect);
  140. CPictureEx();
  141. virtual ~CPictureEx();
  142. void Stop();   // stops animation
  143. void UnLoad(); // stops animation plus releases all resources
  145. BOOL IsGIF() const;
  146. BOOL IsPlaying() const;
  147. BOOL IsAnimatedGIF() const;
  148. SIZE GetSize() const;
  149. int GetFrameCount() const;
  150. COLORREF GetBkColor() const;
  151. void SetBkColor(COLORREF clr);
  153. // draws the picture (starts an animation thread if needed)
  154. // if an animation was previously stopped by Stop(),
  155. // continues it from the last displayed frame
  156. BOOL Draw();
  158. // loads a picture from a file
  159. // i.e. Load(_T("mypic.gif"));
  160. BOOL Load(LPCTSTR szFileName);
  162. // loads a picture from a global memory block (allocated by GlobalAlloc)
  163. // Warning: this function DOES NOT free the global memory, pointed to by hGlobal
  164. BOOL Load(HGLOBAL hGlobal, DWORD dwSize);
  166. // loads a picture from a program resource
  167. // i.e. Load(MAKEINTRESOURCE(IDR_MYPIC),_T("GIFTYPE"));
  168. BOOL Load(LPCTSTR szResourceName,LPCTSTR szResourceType);
  170. protected:
  172. #ifdef GIF_TRACING
  173. void EnumGIFBlocks();
  174. void WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize);
  175. #endif // GIF_TRACING
  177. RECT m_PaintRect;
  178. SIZE m_PictureSize;
  179. COLORREF m_clrBackground;
  180. UINT m_nCurrFrame;
  181. UINT m_nDataSize;
  182. UINT m_nCurrOffset;
  183. UINT m_nGlobalCTSize;
  184. BOOL m_bIsGIF;
  185. BOOL m_bIsPlaying;
  186. volatile BOOL m_bExitThread;
  187. BOOL m_bIsInitialized;
  188. HDC m_hMemDC;
  190. HDC m_hDispMemDC;
  191. HBITMAP m_hDispMemBM;
  192. HBITMAP m_hDispOldBM;
  194. HBITMAP m_hBitmap;
  195. HBITMAP m_hOldBitmap;
  196. HANDLE m_hThread;
  197. HANDLE m_hExitEvent;
  198. IPicture * m_pPicture;
  199. TGIFHeader * m_pGIFHeader;
  200. unsigned char * m_pRawData;
  201. TGIFLSDescriptor * m_pGIFLSDescriptor;
  202. std::vector<TFrame> m_arrFrames;
  204. void ThreadAnimation();
  205. static UINT WINAPI _ThreadAnimation(LPVOID pParam);
  207. int GetNextBlockLen() const;
  208. BOOL SkipNextBlock();
  209. BOOL SkipNextGraphicBlock();
  210. BOOL PrepareDC(int nWidth, int nHeight);
  211. void ResetDataPointer();
  212. enum GIFBlockTypes GetNextBlock() const;
  213. UINT GetSubBlocksLen(UINT nStartingOffset) const;
  214. HGLOBAL GetNextGraphicBlock(UINT *pBlockLen, UINT *pDelay,
  215.   SIZE *pBlockSize, SIZE *pBlockOffset, UINT *pDisposal);
  217. // Generated message map functions
  218. //{{AFX_MSG(CPictureEx)
  219. afx_msg void OnDestroy();
  220. afx_msg void OnPaint();
  221. //}}AFX_MSG
  223. DECLARE_MESSAGE_MAP()
  224. };
  226. #endif // !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)
urJ>dw?FI  
7N@4c   
PictureEx.cpp代码如下: $6&P 69<  
复制代码
  1. #include "stdafx.h"
  2. #include "PictureEx.h"
  3. #include <process.h>
  5. #ifdef _DEBUG
  6. #undef THIS_FILE
  7. static char THIS_FILE[]=__FILE__;
  8. #define new DEBUG_NEW
  9. #endif
  11. //////////////////////////////////////////////////////////////////////
  12. // Nested structures member functions
  13. //////////////////////////////////////////////////////////////////////
  15. inline int CPictureEx::TGIFControlExt::GetPackedValue(enum ControlExtValues Value)
  16. {
  17. int nRet = (int)m_cPacked;
  18. switch (Value)
  19. {
  20. case GCX_PACKED_DISPOSAL:
  21.   nRet = (nRet & 28) >> 2;
  22.   break;
  24. case GCX_PACKED_USERINPUT:
  25.   nRet = (nRet & 2) >> 1;
  26.   break;
  28. case GCX_PACKED_TRANSPCOLOR:
  29.   nRet &= 1;
  30.   break;
  31. };
  33. return nRet;
  34. }
  36. inline int CPictureEx::TGIFLSDescriptor::GetPackedValue(enum LSDPackedValues Value)
  37. {
  38. int nRet = (int)m_cPacked;
  40. switch (Value)
  41. {
  42. case LSD_PACKED_GLOBALCT:
  43.   nRet = nRet >> 7;
  44.   break;
  46. case LSD_PACKED_CRESOLUTION:
  47.   nRet = ((nRet & 0x70) >> 4) + 1;
  48.   break;
  50. case LSD_PACKED_SORT:
  51.   nRet = (nRet & 8) >> 3;
  52.   break;
  54. case LSD_PACKED_GLOBALCTSIZE:
  55.   nRet &= 7;
  56.   break;
  57. };
  59. return nRet;
  60. }
  62. inline int CPictureEx::TGIFImageDescriptor::GetPackedValue(enum IDPackedValues Value)
  63. {
  64. int nRet = (int)m_cPacked;
  66. switch (Value)
  67. {
  68. case ID_PACKED_LOCALCT:
  69.   nRet >>= 7;
  70.   break;
  72. case ID_PACKED_INTERLACE:
  73.   nRet = ((nRet & 0x40) >> 6);
  74.   break;
  76. case ID_PACKED_SORT:
  77.   nRet = (nRet & 0x20) >> 5;
  78.   break;
  80. case ID_PACKED_LOCALCTSIZE:
  81.   nRet &= 7;
  82.   break;
  83. };
  85. return nRet;
  86. }
  89. //////////////////////////////////////////////////////////////////////
  90. // Construction/Destruction
  91. //////////////////////////////////////////////////////////////////////
  93. CPictureEx::CPictureEx()
  94. {
  95. // check structures size
  96. ASSERT(sizeof(TGIFImageDescriptor) == 10);
  97. ASSERT(sizeof(TGIFAppExtension)    == 14);
  98. ASSERT(sizeof(TGIFPlainTextExt)    == 15);
  99. ASSERT(sizeof(TGIFLSDescriptor)    ==  7);
  100. ASSERT(sizeof(TGIFControlExt)    ==  8);
  101. ASSERT(sizeof(TGIFCommentExt)    ==  2);
  102. ASSERT(sizeof(TGIFHeader)     ==  6);
  104. m_pGIFLSDescriptor = NULL;
  105. m_pGIFHeader    = NULL;
  106. m_pPicture     = NULL;
  107. m_pRawData     = NULL;
  108. m_hThread     = NULL;
  109. m_hBitmap          = NULL;
  110. m_hMemDC     = NULL;
  112. m_hDispMemDC       = NULL;
  113. m_hDispMemBM       = NULL;
  114. m_hDispOldBM       = NULL;
  116. m_bIsInitialized   = FALSE;
  117. m_bExitThread    = FALSE;
  118. m_bIsPlaying       = FALSE;
  119. m_bIsGIF     = FALSE;
  120. m_clrBackground    = RGB(255,255,255); // white by default
  121. m_nGlobalCTSize    = 0;
  122. m_nCurrOffset    = 0;
  123. m_nCurrFrame    = 0;
  124. m_nDataSize     = 0;
  125. m_PictureSize.cx = m_PictureSize.cy = 0;
  126. SetRect(&m_PaintRect,0,0,0,0);
  128. m_hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  129. }
  131. CPictureEx::~CPictureEx()
  132. {
  133. UnLoad();
  134. CloseHandle(m_hExitEvent);
  135. }
  137. BEGIN_MESSAGE_MAP(CPictureEx, CStatic)
  138. //{{AFX_MSG_MAP(CPictureEx)
  139. ON_WM_DESTROY()
  140. ON_WM_PAINT()
  141. //}}AFX_MSG_MAP
  142. END_MESSAGE_MAP()
  144. BOOL CPictureEx::Load(HGLOBAL hGlobal, DWORD dwSize)
  145. {
  146. IStream *pStream = NULL;
  147. UnLoad();
  149. if (!(m_pRawData = reinterpret_cast<unsigned char*> (GlobalLock(hGlobal))) )
  150. {
  151.   TRACE(_T("Load: Error locking memory\n"));
  152.   return FALSE;
  153. };
  155. m_nDataSize = dwSize;
  156. m_pGIFHeader = reinterpret_cast<TGIFHeader *> (m_pRawData);
  158. if ((memcmp(&m_pGIFHeader->m_cSignature,"GIF",3) != 0) &&
  159.   ((memcmp(&m_pGIFHeader->m_cVersion,"87a",3) != 0) ||
  160.    (memcmp(&m_pGIFHeader->m_cVersion,"89a",3) != 0)) )
  161. {
  162. // it's neither GIF87a nor GIF89a
  163. // do the default processing
  165.   // clear GIF variables
  166.   m_pRawData = NULL;
  167.   GlobalUnlock(hGlobal);
  169.   // don't delete memory on object's release
  170.   if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  171.    return FALSE;
  173.   if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  174.    reinterpret_cast<LPVOID *>(&m_pPicture)) != S_OK)
  175.   {
  176.    pStream->Release();
  177.    return FALSE;
  178.   };
  179.   pStream->Release();
  181.   // store picture's size
  183.   long hmWidth;
  184.   long hmHeight;
  185.   m_pPicture->get_Width(&hmWidth);
  186.   m_pPicture->get_Height(&hmHeight);
  188.   HDC hDC = ::GetDC(m_hWnd);
  189.   m_PictureSize.cx = MulDiv(hmWidth, GetDeviceCaps(hDC,LOGPIXELSX), 2540);
  190.   m_PictureSize.cy = MulDiv(hmHeight, GetDeviceCaps(hDC,LOGPIXELSY), 2540);
  191.   ::ReleaseDC(m_hWnd,hDC);
  192. }
  193. else
  194. {
  195.   // it's a GIF
  196.   m_bIsGIF = TRUE;
  197.   m_pGIFLSDescriptor = reinterpret_cast<TGIFLSDescriptor *>
  198.    (m_pRawData + sizeof(TGIFHeader));
  199.   if (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT) == 1)
  200.   {
  201.    // calculate the globat color table size
  202.    m_nGlobalCTSize = static_cast<int>
  203.     (3* (1 << (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE)+1)));
  204.    // get the background color if GCT is present
  205.    unsigned char *pBkClr = m_pRawData + sizeof(TGIFHeader) +
  206.     sizeof(TGIFLSDescriptor) + 3*m_pGIFLSDescriptor->m_cBkIndex;
  207.    m_clrBackground = RGB(pBkClr[0],pBkClr[1],pBkClr[2]);
  208.   };
  210.   // store the picture's size
  211.   m_PictureSize.cx = m_pGIFLSDescriptor->m_wWidth;
  212.   m_PictureSize.cy = m_pGIFLSDescriptor->m_wHeight;
  214.   // determine frame count for this picture
  215.   UINT nFrameCount=0;
  216.   ResetDataPointer();
  217.   while (SkipNextGraphicBlock())
  218.    nFrameCount++;
  220. #ifdef GIF_TRACING
  221.   TRACE(
  222.    _T(" -= GIF encountered\n"
  223.       "Logical Screen dimensions = %dx%d\n"
  224.       "Global color table = %d\n"
  225.       "Color depth = %d\n"
  226.       "Sort flag = %d\n"
  227.       "Size of Global Color Table = %d\n"
  228.       "Background color index = %d\n"
  229.       "Pixel aspect ratio = %d\n"
  230.       "Frame count = %d\n"
  231.       "Background color = %06Xh\n\n"
  232.      ),
  233.    m_pGIFLSDescriptor->m_wWidth,
  234.    m_pGIFLSDescriptor->m_wHeight,
  235.    m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT),
  236.    m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_CRESOLUTION),
  237.    m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_SORT),
  238.    m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE),
  239.    m_pGIFLSDescriptor->m_cBkIndex,
  240.    m_pGIFLSDescriptor->m_cPixelAspect,
  241.    nFrameCount,
  242.    m_clrBackground
  243.    );
  244.   EnumGIFBlocks();
  245. #endif
  247.   if (nFrameCount == 0) // it's an empty GIF!
  248.   {
  249.    m_pRawData = NULL;
  250.    GlobalUnlock(hGlobal);
  251.    return FALSE;
  252.   };
  254.   // now check the frame count
  255.   // if there's only one frame, no need to animate this GIF
  256.   // therefore, treat it like any other pic
  258.   if (nFrameCount == 1)
  259.   {
  260.    // clear GIF variables
  261.    m_pRawData = NULL;
  262.    GlobalUnlock(hGlobal);
  264.    // don't delete memory on object's release
  265.    if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  266.     return FALSE;
  268.    if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  269.     (LPVOID *)&m_pPicture) != S_OK)
  270.    {
  271.     pStream->Release();
  272.     return FALSE;
  273.    };
  275.    pStream->Release();
  276.   }
  277.   else
  278.   {
  279.   // if, on the contrary, there are several frames
  280.   // then store separate frames in an array
  282.    TFrame frame;
  283.    UINT nBlockLen;
  284.    HGLOBAL hFrameData;
  285.    UINT nCurFrame = 0;
  287.    ResetDataPointer();
  288.    while (hFrameData = GetNextGraphicBlock(&nBlockLen,
  289.     &frame.m_nDelay, &frame.m_frameSize,
  290.     &frame.m_frameOffset, &frame.m_nDisposal) )
  291.    {
  292.     #ifdef GIF_TRACING
  293.     //////////////////////////////////////////////
  294.     // uncomment the following strings if you want
  295.     // to write separate frames on disk
  296.     //
  297.     // CString szName;
  298.     // szName.Format(_T("%.4d.gif"),nCurFrame);
  299.     // WriteDataOnDisk(szName,hFrameData,nBlockLen);
  300.     // nCurFrame++;
  301.     #endif // GIF_TRACING
  303.     IStream *pStream = NULL;
  305.     // delete memory on object's release
  306.     if (CreateStreamOnHGlobal(hFrameData,TRUE,&pStream) != S_OK)
  307.     {
  308.      GlobalFree(hFrameData);
  309.      continue;
  310.     };
  312.     if (OleLoadPicture(pStream,nBlockLen,FALSE,
  313.      IID_IPicture,
  314.      reinterpret_cast<LPVOID *>(&frame.m_pPicture)) != S_OK)
  315.     {
  316.      pStream->Release();
  317.      continue;
  318.     };
  319.     pStream->Release();
  320.   
  321.     // everything went well, add this frame
  322.     m_arrFrames.push_back(frame);
  323.    };
  325.    // clean after ourselves
  326.    m_pRawData = NULL;
  327.    GlobalUnlock(hGlobal);
  329.    if (m_arrFrames.empty()) // couldn't load any frames
  330.     return FALSE;
  331.   };
  332. }; // if (!IsGIF...
  334. return PrepareDC(m_PictureSize.cx,m_PictureSize.cy);
  335. }
  337. void CPictureEx::UnLoad()
  338. {
  339. Stop();
  340. if (m_pPicture)
  341. {
  342.   m_pPicture->Release();
  343.   m_pPicture = NULL;
  344. };
  346. std::vector<TFrame>::iterator it;
  347. for (it=m_arrFrames.begin();it<m_arrFrames.end();it++)
  348.   (*it).m_pPicture->Release();
  349. m_arrFrames.clear();
  351. if (m_hMemDC)
  352. {
  353.   SelectObject(m_hMemDC,m_hOldBitmap);
  354.   ::DeleteDC(m_hMemDC);
  355.   ::DeleteObject(m_hBitmap);
  356.   m_hMemDC  = NULL;
  357.   m_hBitmap = NULL;
  358. };
  360. if (m_hDispMemDC)
  361. {
  362.   SelectObject(m_hDispMemDC,m_hDispOldBM);
  363.   ::DeleteDC(m_hDispMemDC);
  364.   ::DeleteObject(m_hDispMemBM);
  365.   m_hDispMemDC  = NULL;
  366.   m_hDispMemBM = NULL;
  367. };
  369. SetRect(&m_PaintRect,0,0,0,0);
  370. m_pGIFLSDescriptor = NULL;
  371. m_pGIFHeader    = NULL;
  372. m_pRawData     = NULL;
  373. m_hThread     = NULL;
  374. m_bIsInitialized   = FALSE;
  375. m_bExitThread    = FALSE;
  376. m_bIsGIF     = FALSE;
  377. m_clrBackground    = RGB(255,255,255); // white by default
  378. m_nGlobalCTSize    = 0;
  379. m_nCurrOffset    = 0;
  380. m_nCurrFrame    = 0;
  381. m_nDataSize     = 0;
  382. }
  384. BOOL CPictureEx::Draw()
  385. {
  386. if (!m_bIsInitialized)
  387. {
  388.   TRACE(_T("Call one of the CPictureEx::Load() member functions before calling Draw()\n"));
  389.   return FALSE;
  390. };
  392. if (IsAnimatedGIF())
  393. {
  394. // the picture needs animation
  395. // we'll start the thread that will handle it for us
  397.   unsigned int nDummy;
  398.   m_hThread = (HANDLE) _beginthreadex(NULL,0,_ThreadAnimation,this,
  399.    CREATE_SUSPENDED,&nDummy);
  400.   if (!m_hThread)
  401.   {
  402.    TRACE(_T("Draw: Couldn't start a GIF animation thread\n"));
  403.    return FALSE;
  404.   }
  405.   else
  406.    ResumeThread(m_hThread);
  407. }
  408. else
  409. {
  410.   if (m_pPicture)
  411.   {
  412.    long hmWidth;
  413.    long hmHeight;
  414.    m_pPicture->get_Width(&hmWidth);
  415.    m_pPicture->get_Height(&hmHeight);
  416.    if (m_pPicture->Render(m_hMemDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy,
  417.     0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  418.    {
  419.     Invalidate(FALSE);
  420.     return TRUE;
  421.    };
  422.   };
  423. };
  425. return FALSE;
  426. }
  428. SIZE CPictureEx::GetSize() const
  429. {
  430. return m_PictureSize;
  431. }
  433. BOOL CPictureEx::Load(LPCTSTR szFileName)
  434. {
  435. ASSERT(szFileName);
  437. CFile file;
  438. HGLOBAL hGlobal;
  439. DWORD dwSize;
  441. if (!file.Open(szFileName,
  442.     CFile::modeRead |
  443.     CFile::shareDenyWrite) )
  444. {
  445.   TRACE(_T("Load (file): Error opening file %s\n"),szFileName);
  446.   return FALSE;
  447. };
  449. dwSize = file.GetLength();
  450. hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  451. if (!hGlobal)
  452. {
  453.   TRACE(_T("Load (file): Error allocating memory\n"));
  454.   return FALSE;
  455. };
  457. char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal));
  458. if (!pData)
  459. {
  460.   TRACE(_T("Load (file): Error locking memory\n"));
  461.   GlobalFree(hGlobal);
  462.   return FALSE;
  463. };
  465. TRY
  466. {
  467.   file.Read(pData,dwSize);
  468. }
  469. CATCH(CFileException, e);                                          
  470. {
  471.   TRACE(_T("Load (file): An exception occured while reading the file %s\n"),
  472.    szFileName);
  473.   GlobalFree(hGlobal);
  474.   e->Delete();
  475.   file.Close();
  476.   return FALSE;
  477. }
  478. END_CATCH
  479. GlobalUnlock(hGlobal);
  480. file.Close();
  482. BOOL bRetValue = Load(hGlobal,dwSize);
  483. GlobalFree(hGlobal);
  484. return bRetValue;
  485. }
  487. BOOL CPictureEx::Load(LPCTSTR szResourceName, LPCTSTR szResourceType)
  488. {
  489. ASSERT(szResourceName);
  490. ASSERT(szResourceType);
  492. HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,szResourceType);
  493. HGLOBAL hResData;
  494. if (!hPicture || !(hResData = LoadResource(AfxGetResourceHandle(),hPicture)))
  495. {
  496.   TRACE(_T("Load (resource): Error loading resource %s\n"),szResourceName);
  497.   return FALSE;
  498. };
  499. DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);
  501. // hResData is not the real HGLOBAL (we can't lock it)
  502. // let's make it real
  504. HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  505. if (!hGlobal)
  506. {
  507.   TRACE(_T("Load (resource): Error allocating memory\n"));
  508.   FreeResource(hResData);
  509.   return FALSE;
  510. };
  512. char *pDest = reinterpret_cast<char *> (GlobalLock(hGlobal));
  513. char *pSrc = reinterpret_cast<char *> (LockResource(hResData));
  514. if (!pSrc || !pDest)
  515. {
  516.   TRACE(_T("Load (resource): Error locking memory\n"));
  517.   GlobalFree(hGlobal);
  518.   FreeResource(hResData);
  519.   return FALSE;
  520. };
  521. CopyMemory(pDest,pSrc,dwSize);
  522. FreeResource(hResData);
  523. GlobalUnlock(hGlobal);
  525. BOOL bRetValue = Load(hGlobal,dwSize);
  526. GlobalFree(hGlobal);
  527. return bRetValue;
  528. }
  530. void CPictureEx::ResetDataPointer()
  531. {
  532. // skip header and logical screen descriptor
  533. m_nCurrOffset =
  534.   sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  535. }
  537. BOOL CPictureEx::SkipNextGraphicBlock()
  538. {
  539. if (!m_pRawData) return FALSE;
  541. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  543. enum GIFBlockTypes nBlock;
  545. nBlock = GetNextBlock();
  547. while ((nBlock != BLOCK_CONTROLEXT) &&
  548.      (nBlock != BLOCK_IMAGE) &&
  549.      (nBlock != BLOCK_PLAINTEXT) &&
  550.      (nBlock != BLOCK_UNKNOWN) &&
  551.      (nBlock != BLOCK_TRAILER) )
  552. {
  553.   if (!SkipNextBlock()) return NULL;
  554.   nBlock = GetNextBlock();
  555. };
  557. if ((nBlock == BLOCK_UNKNOWN) ||
  558.   (nBlock == BLOCK_TRAILER))
  559.   return FALSE;
  561. // it's either a control ext.block, an image or a plain text
  563. if (GetNextBlockLen() <= 0) return FALSE;
  565. if (nBlock == BLOCK_CONTROLEXT)
  566. {
  567.   if (!SkipNextBlock()) return FALSE;
  568.   nBlock = GetNextBlock();
  570.   // skip everything until we meet an image block or a plain-text block
  571.   while ((nBlock != BLOCK_IMAGE) &&
  572.       (nBlock != BLOCK_PLAINTEXT) &&
  573.       (nBlock != BLOCK_UNKNOWN) &&
  574.       (nBlock != BLOCK_TRAILER) )
  575.   {
  576.    if (!SkipNextBlock()) return NULL;
  577.    nBlock = GetNextBlock();
  578.   };
  580.   if ((nBlock == BLOCK_UNKNOWN) ||
  581.    (nBlock == BLOCK_TRAILER))
  582.    return FALSE;
  583. };
  585. // skip the found data block (image or plain-text)
  586. if (!SkipNextBlock()) return FALSE;
  588. return TRUE;
  589. }
  591. UINT CPictureEx::GetSubBlocksLen(UINT nStartingOffset) const
  592. {
  593. UINT nRet = 0;
  594. UINT nCurOffset = nStartingOffset;
  596. while (m_pRawData[nCurOffset] != 0)
  597. {
  598.   nRet += m_pRawData[nCurOffset]+1;
  599.   nCurOffset += m_pRawData[nCurOffset]+1;
  600. };
  602. return nRet+1;
  603. }
  605. enum CPictureEx::GIFBlockTypes CPictureEx::GetNextBlock() const
  606. {
  607. switch(m_pRawData[m_nCurrOffset])
  608. {
  609. case 0x21:
  610. // extension block
  611.   switch(m_pRawData[m_nCurrOffset+1])
  612.   {
  613.   case 0x01:
  614.   // plain text extension
  615.    return BLOCK_PLAINTEXT;
  616.    break;
  618.   case 0xF9:
  619.   // graphic control extension
  620.    return BLOCK_CONTROLEXT;
  621.    break;
  623.   case 0xFE:
  624.   // comment extension
  625.    return BLOCK_COMMEXT;
  626.    break;
  628.   case 0xFF:
  629.   // application extension
  630.    return BLOCK_APPEXT;
  631.    break;
  632.   };
  633.   break;
  635. case 0x3B:
  636. // trailer
  637.   return BLOCK_TRAILER;
  638.   break;
  640. case 0x2C:
  641. // image data
  642.   return BLOCK_IMAGE;
  643.   break;
  644. };
  646. return BLOCK_UNKNOWN;
  647. }
  649. BOOL CPictureEx::SkipNextBlock()
  650. {
  651. if (!m_pRawData) return FALSE;
  653. int nLen = GetNextBlockLen();
  654. if ((nLen <= 0) || ((m_nCurrOffset+nLen) > m_nDataSize))
  655.   return FALSE;
  657. m_nCurrOffset += nLen;
  658. return TRUE;
  659. }
  661. int CPictureEx::GetNextBlockLen() const
  662. {
  663. GIFBlockTypes nBlock = GetNextBlock();
  665. int nTmp;
  667. switch(nBlock)
  668. {
  669. case BLOCK_UNKNOWN:
  670.   return -1;
  671.   break;
  673. case BLOCK_TRAILER:
  674.   return 1;
  675.   break;
  677. case BLOCK_APPEXT:
  678.   nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFAppExtension));
  679.   if (nTmp > 0)
  680.    return sizeof(TGIFAppExtension)+nTmp;
  681.   break;
  683. case BLOCK_COMMEXT:
  684.   nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFCommentExt));
  685.   if (nTmp > 0)
  686.    return sizeof(TGIFCommentExt)+nTmp;
  687.   break;
  689. case BLOCK_CONTROLEXT:
  690.   return sizeof(TGIFControlExt);
  691.   break;
  693. case BLOCK_PLAINTEXT:
  694.   nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFPlainTextExt));
  695.   if (nTmp > 0)
  696.    return sizeof(TGIFPlainTextExt)+nTmp;
  697.   break;
  699. case BLOCK_IMAGE:
  700.   TGIFImageDescriptor *pIDescr =
  701.    reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  702.   int nLCTSize = (int)
  703.    (pIDescr->GetPackedValue(ID_PACKED_LOCALCT)*3*
  704.    (1 << (pIDescr->GetPackedValue(ID_PACKED_LOCALCTSIZE)+1)));
  706.   int nTmp = GetSubBlocksLen(m_nCurrOffset+
  707.    sizeof(TGIFImageDescriptor) + nLCTSize + 1);
  708.   if (nTmp > 0)
  709.    return sizeof(TGIFImageDescriptor) + nLCTSize + 1 + nTmp;
  710.   break;
  711. };
  713. return 0;
  714. }
  716. UINT WINAPI CPictureEx::_ThreadAnimation(LPVOID pParam)
  717. {
  718. ASSERT(pParam);
  719. CPictureEx *pPic = reinterpret_cast<CPictureEx *> (pParam);
  721. pPic->m_bIsPlaying = TRUE;
  722. pPic->ThreadAnimation();
  723. pPic->m_bIsPlaying = FALSE;
  725. // this thread has finished its work so we close the handle
  726. CloseHandle(pPic->m_hThread);
  727. // and init the handle to zero (so that Stop() doesn't Wait on it)
  728. pPic->m_hThread = 0;
  729. return 0;
  730. }
  732. void CPictureEx::ThreadAnimation()
  733. {
  734. // first, restore background (for stop/draw support)
  735. // disposal method #2
  736. if (m_arrFrames[m_nCurrFrame].m_nDisposal == 2)
  737. {
  738.   HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  739.   if (hBrush)
  740.   {
  741.    RECT rect = {
  742.     m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  743.     m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  744.     m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  745.     m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };
  746.    FillRect(m_hMemDC,&rect,hBrush);
  747.    DeleteObject(hBrush);
  748.   };
  749. }
  750. else
  751.   // disposal method #3
  752.   if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == 3) )
  753.   {
  754.    // put it back
  755.    BitBlt(m_hMemDC,
  756.     m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  757.     m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  758.     m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  759.     m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  760.     m_hDispMemDC,0,0, SRCCOPY);
  761.    // init variables
  762.    SelectObject(m_hDispMemDC,m_hDispOldBM);
  763.    DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;
  764.    DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;
  765.   };
  767. while (!m_bExitThread)
  768. {
  769.   if (m_arrFrames[m_nCurrFrame].m_pPicture)
  770.   {
  771.   ///////////////////////////////////////////////////////
  772.   // Before rendering a frame we should take care of what's
  773.   // behind that frame. TFrame::m_nDisposal will be our guide:
  774.   //   0 - no disposal specified (do nothing)
  775.   //   1 - do not dispose (again, do nothing)
  776.   //   2 - restore to background color (m_clrBackground)
  777.   //   3 - restore to previous
  779.    //////// disposal method #3
  780.    if (m_arrFrames[m_nCurrFrame].m_nDisposal == 3)
  781.    {
  782.     // prepare a memory DC and store the background in it
  783.     m_hDispMemDC = CreateCompatibleDC(m_hMemDC);
  784.     m_hDispMemBM = CreateCompatibleBitmap(m_hMemDC,
  785.        m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  786.        m_arrFrames[m_nCurrFrame].m_frameSize.cy);
  787.     
  788.     if (m_hDispMemDC && m_hDispMemBM)
  789.     {
  790.      m_hDispOldBM = reinterpret_cast<HBITMAP> (SelectObject(m_hDispMemDC,m_hDispMemBM));
  791.      BitBlt(m_hDispMemDC,0,0,
  792.       m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  793.       m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  794.       m_hMemDC,
  795.       m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  796.       m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  797.       SRCCOPY);
  798.     };
  799.    };
  800.    ///////////////////////
  802.    long hmWidth;
  803.    long hmHeight;
  804.    m_arrFrames[m_nCurrFrame].m_pPicture->get_Width(&hmWidth);
  805.    m_arrFrames[m_nCurrFrame].m_pPicture->get_Height(&hmHeight);
  807.    if (m_arrFrames[m_nCurrFrame].m_pPicture->Render(m_hMemDC,
  808.     m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  809.     m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  810.     m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  811.     m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  812.     0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  813.    {
  814.     Invalidate(FALSE);
  815.    };
  816.   
  817.    if (m_bExitThread) break;
  819.    // if the delay time is too short (like in old GIFs), wait for 100ms
  820.    if (m_arrFrames[m_nCurrFrame].m_nDelay < 5)
  821.     WaitForSingleObject(m_hExitEvent, 100);
  822.    else
  823.     WaitForSingleObject(m_hExitEvent, 10*m_arrFrames[m_nCurrFrame].m_nDelay);
  825.    if (m_bExitThread) break;
  827.    // disposal method #2
  828.    if (m_arrFrames[m_nCurrFrame].m_nDisposal == 2)
  829.    {
  830.     HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  831.     if (hBrush)
  832.     {
  833.      RECT rect = {
  834.       m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  835.       m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  836.       m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  837.       m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };
  838.      FillRect(m_hMemDC,&rect,hBrush);
  839.      DeleteObject(hBrush);
  840.     };
  841.    }
  842.    else
  843.     if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == 3) )
  844.     {
  845.      // put it back
  846.      BitBlt(m_hMemDC,
  847.       m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  848.       m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  849.       m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  850.       m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  851.       m_hDispMemDC,0,0, SRCCOPY);
  852.      // init variables
  853.      SelectObject(m_hDispMemDC,m_hDispOldBM);
  854.      DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;
  855.      DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;
  856.     };
  857.   };
  858.   m_nCurrFrame++;
  859.   if (m_nCurrFrame == m_arrFrames.size())
  860.   {
  861.    m_nCurrFrame
  862.     = 0;
  863.   // init the screen for the first frame,
  864.    HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  865.    if (hBrush)
  866.    {
  867.     RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  868.     FillRect(m_hMemDC,&rect,hBrush);
  869.     DeleteObject(hBrush);
  870.    };
  871.   };
  872. };
  873. }
  875. void CPictureEx::Stop()
  876. {
  877. m_bIsPlaying = FALSE;
  878. m_bExitThread = TRUE;
  879. SetEvent(m_hExitEvent);
  880. if (m_hThread)
  881. {
  882.   // we'll wait for 5 seconds then continue execution
  883.   WaitForSingleObject(m_hThread,5000);
  884.   CloseHandle(m_hThread);
  885.   m_hThread = NULL;
  886. }
  888. // make it possible to Draw() again
  889. ResetEvent(m_hExitEvent);
  890. m_bExitThread = FALSE;
  891. }
  893. HGLOBAL CPictureEx::GetNextGraphicBlock(UINT *pBlockLen,
  894. UINT *pDelay, SIZE *pBlockSize, SIZE *pBlockOffset,
  895. UINT *pDisposal)
  896. {
  897. if (!m_pRawData) return NULL;
  899. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  901. *pDisposal = 0;
  902. enum GIFBlockTypes nBlock;
  903. nBlock = GetNextBlock();
  905. while (
  906.   (nBlock != BLOCK_CONTROLEXT) &&
  907.   (nBlock != BLOCK_IMAGE) &&
  908.   (nBlock != BLOCK_PLAINTEXT) &&
  909.   (nBlock != BLOCK_UNKNOWN) &&
  910.   (nBlock != BLOCK_TRAILER)
  911.   )
  912. {
  913.   if (!SkipNextBlock()) return NULL;
  914.   nBlock = GetNextBlock();
  915. };
  917. if ((nBlock == BLOCK_UNKNOWN) ||
  918.   (nBlock == BLOCK_TRAILER))
  919.   return NULL;
  921. // it's either a control ext.block, an image or a plain text
  923. int nStart = m_nCurrOffset;
  924. int nBlockLen = GetNextBlockLen();
  926. if (nBlockLen <= 0) return NULL;
  928. if (nBlock == BLOCK_CONTROLEXT)
  929. {
  930.   // get the following data
  931.   TGIFControlExt *pControl =
  932.    reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  933.   // store delay time
  934.   *pDelay = pControl->m_wDelayTime;
  935.   // store disposal method
  936.   *pDisposal = pControl->GetPackedValue(GCX_PACKED_DISPOSAL);
  938.   if (!SkipNextBlock()) return NULL;
  939.   nBlock = GetNextBlock();
  940.   
  941.   // skip everything until we find data to display
  942.   // (image block or plain-text block)
  943.   
  944.   while (
  945.    (nBlock != BLOCK_IMAGE) &&
  946.    (nBlock != BLOCK_PLAINTEXT) &&
  947.    (nBlock != BLOCK_UNKNOWN) &&
  948.    (nBlock != BLOCK_TRAILER)
  949.    )
  950.   {
  951.    if (!SkipNextBlock()) return NULL;
  952.    nBlock = GetNextBlock();
  953.    nBlockLen += GetNextBlockLen();
  954.   };
  956.   if ((nBlock == BLOCK_UNKNOWN) || (nBlock == BLOCK_TRAILER))
  957.    return NULL;
  958.   nBlockLen += GetNextBlockLen();
  959. }
  960. else
  961.   *pDelay = -1; // to indicate that there was no delay value
  963. if (nBlock == BLOCK_IMAGE)
  964. {
  965.   // store size and offsets
  966.   TGIFImageDescriptor *pImage =
  967.    reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  968.   pBlockSize->cx = pImage->m_wWidth;
  969.   pBlockSize->cy = pImage->m_wHeight;
  970.   pBlockOffset->cx = pImage->m_wLeftPos;
  971.   pBlockOffset->cy = pImage->m_wTopPos;
  972. };
  974. if (!SkipNextBlock()) return NULL;
  976. HGLOBAL hGlobal = GlobalAlloc(GMEM_FIXED,
  977.   sizeof(TGIFHeader) +
  978.   sizeof(TGIFLSDescriptor) +
  979.   m_nGlobalCTSize +
  980.   nBlockLen +
  981.   1);  // for the trailer
  983. if (!hGlobal) return NULL;
  985. int nOffset = 0;
  987. // GMEM_FIXED means we get a pointer
  988. unsigned char *pGlobal = reinterpret_cast<unsigned char *> (hGlobal);
  990. CopyMemory(pGlobal,m_pRawData,
  991.   sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize);
  992. nOffset += sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  994. CopyMemory(pGlobal + nOffset,&m_pRawData[nStart], nBlockLen);
  995. nOffset += nBlockLen;
  997. pGlobal[nOffset] = 0x3B; // trailer
  998. nOffset++;
  1000. *pBlockLen = nOffset;
  1002. return hGlobal;
  1003. }
  1005. BOOL CPictureEx::IsGIF() const
  1006. {
  1007. return m_bIsGIF;
  1008. }
  1010. BOOL CPictureEx::IsAnimatedGIF() const
  1011. {
  1012. return (m_bIsGIF && (m_arrFrames.size() > 1));
  1013. }
  1015. BOOL CPictureEx::IsPlaying() const
  1016. {
  1017. return m_bIsPlaying;
  1018. }
  1020. int CPictureEx::GetFrameCount() const
  1021. {
  1022. if (!IsAnimatedGIF())
  1023.   return 0;
  1025. return m_arrFrames.size();
  1026. }
  1028. COLORREF CPictureEx::GetBkColor() const
  1029. {
  1030. return m_clrBackground;
  1031. }
  1033. void CPictureEx::OnPaint()
  1034. {
  1035. CPaintDC dc(this); // device context for painting
  1037. LONG nPaintWidth = m_PaintRect.right-m_PaintRect.left;
  1039. if (nPaintWidth > 0)
  1040. {
  1041.   LONG nPaintHeight = m_PaintRect.bottom - m_PaintRect.top;
  1042.   ::BitBlt(dc.m_hDC, 0, 0, nPaintWidth, nPaintHeight,
  1043.    m_hMemDC, m_PaintRect.left, m_PaintRect.top, SRCCOPY);
  1044. }
  1045. else
  1046. {
  1047.   ::BitBlt(dc.m_hDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy,
  1048.    m_hMemDC, 0, 0, SRCCOPY);
  1049. };
  1050. }
  1052. BOOL CPictureEx::PrepareDC(int nWidth, int nHeight)
  1053. {
  1054. SetWindowPos(NULL,0,0,nWidth,nHeight,SWP_NOMOVE | SWP_NOZORDER);
  1056. HDC hWinDC = ::GetDC(m_hWnd);
  1057. if (!hWinDC) return FALSE;
  1059. m_hMemDC = CreateCompatibleDC(hWinDC);
  1060. if (!m_hMemDC)
  1061. {
  1062.   ::ReleaseDC(m_hWnd,hWinDC);
  1063.   return FALSE;
  1064. };
  1066. m_hBitmap  = CreateCompatibleBitmap(hWinDC,nWidth,nHeight);
  1067. if (!m_hBitmap)
  1068. {
  1069.   ::ReleaseDC(m_hWnd,hWinDC);
  1070.   ::DeleteDC(m_hMemDC);
  1071.   return FALSE;
  1072. };
  1074. m_hOldBitmap = reinterpret_cast<HBITMAP>
  1075.       (SelectObject(m_hMemDC,m_hBitmap));
  1077. // fill the background
  1078. m_clrBackground = GetSysColor(COLOR_3DFACE);
  1079. RECT rect = {0,0,nWidth,nHeight};
  1080. FillRect(m_hMemDC,&rect,(HBRUSH)(COLOR_WINDOW));
  1082. ::ReleaseDC(m_hWnd,hWinDC);
  1083. m_bIsInitialized = TRUE;
  1084. return TRUE;
  1085. }
  1087. void CPictureEx::OnDestroy()
  1088. {
  1089. Stop();
  1090. CStatic::OnDestroy();
  1091. }
  1093. void CPictureEx::SetBkColor(COLORREF clr)
  1094. {
  1095. if (!m_bIsInitialized) return;
  1097. m_clrBackground = clr;
  1099. HBRUSH hBrush = CreateSolidBrush(clr);
  1100. if (hBrush)
  1101. {
  1102.   RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  1103.   FillRect(m_hMemDC,&rect,hBrush);
  1104.   DeleteObject(hBrush);
  1105. };
  1106. }
  1108. #ifdef GIF_TRACING
  1109. void CPictureEx::WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize)
  1110. {
  1111. CFile file;
  1113. if (!file.Open(szFileName,
  1114.    CFile::modeCreate |
  1115.    CFile::modeWrite |
  1116.    CFile::shareDenyNone))
  1117. {
  1118.   TRACE(_T("WriteData: Error creating file %s\n"),szFileName);
  1119.   return;
  1120. };
  1122. char *pData = reinterpret_cast<char *> (GlobalLock(hData));
  1123. if (!pData)
  1124. {
  1125.   TRACE(_T("WriteData: Error locking memory\n"));
  1126.   return;
  1127. };
  1129. TRY
  1130. {
  1131.   file.Write(pData,dwSize);
  1132. }
  1133. CATCH(CFileException, e);                                          
  1134. {
  1135.   TRACE(_T("WriteData: An exception occured while writing to the file %s\n"),
  1136.    szFileName);
  1137.   e->Delete();
  1138.   GlobalUnlock(hData);
  1139.   file.Close();
  1140.   return;
  1141. }
  1142. END_CATCH
  1144. GlobalUnlock(hData);
  1145. file.Close();
  1146. }
  1148. void CPictureEx::EnumGIFBlocks()
  1149. {
  1150. enum GIFBlockTypes nBlock;
  1152. ResetDataPointer();
  1153. while(m_nCurrOffset < m_nDataSize)
  1154. {
  1155.   nBlock = GetNextBlock();
  1156.   switch(nBlock)
  1157.   {
  1158.   case BLOCK_UNKNOWN:
  1159.    TRACE(_T("- Unknown block\n"));
  1160.    return;
  1161.    break;
  1163.   case BLOCK_TRAILER:
  1164.    TRACE(_T("- Trailer block\n"));
  1165.    break;
  1167.   case BLOCK_APPEXT:
  1168.    TRACE(_T("- Application extension block\n"));
  1169.    break;
  1171.   case BLOCK_COMMEXT:
  1172.    TRACE(_T("- Comment extension block\n"));
  1173.    break;
  1175.   case BLOCK_CONTROLEXT:
  1176.    {
  1177.    TGIFControlExt *pControl =
  1178.     reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  1179.    TRACE(_T("- Graphic control extension block (delay %d, disposal %d)\n"),
  1180.      pControl->m_wDelayTime, pControl->GetPackedValue(GCX_PACKED_DISPOSAL));
  1181.    };
  1182.    break;
  1184.   case BLOCK_PLAINTEXT:
  1185.    TRACE(_T("- Plain text extension block\n"));
  1186.    break;
  1188.   case BLOCK_IMAGE:
  1189.    TGIFImageDescriptor *pIDescr =
  1190.     reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  1191.    TRACE(_T("- Image data block (%dx%d  %d,%d)\n"),
  1192.      pIDescr->m_wWidth,
  1193.      pIDescr->m_wHeight,
  1194.      pIDescr->m_wLeftPos,
  1195.      pIDescr->m_wTopPos);
  1196.    break;
  1197.   };
  1199.   SkipNextBlock();
  1200. };
  1202. TRACE(_T("\n"));
  1203. }
  1204. #endif // GIF_TRACING
  1206. BOOL CPictureEx::SetPaintRect(const RECT *lpRect)
  1207. {
  1208. return CopyRect(&m_PaintRect, lpRect);
  1209. }
  1211. BOOL CPictureEx::GetPaintRect(RECT *lpRect)
  1212. {
  1213. return CopyRect(lpRect, &m_PaintRect);
  1214. }
i\4Qv"%  
lkj^<%N"r  
Q}a, f75  
;(]O*{F7k  
PS：有多少人是被这张美女图片给吸引进来的呢？
广海社区提醒您：
1.忘记账号、密码、安全问题等常见站务问题，请查看论坛左上角站点帮助
2.请理性对待商业信息，如有交易，强烈建议您选择广海中介进行交易
3.欢迎购买广海社区广告位，感谢您的支持，报价及位置详见广海社区广告服务
4.特殊会员售价50元，积分（金钱和威望）无限，更多权限，欢迎到广海淘宝购买
5.广海社区唯一域名ghoffice.cc，唯一QQ190959022，其他均为假冒，谨防上当受骗
6.如您被骗，请查看广海社区举报中心，按照要求和流程提交举报材料，未经核实的举报帖子将一律删除
7.如您发现违规违法内容，欢迎点击帖子右下角举报按钮进行举报，也可到站务办公版块匿名发帖举报
免责声明
文中内容未经本站证实，对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。 私下交易造成损失的，本站概不负责。
 
回复
举报
分享到 淘江湖 新浪 QQ微博 QQ空间 开心 人人 豆瓣 网易微博 百度 鲜果 白社会 飞信
离线huaiyesu
韶华一笑间

发帖
2
金钱
342
威望
302
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 沙发   发表于: 2019-07-01
看图片的停留时间 超过看代码的时间！
回复
举报
离线龙剑飞
特殊会员

发帖
22
金钱
571
威望
571
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 板凳   发表于: 2019-07-09
感谢分享
回复
举报
离线兔崽子
特殊会员

发帖
1
金钱
1200
威望
1200
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 地板   发表于: 2019-08-03
感谢分享
回复
举报
离线qianlan
韶华一笑间

发帖
1
金钱
401
威望
401
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 4楼  发表于: 2019-08-03
看看我的ID
回复
举报
离线水上往来
韶华一笑间

发帖
3
金钱
303
威望
303
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 5楼  发表于: 2019-08-16
貌似不错，学习了
回复
举报
离线bailnln
特殊会员

发帖
1
金钱
1200
威望
1200
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 6楼  发表于: 2019-09-12
能不能出个C++初学教程啊
回复
举报
离线易了科技
特殊会员

发帖
57
金钱
892
威望
892
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 7楼  发表于: 2020-02-14
感谢，很受用呢！
回复
举报
离线daybreak
韶华一笑间

发帖
9
金钱
516
威望
516
贡献值
0
诚信值
4500
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 8楼  发表于: 2021-09-04
感谢分享，受用了
回复
举报
离线xiaoxin
韶华一笑间

发帖
24
金钱
16
威望
0
贡献值
0
诚信值
0
社区警告
0
纠纷记录
0
冻结资金
0
保证金
0
只看该作者 9楼  发表于: 2021-10-05
感谢分享
回复
举报
发帖 回复
返回列表
快速回复
限150 字节
如果您在写长篇帖子又不马上发表，建议存为草稿
 
上一个 下一个