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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 其他数据库 > 查看源码
PictureEx.cpp
资源名称：ODBCRWExcel.zip　[点击查看]
上传用户：xiuanze55
上传日期：2013-06-16
资源大小：85k
文件大小：27k
源码类别：

其他数据库

开发平台：

Visual C++

PictureEx.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. // PictureEx.cpp: implementation of the CPicture class.
  3. //
  4. // Picture displaying control with support for the following formats:
  5. // GIF (including animated GIF87a and GIF89a), JPEG, BMP, WMF, ICO, CUR
  6. // 
  7. // Written by Oleg Bykov (oleg_bykoff@rsdn.ru)
  8. //
  9. // Modified by jingzhou Xu
  10. //////////////////////////////////////////////////////////////////////
  12. #include "stdafx.h"
  13. #include "PictureEx.h"
  14. #include <math.h>
  15. #include <process.h>
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[]=__FILE__;
  20. #define new DEBUG_NEW
  21. #endif
  23. //////////////////////////////////////////////////////////////////////
  24. // Nested structures member functions
  25. //////////////////////////////////////////////////////////////////////
  27. inline int CPictureEx::TGIFControlExt::GetPackedValue(enum ControlExtValues Value)
  28. {
  29. int nRet = (int)m_cPacked;
  30. switch (Value)
  31. {
  32. case GCX_PACKED_DISPOSAL:
  33. nRet = (nRet & 28) >> 2;
  34. break;
  36. case GCX_PACKED_USERINPUT:
  37. nRet = (nRet & 2) >> 1;
  38. break;
  40. case GCX_PACKED_TRANSPCOLOR:
  41. nRet &= 1;
  42. break;
  43. };
  45. return nRet;
  46. }
  48. inline int CPictureEx::TGIFLSDescriptor::GetPackedValue(enum LSDPackedValues Value)
  49. {
  50. int nRet = (int)m_cPacked;
  52. switch (Value)
  53. {
  54. case LSD_PACKED_GLOBALCT:
  55. nRet = nRet >> 7;
  56. break;
  58. case LSD_PACKED_CRESOLUTION:
  59. nRet = ((nRet & 0x70) >> 4) + 1;
  60. break;
  62. case LSD_PACKED_SORT:
  63. nRet = (nRet & 8) >> 3;
  64. break;
  66. case LSD_PACKED_GLOBALCTSIZE:
  67. nRet &= 7;
  68. break;
  69. };
  71. return nRet;
  72. }
  74. inline int CPictureEx::TGIFImageDescriptor::GetPackedValue(enum IDPackedValues Value)
  75. {
  76. int nRet = (int)m_cPacked;
  78. switch (Value)
  79. {
  80. case ID_PACKED_LOCALCT:
  81. nRet >>= 7;
  82. break;
  84. case ID_PACKED_INTERLACE:
  85. nRet = ((nRet & 0x40) >> 6);
  86. break;
  88. case ID_PACKED_SORT:
  89. nRet = (nRet & 0x20) >> 5;
  90. break;
  92. case ID_PACKED_LOCALCTSIZE:
  93. nRet &= 7;
  94. break;
  95. };
  97. return nRet;
  98. }
  101. //////////////////////////////////////////////////////////////////////
  102. // Construction/Destruction
  103. //////////////////////////////////////////////////////////////////////
  105. CPictureEx::CPictureEx()
  106. {
  107. // check structures size
  108. ASSERT(sizeof(TGIFImageDescriptor) == 10);
  109. ASSERT(sizeof(TGIFAppExtension)    == 14);
  110. ASSERT(sizeof(TGIFPlainTextExt)    == 15);
  111. ASSERT(sizeof(TGIFLSDescriptor)    ==  7);
  112. ASSERT(sizeof(TGIFControlExt)    ==  8);
  113. ASSERT(sizeof(TGIFCommentExt)    ==  2);
  114. ASSERT(sizeof(TGIFHeader)    ==  6);
  116. m_pGIFLSDescriptor = NULL;
  117. m_pGIFHeader    = NULL;
  118. m_pPicture    = NULL;
  119. m_pRawData    = NULL;
  120. m_hThread    = NULL;
  121. m_hBitmap          = NULL;
  122. m_hMemDC    = NULL;
  123. m_bIsInitialized   = FALSE;
  124. m_bExitThread    = FALSE;
  125. m_bIsGIF    = FALSE;
  126. m_clrBackground    = RGB(255,255,255); // white by default
  127. m_nGlobalCTSize    = 0;
  128. m_nCurrOffset    = 0;
  129. m_nDataSize    = 0;
  130. m_PictureSize.cx = m_PictureSize.cy = 0;
  132. m_hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  133. }
  135. CPictureEx::~CPictureEx()
  136. {
  137. UnLoad();
  138. CloseHandle(m_hExitEvent);
  139. }
  141. BEGIN_MESSAGE_MAP(CPictureEx, CStatic)
  142. //{{AFX_MSG_MAP(CMyStatic)
  143. ON_WM_DESTROY()
  144. ON_WM_PAINT()
  145. //}}AFX_MSG_MAP
  146. END_MESSAGE_MAP()
  148. BOOL CPictureEx::Load(HGLOBAL hGlobal, DWORD dwSize)
  149. {
  150. IStream *pStream = NULL;
  151. UnLoad();
  153. if (!(m_pRawData = reinterpret_cast<unsigned char*> (GlobalLock(hGlobal))) )
  154. {
  155. TRACE(_T("Load: Error locking memoryn"));
  156. return FALSE;
  157. };
  159. m_nDataSize = dwSize;
  160. m_pGIFHeader = reinterpret_cast<TGIFHeader *> (m_pRawData);
  162. if ((memcmp(&m_pGIFHeader->m_cSignature,"GIF",3) != 0) &&
  163. ((memcmp(&m_pGIFHeader->m_cVersion,"87a",3) != 0) ||
  164.  (memcmp(&m_pGIFHeader->m_cVersion,"89a",3) != 0)) )
  165. {
  166. // it's neither GIF87a nor GIF89a
  167. // do the default processing
  169. // clear GIF variables
  170. m_pRawData = NULL;
  171. GlobalUnlock(hGlobal);
  173. // don't delete memory on object's release
  174. if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  175. return FALSE;
  177. if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  178. reinterpret_cast<LPVOID *>(&m_pPicture)) != S_OK)
  179. {
  180. pStream->Release();
  181. return FALSE;
  182. };
  183. pStream->Release();
  185. // store picture's size
  187. long hmWidth;
  188. long hmHeight;
  189. m_pPicture->get_Width(&hmWidth);
  190. m_pPicture->get_Height(&hmHeight);
  192. HDC hDC = ::GetDC(m_hWnd);
  193. m_PictureSize.cx = MulDiv(hmWidth, GetDeviceCaps(hDC,LOGPIXELSX), 2540);
  194. m_PictureSize.cy = MulDiv(hmHeight, GetDeviceCaps(hDC,LOGPIXELSY), 2540);
  195. ::ReleaseDC(m_hWnd,hDC);
  196. }
  197. else
  198. {
  199. // it's a GIF
  200. m_bIsGIF = TRUE;
  201. m_pGIFLSDescriptor = reinterpret_cast<TGIFLSDescriptor *>
  202. (m_pRawData + sizeof(TGIFHeader));
  203. if (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT) == 1)
  204. {
  205. // calculate the globat color table size
  206. m_nGlobalCTSize = static_cast<int>
  207. (3*pow(2,m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE)+1));
  208. // get the background color if GCT is present
  209. unsigned char *pBkClr = m_pRawData + sizeof(TGIFHeader) + 
  210. sizeof(TGIFLSDescriptor) + 3*m_pGIFLSDescriptor->m_cBkIndex;
  211. m_clrBackground = RGB(pBkClr[0],pBkClr[1],pBkClr[2]);
  212. };
  214. // store the picture's size
  215. m_PictureSize.cx = m_pGIFLSDescriptor->m_wWidth;
  216. m_PictureSize.cy = m_pGIFLSDescriptor->m_wHeight;
  218. // determine frame count for this picture
  219. UINT nFrameCount=0;
  220. ResetDataPointer();
  221. while (SkipNextGraphicBlock())
  222. nFrameCount++;
  224. #ifdef GIF_TRACING
  225. TRACE(
  226. _T(" -= GIF encounteredn"
  227.    "Logical Screen dimensions = %dx%dn"
  228.    "Global color table = %dn"
  229.    "Color depth = %dn"
  230.    "Sort flag = %dn"
  231.    "Size of Global Color Table = %dn"
  232.    "Background color index = %dn"
  233.    "Pixel aspect ratio = %dn"
  234.    "Frame count = %dn"
  235.    "Background color = %06Xhnn"
  236.   ),
  237. m_pGIFLSDescriptor->m_wWidth,
  238. m_pGIFLSDescriptor->m_wHeight,
  239. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT),
  240. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_CRESOLUTION),
  241. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_SORT),
  242. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE),
  243. m_pGIFLSDescriptor->m_cBkIndex,
  244. m_pGIFLSDescriptor->m_cPixelAspect,
  245. nFrameCount,
  246. m_clrBackground
  247. );
  248. EnumGIFBlocks();
  249. #endif
  251. if (nFrameCount == 0) // it's an empty GIF!
  252. {
  253. m_pRawData = NULL;
  254. GlobalUnlock(hGlobal);
  255. return FALSE;
  256. };
  258. // now check the frame count
  259. // if there's only one frame, no need to animate this GIF
  260. // therefore, treat it like any other pic
  262. if (nFrameCount == 1)
  263. {
  264. // clear GIF variables
  265. m_pRawData = NULL;
  266. GlobalUnlock(hGlobal);
  268. // don't delete memory on object's release
  269. if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  270. return FALSE;
  272. if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  273. (LPVOID *)&m_pPicture) != S_OK)
  274. {
  275. pStream->Release();
  276. return FALSE;
  277. };
  279. pStream->Release();
  280. }
  281. else
  282. {
  283. // if, on the contrary, there are several frames
  284. // then store separate frames in an array
  286. TFrame frame;
  287. UINT nBlockLen;
  288. HGLOBAL hFrameData;
  289. UINT nCurFrame = 0;
  291. ResetDataPointer();
  292. while (hFrameData = GetNextGraphicBlock(&nBlockLen,
  293. &frame.m_nDelay, &frame.m_frameSize,
  294. &frame.m_frameOffset, &frame.m_nDisposal) )
  295. {
  296. #ifdef GIF_TRACING
  297. //////////////////////////////////////////////
  298. // uncomment the following strings if you want 
  299. // to write separate frames on disk
  300. //
  301. // CString szName;
  302. // szName.Format(_T("%.4d.gif"),nCurFrame);
  303. // WriteDataOnDisk(szName,hFrameData,nBlockLen);
  304. // nCurFrame++;
  305. #endif // GIF_TRACING
  307. IStream *pStream = NULL;
  309. // delete memory on object's release
  310. if (CreateStreamOnHGlobal(hFrameData,TRUE,&pStream) != S_OK)
  311. {
  312. GlobalFree(hFrameData);
  313. continue;
  314. };
  316. if (OleLoadPicture(pStream,nBlockLen,FALSE,
  317. IID_IPicture,
  318. reinterpret_cast<LPVOID *>(&frame.m_pPicture)) != S_OK)
  319. {
  320. pStream->Release();
  321. continue;
  322. };
  323. pStream->Release();
  325. // everything went well, add this frame
  326. m_arrFrames.push_back(frame);
  327. };
  329. // clean after ourselves
  330. m_pRawData = NULL;
  331. GlobalUnlock(hGlobal);
  333. if (m_arrFrames.empty()) // couldn't load any frames
  334. return FALSE;
  335. };
  336. }; // if (!IsGIF...
  338. return PrepareDC(m_PictureSize.cx,m_PictureSize.cy);
  339. }
  341. void CPictureEx::UnLoad()
  342. {
  343. Stop();
  344. if (m_pPicture)
  345. {
  346. m_pPicture->Release();
  347. m_pPicture = NULL;
  348. };
  350. std::vector<TFrame>::iterator it;
  351. for (it=m_arrFrames.begin();it<m_arrFrames.end();it++)
  352. (*it).m_pPicture->Release();
  353. m_arrFrames.clear();
  355. if (m_hMemDC)
  356. {
  357. SelectObject(m_hMemDC,m_hOldBitmap);
  358. ::DeleteDC(m_hMemDC);
  359. ::DeleteObject(m_hBitmap);
  360. m_hMemDC  = NULL;
  361. m_hBitmap = NULL;
  362. };
  364. m_pGIFLSDescriptor = NULL;
  365. m_pGIFHeader    = NULL;
  366. m_pRawData    = NULL;
  367. m_hThread    = NULL;
  368. m_bIsInitialized   = FALSE;
  369. m_bExitThread    = FALSE;
  370. m_bIsGIF    = FALSE;
  371. m_clrBackground    = RGB(255,255,255); // white by default
  372. m_nGlobalCTSize    = 0;
  373. m_nCurrOffset    = 0;
  374. m_nDataSize    = 0;
  375. }
  377. BOOL CPictureEx::Draw()
  378. {
  379. if (!m_bIsInitialized)
  380. {
  381. TRACE(_T("Call of one the CPictureEx::Load() member functions before calling Draw()n"));
  382. return FALSE;
  383. };
  385. if (IsAnimatedGIF())
  386. {
  387. // the picture needs some animation
  388. // we'll start the thread that will handle it for us
  390. unsigned int nDummy;
  391. m_hThread = (HANDLE) _beginthreadex(NULL,0,_ThreadAnimation,this,
  392. CREATE_SUSPENDED,&nDummy);
  393. if (!m_hThread)
  394. {
  395. TRACE(_T("Draw: Couldn't start a GIF animation threadn"));
  396. return FALSE;
  397. } 
  398. else 
  399. ResumeThread(m_hThread);
  400. } 
  401. else
  402. {
  403. if (m_pPicture)
  404. {
  405. long hmWidth;
  406. long hmHeight;
  407. m_pPicture->get_Width(&hmWidth);
  408. m_pPicture->get_Height(&hmHeight);
  409. if (m_pPicture->Render(m_hMemDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy, 
  410. 0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  411. {
  412. Invalidate(FALSE);
  413. return TRUE;
  414. };
  415. };
  416. };
  418. return FALSE;
  419. }
  421. SIZE CPictureEx::GetSize() const
  422. {
  423. return m_PictureSize;
  424. }
  426. BOOL CPictureEx::Load(LPCTSTR szFileName)
  427. {
  428. ASSERT(szFileName);
  430. CFile file;
  431. HGLOBAL hGlobal;
  432. DWORD dwSize;
  434. if (!file.Open(szFileName,
  435. CFile::modeRead | 
  436. CFile::shareDenyWrite) )
  437. {
  438. TRACE(_T("Load (file): Error opening file %sn"),szFileName);
  439. return FALSE;
  440. };
  442. dwSize = file.GetLength();
  443. hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  444. if (!hGlobal)
  445. {
  446. TRACE(_T("Load (file): Error allocating memoryn"));
  447. return FALSE;
  448. };
  450. char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal));
  451. if (!pData)
  452. {
  453. TRACE(_T("Load (file): Error locking memoryn"));
  454. GlobalFree(hGlobal);
  455. return FALSE;
  456. };
  458. TRY
  459. {
  460. file.Read(pData,dwSize);
  461. }
  462. CATCH(CFileException, e);                                          
  463. {
  464. TRACE(_T("Load (file): An exception occured while reading the file %sn"),
  465. szFileName);
  466. GlobalFree(hGlobal);
  467. //e->Delete();   // DO NOT CALL THIS, CAN CAUSE CRASH.  majun, 7.31
  468. file.Close();
  469. return FALSE;
  470. }
  471. END_CATCH
  472. GlobalUnlock(hGlobal);
  473. file.Close();
  475. BOOL bRetValue = Load(hGlobal,dwSize);
  476. GlobalFree(hGlobal);
  477. return bRetValue;
  478. }
  480. BOOL CPictureEx::Load(LPCTSTR szResourceName, LPCTSTR szResourceType)
  481. {
  482. ASSERT(szResourceName);
  483. ASSERT(szResourceType);
  485. HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,szResourceType);
  486. HGLOBAL hResData;
  487. if (!hPicture || !(hResData = LoadResource(AfxGetResourceHandle(),hPicture)))
  488. {
  489. TRACE(_T("Load (resource): Error loading resource %sn"),szResourceName);
  490. return FALSE;
  491. };
  492. DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);
  494. // hResData is not the real HGLOBAL (we can't lock it)
  495. // let's make it real
  497. HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  498. if (!hGlobal)
  499. {
  500. TRACE("Load (resource): Error allocating memoryn");
  501. FreeResource(hResData);
  502. return FALSE;
  503. };
  505. char *pDest = reinterpret_cast<char *> (GlobalLock(hGlobal));
  506. char *pSrc = reinterpret_cast<char *> (LockResource(hResData));
  507. if (!pSrc || !pDest)
  508. {
  509. TRACE(_T("Load (resource): Error locking memoryn"));
  510. GlobalFree(hGlobal);
  511. FreeResource(hResData);
  512. return FALSE;
  513. };
  514. CopyMemory(pDest,pSrc,dwSize);
  515. FreeResource(hResData);
  516. GlobalUnlock(hGlobal);
  518. BOOL bRetValue = Load(hGlobal,dwSize);
  519. GlobalFree(hGlobal);
  520. return bRetValue;
  521. }
  523. void CPictureEx::ResetDataPointer()
  524. {
  525. // skip header and logical screen descriptor
  526. m_nCurrOffset = 
  527. sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  528. }
  530. BOOL CPictureEx::SkipNextGraphicBlock()
  531. {
  532. if (!m_pRawData) return FALSE;
  534. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  536. enum GIFBlockTypes nBlock;
  538. nBlock = GetNextBlock();
  540. while ((nBlock != BLOCK_CONTROLEXT) &&
  541.    (nBlock != BLOCK_IMAGE) &&
  542.    (nBlock != BLOCK_PLAINTEXT) &&
  543.    (nBlock != BLOCK_UNKNOWN) &&
  544.    (nBlock != BLOCK_TRAILER) )
  545. {
  546. if (!SkipNextBlock()) return NULL;
  547. nBlock = GetNextBlock();
  548. };
  550. if ((nBlock == BLOCK_UNKNOWN) ||
  551. (nBlock == BLOCK_TRAILER))
  552. return FALSE;
  554. // it's either a control ext.block, an image or a plain text
  556. if (GetNextBlockLen() <= 0) return FALSE;
  558. if (nBlock == BLOCK_CONTROLEXT)
  559. {
  560. if (!SkipNextBlock()) return FALSE;
  561. nBlock = GetNextBlock();
  563. // skip everything until we meet an image block or a plain-text block
  564. while ((nBlock != BLOCK_IMAGE) &&
  565.    (nBlock != BLOCK_PLAINTEXT) &&
  566.    (nBlock != BLOCK_UNKNOWN) &&
  567.    (nBlock != BLOCK_TRAILER) )
  568. {
  569. if (!SkipNextBlock()) return NULL;
  570. nBlock = GetNextBlock();
  571. };
  573. if ((nBlock == BLOCK_UNKNOWN) ||
  574. (nBlock == BLOCK_TRAILER))
  575. return FALSE;
  576. };
  578. // skip the found data block (image or plain-text)
  579. if (!SkipNextBlock()) return FALSE;
  581. return TRUE;
  582. }
  584. UINT CPictureEx::GetSubBlocksLen(UINT nStartingOffset) const
  585. {
  586. UINT nRet = 0;
  587. UINT nCurOffset = nStartingOffset;
  589. while (m_pRawData[nCurOffset] != 0)
  590. {
  591. nRet += m_pRawData[nCurOffset]+1;
  592. nCurOffset += m_pRawData[nCurOffset]+1;
  593. };
  595. return nRet+1;
  596. }
  598. enum CPictureEx::GIFBlockTypes CPictureEx::GetNextBlock() const
  599. {
  600. switch(m_pRawData[m_nCurrOffset])
  601. {
  602. case 0x21:
  603. // extension block
  604. switch(m_pRawData[m_nCurrOffset+1])
  605. {
  606. case 0x01:
  607. // plain text extension
  608. return BLOCK_PLAINTEXT;
  609. break;
  611. case 0xF9:
  612. // graphic control extension
  613. return BLOCK_CONTROLEXT;
  614. break;
  616. case 0xFE:
  617. // comment extension
  618. return BLOCK_COMMEXT;
  619. break;
  621. case 0xFF:
  622. // application extension
  623. return BLOCK_APPEXT;
  624. break;
  625. };
  626. break;
  628. case 0x3B:
  629. // trailer
  630. return BLOCK_TRAILER;
  631. break;
  633. case 0x2C:
  634. // image data
  635. return BLOCK_IMAGE;
  636. break;
  637. };
  639. return BLOCK_UNKNOWN;
  640. }
  642. BOOL CPictureEx::SkipNextBlock()
  643. {
  644. if (!m_pRawData) return FALSE;
  646. int nLen = GetNextBlockLen();
  647. if ((nLen <= 0) || ((m_nCurrOffset+nLen) > m_nDataSize))
  648. return FALSE;
  650. m_nCurrOffset += nLen;
  651. return TRUE;
  652. }
  654. int CPictureEx::GetNextBlockLen() const
  655. {
  656. GIFBlockTypes nBlock = GetNextBlock();
  658. int nTmp;
  660. switch(nBlock)
  661. {
  662. case BLOCK_UNKNOWN:
  663. return -1;
  664. break;
  666. case BLOCK_TRAILER:
  667. return 1;
  668. break;
  670. case BLOCK_APPEXT:
  671. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFAppExtension));
  672. if (nTmp > 0)
  673. return sizeof(TGIFAppExtension)+nTmp;
  674. break;
  676. case BLOCK_COMMEXT:
  677. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFCommentExt));
  678. if (nTmp > 0)
  679. return sizeof(TGIFCommentExt)+nTmp;
  680. break;
  682. case BLOCK_CONTROLEXT:
  683. return sizeof(TGIFControlExt);
  684. break;
  686. case BLOCK_PLAINTEXT:
  687. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFPlainTextExt));
  688. if (nTmp > 0)
  689. return sizeof(TGIFPlainTextExt)+nTmp;
  690. break;
  692. case BLOCK_IMAGE:
  693. TGIFImageDescriptor *pIDescr = 
  694. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  695. int nLCTSize = (int)
  696. (pIDescr->GetPackedValue(ID_PACKED_LOCALCT)*3*
  697. pow(2,pIDescr->GetPackedValue(ID_PACKED_LOCALCTSIZE)+1));
  699. int nTmp = GetSubBlocksLen(m_nCurrOffset+
  700. sizeof(TGIFImageDescriptor) + nLCTSize + 1);
  701. if (nTmp > 0)
  702. return sizeof(TGIFImageDescriptor) + nLCTSize + 1 + nTmp;
  703. break;
  704. };
  706. return 0;
  707. }
  709. UINT WINAPI CPictureEx::_ThreadAnimation(LPVOID pParam)
  710. {
  711. ASSERT(pParam);
  712. CPictureEx *pPic = reinterpret_cast<CPictureEx *> (pParam);
  713. pPic->ThreadAnimation();
  715. // this thread has finished its work so we close the handle
  716. CloseHandle(pPic->m_hThread); 
  717. // and init the handle to zero (so that Stop() doesn't Wait on it)
  718. pPic->m_hThread = 0;
  719. return 0;
  720. }
  722. void CPictureEx::ThreadAnimation()
  723. {
  724. int nTemp = 0;
  725. while (!m_bExitThread)
  726. {
  727. if (m_arrFrames[nTemp].m_pPicture)
  728. {
  729. ///////////////////////////////////////////////////////
  730. // Before rendering a frame we should take care of what's 
  731. // behind that frame. TFrame::m_nDisposal will be our guide:
  732. //   0 - no disposal specified (do nothing)
  733. //   1 - do not dispose (again, do nothing)
  734. //   2 - restore to background color (m_clrBackground)
  735. //   3 - restore to previous
  737. //////// disposal method #3
  738. HDC hMemDC = NULL;
  739. HBITMAP hMemBM = NULL, hOldBM;
  741. if (m_arrFrames[nTemp].m_nDisposal == 3)
  742. {
  743. // prepare a memory DC and store the background in it
  744. hMemDC = CreateCompatibleDC(m_hMemDC);
  745. hMemBM = CreateCompatibleBitmap(m_hMemDC,
  746. m_arrFrames[nTemp].m_frameSize.cx,
  747. m_arrFrames[nTemp].m_frameSize.cy);
  749. if (hMemDC && hMemBM)
  750. {
  751. hOldBM = reinterpret_cast<HBITMAP> (SelectObject(hMemDC,hMemBM));
  752. BitBlt(hMemDC,0,0,
  753. m_arrFrames[nTemp].m_frameSize.cx,
  754. m_arrFrames[nTemp].m_frameSize.cy,
  755. m_hMemDC,
  756. m_arrFrames[nTemp].m_frameOffset.cx,
  757. m_arrFrames[nTemp].m_frameOffset.cy,
  758. SRCCOPY);
  759. };
  760. };
  761. ///////////////////////
  763. long hmWidth;
  764. long hmHeight;
  765. m_arrFrames[nTemp].m_pPicture->get_Width(&hmWidth);
  766. m_arrFrames[nTemp].m_pPicture->get_Height(&hmHeight);
  768. if (m_arrFrames[nTemp].m_pPicture->Render(m_hMemDC, 
  769. m_arrFrames[nTemp].m_frameOffset.cx, 
  770. m_arrFrames[nTemp].m_frameOffset.cy, 
  771. m_arrFrames[nTemp].m_frameSize.cx, 
  772. m_arrFrames[nTemp].m_frameSize.cy, 
  773. 0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  774. {
  775. Invalidate(FALSE);
  776. };
  778. if (m_bExitThread)
  779. {
  780. if (hMemDC)
  781. {
  782. // dispose local variables
  783. SelectObject(hMemDC,hOldBM);
  784. DeleteDC(hMemDC);
  785. DeleteObject(hMemBM);
  786. };
  787. break;
  788. };
  790. // if the delay time is too short (like in old GIFs), wait for 100ms
  791. if (m_arrFrames[nTemp].m_nDelay < 5) 
  792. WaitForSingleObject(m_hExitEvent, 100);
  793. else
  794. WaitForSingleObject(m_hExitEvent, 10*m_arrFrames[nTemp].m_nDelay);
  796. if (m_bExitThread)
  797. {
  798. if (hMemDC)
  799. {
  800. // dispose local variables
  801. SelectObject(hMemDC,hOldBM);
  802. DeleteDC(hMemDC);
  803. DeleteObject(hMemBM);
  804. };
  805. break;
  806. };
  808. // disposal method #2
  809. if (m_arrFrames[nTemp].m_nDisposal == 2)
  810. {
  811. HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  812. if (hBrush)
  813. {
  814. RECT rect = {
  815. m_arrFrames[nTemp].m_frameOffset.cx,
  816. m_arrFrames[nTemp].m_frameOffset.cy,
  817. m_arrFrames[nTemp].m_frameOffset.cx + m_arrFrames[nTemp].m_frameSize.cx,
  818. m_arrFrames[nTemp].m_frameOffset.cy + m_arrFrames[nTemp].m_frameSize.cy };
  819. FillRect(m_hMemDC,&rect,hBrush);
  820. DeleteObject(hBrush);
  821. };
  822. } 
  823. else
  824. if (hMemDC && (m_arrFrames[nTemp].m_nDisposal == 3) )
  825. {
  826. // put it back
  827. BitBlt(m_hMemDC,
  828. m_arrFrames[nTemp].m_frameOffset.cx,
  829. m_arrFrames[nTemp].m_frameOffset.cy,
  830. m_arrFrames[nTemp].m_frameSize.cx,
  831. m_arrFrames[nTemp].m_frameSize.cy,
  832. hMemDC,0,0, SRCCOPY);
  833. // dispose local variables
  834. SelectObject(hMemDC,hOldBM);
  835. DeleteDC(hMemDC);
  836. DeleteObject(hMemBM);
  837. };
  838. };
  839. nTemp++;
  840. if (nTemp == m_arrFrames.size())
  841. {
  842. nTemp = 0; 
  843. // init the screen for the first frame,
  844. HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  845. if (hBrush)
  846. {
  847. RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  848. FillRect(m_hMemDC,&rect,hBrush);
  849. DeleteObject(hBrush);
  850. };
  851. };
  852. };
  853. }
  855. void CPictureEx::Stop()
  856. {
  857. m_bExitThread = TRUE;
  858. SetEvent(m_hExitEvent);
  859. if (m_hThread)
  860. {
  861. // we'll wait for 5 seconds then continue execution
  862. WaitForSingleObject(m_hThread,5000);
  863. CloseHandle(m_hThread);
  864. m_hThread = NULL;
  865. }
  867. // make it possible to Draw() again
  868. ResetEvent(m_hExitEvent);
  869. m_bExitThread = FALSE;
  870. }
  872. HGLOBAL CPictureEx::GetNextGraphicBlock(UINT *pBlockLen, 
  873. UINT *pDelay, SIZE *pBlockSize, SIZE *pBlockOffset, 
  874. UINT *pDisposal)
  875. {
  876. if (!m_pRawData) return NULL;
  878. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  880. *pDisposal = 0;
  881. enum GIFBlockTypes nBlock;
  882. nBlock = GetNextBlock();
  884. while (
  885. (nBlock != BLOCK_CONTROLEXT) &&
  886. (nBlock != BLOCK_IMAGE) &&
  887. (nBlock != BLOCK_PLAINTEXT) &&
  888. (nBlock != BLOCK_UNKNOWN) &&
  889. (nBlock != BLOCK_TRAILER)
  890. )
  891. {
  892. if (!SkipNextBlock()) return NULL;
  893. nBlock = GetNextBlock();
  894. };
  896. if ((nBlock == BLOCK_UNKNOWN) ||
  897. (nBlock == BLOCK_TRAILER))
  898. return NULL;
  900. // it's either a control ext.block, an image or a plain text
  902. int nStart = m_nCurrOffset;
  903. int nBlockLen = GetNextBlockLen();
  905. if (nBlockLen <= 0) return NULL;
  907. if (nBlock == BLOCK_CONTROLEXT)
  908. {
  909. // get the following data
  910. TGIFControlExt *pControl = 
  911. reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  912. // store delay time
  913. *pDelay = pControl->m_wDelayTime;
  914. // store disposal method
  915. *pDisposal = pControl->GetPackedValue(GCX_PACKED_DISPOSAL);
  917. if (!SkipNextBlock()) return NULL;
  918. nBlock = GetNextBlock();
  920. // skip everything until we find data to display 
  921. // (image block or plain-text block)
  923. while (
  924. (nBlock != BLOCK_IMAGE) &&
  925. (nBlock != BLOCK_PLAINTEXT) &&
  926. (nBlock != BLOCK_UNKNOWN) &&
  927. (nBlock != BLOCK_TRAILER)
  928. )
  929. {
  930. if (!SkipNextBlock()) return NULL;
  931. nBlock = GetNextBlock();
  932. nBlockLen += GetNextBlockLen();
  933. };
  935. if ((nBlock == BLOCK_UNKNOWN) || (nBlock == BLOCK_TRAILER))
  936. return NULL;
  937. nBlockLen += GetNextBlockLen();
  938. }
  939. else
  940. *pDelay = -1; // to indicate that there was no delay value
  942. if (nBlock == BLOCK_IMAGE)
  943. {
  944. // store size and offsets
  945. TGIFImageDescriptor *pImage = 
  946. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  947. pBlockSize->cx = pImage->m_wWidth;
  948. pBlockSize->cy = pImage->m_wHeight;
  949. pBlockOffset->cx = pImage->m_wLeftPos;
  950. pBlockOffset->cy = pImage->m_wTopPos;
  951. };
  953. if (!SkipNextBlock()) return NULL;
  955. HGLOBAL hGlobal = GlobalAlloc(GMEM_FIXED,
  956. sizeof(TGIFHeader) +
  957. sizeof(TGIFLSDescriptor) +
  958. m_nGlobalCTSize +
  959. nBlockLen + 
  960. 1);  // for the trailer
  962. if (!hGlobal) return NULL;
  964. int nOffset = 0; 
  966. // GMEM_FIXED means we get a pointer
  967. unsigned char *pGlobal = reinterpret_cast<unsigned char *> (hGlobal);
  969. CopyMemory(pGlobal,m_pRawData, 
  970. sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize);
  971. nOffset += sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  973. CopyMemory(pGlobal + nOffset,&m_pRawData[nStart], nBlockLen);
  974. nOffset += nBlockLen;
  976. pGlobal[nOffset] = 0x3B; // trailer
  977. nOffset++;
  979. *pBlockLen = nOffset;
  981. return hGlobal;
  982. }
  984. BOOL CPictureEx::IsGIF() const
  985. {
  986. return m_bIsGIF;
  987. }
  989. BOOL CPictureEx::IsAnimatedGIF() const
  990. {
  991. return (m_bIsGIF && (m_arrFrames.size() > 1));
  992. }
  994. int CPictureEx::GetFrameCount() const
  995. {
  996. if (!IsAnimatedGIF())
  997. return 0;
  999. return m_arrFrames.size();
  1000. }
  1002. COLORREF CPictureEx::GetBkColor() const
  1003. {
  1004. return m_clrBackground;
  1005. }
  1007. void CPictureEx::OnPaint() 
  1008. {
  1009. CPaintDC dc(this); // device context for painting
  1011. ::BitBlt(dc.m_hDC,0,0,m_PictureSize.cx,m_PictureSize.cy,
  1012. m_hMemDC,0,0,SRCCOPY);
  1013. }
  1015. BOOL CPictureEx::PrepareDC(int nWidth, int nHeight)
  1016. {
  1017. SetWindowPos(NULL,0,0,nWidth,nHeight,SWP_NOMOVE | SWP_NOZORDER);
  1019. HDC hWinDC = ::GetDC(m_hWnd);
  1020. if (!hWinDC) return FALSE;
  1022. m_hMemDC = CreateCompatibleDC(hWinDC);
  1023. if (!m_hMemDC) 
  1024. {
  1025. ::ReleaseDC(m_hWnd,hWinDC);
  1026. return FALSE;
  1027. };
  1029. m_hBitmap  = CreateCompatibleBitmap(hWinDC,nWidth,nHeight);
  1030. if (!m_hBitmap) 
  1031. {
  1032. ::ReleaseDC(m_hWnd,hWinDC);
  1033. ::DeleteDC(m_hMemDC);
  1034. return FALSE;
  1035. };
  1037. m_hOldBitmap = reinterpret_cast<HBITMAP> 
  1038. (SelectObject(m_hMemDC,m_hBitmap));
  1040. // fill the background
  1041. m_clrBackground = GetSysColor(COLOR_3DFACE);
  1042. RECT rect = {0,0,nWidth,nHeight};
  1043. FillRect(m_hMemDC,&rect,(HBRUSH)(COLOR_WINDOW));
  1045. m_bIsInitialized = TRUE;
  1046. return TRUE;
  1047. }
  1049. void CPictureEx::OnDestroy() 
  1050. {
  1051. Stop();
  1052. CStatic::OnDestroy();
  1053. }
  1055. void CPictureEx::SetBkColor(COLORREF clr)
  1056. {
  1057. if (!m_bIsInitialized) return;
  1059. m_clrBackground = clr;
  1061. HBRUSH hBrush = CreateSolidBrush(clr);
  1062. if (hBrush)
  1063. {
  1064. RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  1065. FillRect(m_hMemDC,&rect,hBrush);
  1066. DeleteObject(hBrush);
  1067. };
  1068. }
  1070. #ifdef GIF_TRACING
  1071. void CPictureEx::WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize)
  1072. {
  1073. CFile file;
  1075. if (!file.Open(szFileName,
  1076. CFile::modeCreate |
  1077. CFile::modeWrite |
  1078. CFile::shareDenyNone))
  1079. {
  1080. TRACE(_T("WriteData: Error creating file %sn"),szFileName);
  1081. return;
  1082. };
  1084. char *pData = reinterpret_cast<char *> (GlobalLock(hData));
  1085. if (!pData)
  1086. {
  1087. TRACE(_T("WriteData: Error locking memoryn"));
  1088. return;
  1089. };
  1091. TRY
  1092. {
  1093. file.Write(pData,dwSize);
  1094. }
  1095. CATCH(CFileException, e);                                          
  1096. {
  1097. TRACE(_T("WriteData: An exception occured while writing to the file %sn"),
  1098. szFileName);
  1099. //e->Delete();   // DO NOT CALL THIS, CAN CAUSE CRASH.  majun, 7.31
  1100. GlobalUnlock(hData);
  1101. file.Close();
  1102. return;
  1103. }
  1104. END_CATCH
  1106. GlobalUnlock(hData);
  1107. file.Close();
  1108. }
  1110. void CPictureEx::EnumGIFBlocks()
  1111. {
  1112. enum GIFBlockTypes nBlock;
  1114. ResetDataPointer();
  1115. while(m_nCurrOffset < m_nDataSize)
  1116. {
  1117. nBlock = GetNextBlock();
  1118. switch(nBlock)
  1119. {
  1120. case BLOCK_UNKNOWN:
  1121. TRACE(_T("- Unknown blockn"));
  1122. return;
  1123. break;
  1125. case BLOCK_TRAILER:
  1126. TRACE(_T("- Trailer blockn"));
  1127. break;
  1129. case BLOCK_APPEXT:
  1130. TRACE(_T("- Application extension blockn"));
  1131. break;
  1133. case BLOCK_COMMEXT:
  1134. TRACE(_T("- Comment extension blockn"));
  1135. break;
  1137. case BLOCK_CONTROLEXT:
  1138. {
  1139. TGIFControlExt *pControl = 
  1140. reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  1141. TRACE(_T("- Graphic control extension block (delay %d, disposal %d)n"),
  1142. pControl->m_wDelayTime, pControl->GetPackedValue(GCX_PACKED_DISPOSAL));
  1143. };
  1144. break;
  1146. case BLOCK_PLAINTEXT:
  1147. TRACE(_T("- Plain text extension blockn"));
  1148. break;
  1150. case BLOCK_IMAGE:
  1151. TGIFImageDescriptor *pIDescr = 
  1152. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  1153. TRACE(_T("- Image data block (%dx%d  %d,%d)n"),
  1154. pIDescr->m_wWidth,
  1155. pIDescr->m_wHeight,
  1156. pIDescr->m_wLeftPos,
  1157. pIDescr->m_wTopPos);
  1158. break;
  1159. };
  1161. SkipNextBlock();
  1162. };
  1164. TRACE(_T("n"));
  1165. }
  1166. #endif // GIF_TRACING