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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
PictureEx.cpp
资源名称：1731.rar　[点击查看]
上传用户：swkcbjrc
上传日期：2016-04-02
资源大小：45277k
文件大小：33k
源码类别：

游戏

开发平台：

Visual C++

PictureEx.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. // PictureEx.cpp: implementation of the CPictureEx 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. // Copyright (c) 2001
  9. //
  10. // To use CPictureEx, follow these steps:
  11. //   - place a static control on your dialog (either a text or a bitmap)
  12. //   - change its identifier to something else (e.g. IDC_MYPIC)
  13. //   - associate a CStatic with it using ClassWizard
  14. //   - in your dialog's header file replace CStatic with CPictureEx
  15. //     (don't forget to #include "PictureEx.h" and add 
  16. //     PictureEx.h and PictureEx.cpp to your project)
  17. //   - call one of the overloaded CPictureEx::Load() functions somewhere
  18. //     (OnInitDialog is a good place to start)
  19. //   - if the preceding Load() succeeded call Draw()
  20. //  
  21. // You can also add the control by defining a member variable of type 
  22. // CPictureEx, calling CPictureEx::Create (derived from CStatic), then 
  23. // CPictureEx::Load and CPictureEx::Draw.
  24. //
  25. // By default, the control initializes its background to COLOR_3DFACE
  26. // (see CPictureEx::PrepareDC()). You can change the background by
  27. // calling CPictureEx::SetBkColor(COLORREF) after CPictureEx::Load().
  28. //
  29. // I decided to leave in the class the functions to write separate frames from 
  30. // animated GIF to disk. If you want to use them, uncomment #define GIF_TRACING 
  31. // and an appropriate section in CPictureEx::Load(HGLOBAL, DWORD). These functions 
  32. // won't be compiled and linked to your project unless you uncomment #define GIF_TRACING,
  33. // so you don't have to worry.
  34. // 
  35. // Warning: this code hasn't been subject to a heavy testing, so
  36. // use it on your own risk. The author accepts no liability for the 
  37. // possible damage caused by this code.
  38. //
  39. // Version 1.0  7 Aug 2001
  40. //              Initial release
  41. //
  42. // Version 1.1  6 Sept 2001
  43. //              ATL version of the class
  44. //
  45. // Version 1.2  14 Oct 2001
  46. //              - Fixed a problem with loading GIFs from resources
  47. //                in MFC-version of the class for multi-modules apps.
  48. //                Thanks to Ruben Avila-Carretero for finding this out.
  49. //
  50. //              - Got rid of waitable timer in ThreadAnimation()
  51. //                Now CPictureEx[Wnd] works in Win95 too.
  52. //                Thanks to Alex Egiazarov and Wayne King for the idea.
  53. //
  54. //              - Fixed a visual glitch of using SetBkColor.
  55. //                Thanks to Kwangjin Lee for finding this out.
  56. //
  57. // Version 1.3  10 Nov 2001
  58. //              - Fixed a DC leak. One DC leaked per each UnLoad()
  59. //                (forgot to put a ReleaseDC() in the end of 
  60. //                CPictureExWnd::PrepareDC() function).
  61. //
  62. //              - Now it is possible to set a clipping rectangle using
  63. //                CPictureEx[Wnd]::SetPaintRect(const LPRECT) function.
  64. //                The LPRECT parameter tells the class what portion of
  65. //                a picture should it display. If the clipping rect is 
  66. //                not set, the whole picture is shown.
  67. //                Thanks to Fabrice Rodriguez for the idea.
  68. //
  69. //              - Added support for Stop/Draw. Now you can Stop() an
  70. //                animated GIF, then Draw() it again, it will continue
  71. //                animation from the frame it was stopped on. You can 
  72. //                also know if a GIF is currently playing with the 
  73. //                IsPlaying() function.
  74. //             
  75. //              - Got rid of math.h and made m_bExitThread volatile. 
  76. //                Thanks to Piotr Sawicki for the suggestion.
  77. //
  78. //////////////////////////////////////////////////////////////////////
  80. #include "stdafx.h"
  81. #include "PictureEx.h"
  82. #include <process.h>
  84. #ifdef _DEBUG
  85. #undef THIS_FILE
  86. static char THIS_FILE[]=__FILE__;
  87. #define new DEBUG_NEW
  88. #endif
  90. //////////////////////////////////////////////////////////////////////
  91. // Nested structures member functions
  92. //////////////////////////////////////////////////////////////////////
  94. inline int CPictureEx::TGIFControlExt::GetPackedValue(enum ControlExtValues Value)
  95. {
  96. int nRet = (int)m_cPacked;
  97. switch (Value)
  98. {
  99. case GCX_PACKED_DISPOSAL:
  100. nRet = (nRet & 28) >> 2;
  101. break;
  103. case GCX_PACKED_USERINPUT:
  104. nRet = (nRet & 2) >> 1;
  105. break;
  107. case GCX_PACKED_TRANSPCOLOR:
  108. nRet &= 1;
  109. break;
  110. };
  112. return nRet;
  113. }
  115. inline int CPictureEx::TGIFLSDescriptor::GetPackedValue(enum LSDPackedValues Value)
  116. {
  117. int nRet = (int)m_cPacked;
  119. switch (Value)
  120. {
  121. case LSD_PACKED_GLOBALCT:
  122. nRet = nRet >> 7;
  123. break;
  125. case LSD_PACKED_CRESOLUTION:
  126. nRet = ((nRet & 0x70) >> 4) + 1;
  127. break;
  129. case LSD_PACKED_SORT:
  130. nRet = (nRet & 8) >> 3;
  131. break;
  133. case LSD_PACKED_GLOBALCTSIZE:
  134. nRet &= 7;
  135. break;
  136. };
  138. return nRet;
  139. }
  141. inline int CPictureEx::TGIFImageDescriptor::GetPackedValue(enum IDPackedValues Value)
  142. {
  143. int nRet = (int)m_cPacked;
  145. switch (Value)
  146. {
  147. case ID_PACKED_LOCALCT:
  148. nRet >>= 7;
  149. break;
  151. case ID_PACKED_INTERLACE:
  152. nRet = ((nRet & 0x40) >> 6);
  153. break;
  155. case ID_PACKED_SORT:
  156. nRet = (nRet & 0x20) >> 5;
  157. break;
  159. case ID_PACKED_LOCALCTSIZE:
  160. nRet &= 7;
  161. break;
  162. };
  164. return nRet;
  165. }
  168. //////////////////////////////////////////////////////////////////////
  169. // Construction/Destruction
  170. //////////////////////////////////////////////////////////////////////
  172. CPictureEx::CPictureEx()
  173. {
  174. // check structures size
  175. ASSERT(sizeof(TGIFImageDescriptor) == 10);
  176. ASSERT(sizeof(TGIFAppExtension)    == 14);
  177. ASSERT(sizeof(TGIFPlainTextExt)    == 15);
  178. ASSERT(sizeof(TGIFLSDescriptor)    ==  7);
  179. ASSERT(sizeof(TGIFControlExt)    ==  8);
  180. ASSERT(sizeof(TGIFCommentExt)    ==  2);
  181. ASSERT(sizeof(TGIFHeader)    ==  6);
  183. m_pGIFLSDescriptor = NULL;
  184. m_pGIFHeader    = NULL;
  185. m_pPicture    = NULL;
  186. m_pRawData    = NULL;
  187. m_hThread    = NULL;
  188. m_hBitmap          = NULL;
  189. m_hMemDC    = NULL;
  191. m_hDispMemDC       = NULL;
  192. m_hDispMemBM       = NULL;
  193. m_hDispOldBM       = NULL;
  195. m_bIsInitialized   = FALSE;
  196. m_bExitThread    = FALSE;
  197. m_bIsPlaying       = FALSE;
  198. m_bIsGIF    = FALSE;
  199. m_clrBackground    = RGB(255,255,255); // white by default
  200. m_nGlobalCTSize    = 0;
  201. m_nCurrOffset    = 0;
  202. m_nCurrFrame    = 0;
  203. m_nDataSize    = 0;
  204. m_PictureSize.cx = m_PictureSize.cy = 0;
  205. SetRect(&m_PaintRect,0,0,0,0);
  207. m_hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  208. }
  210. CPictureEx::~CPictureEx()
  211. {
  212. UnLoad();
  213. CloseHandle(m_hExitEvent);
  214. }
  216. BEGIN_MESSAGE_MAP(CPictureEx, CStatic)
  217. //{{AFX_MSG_MAP(CPictureEx)
  218. ON_WM_DESTROY()
  219. ON_WM_PAINT()
  220. //}}AFX_MSG_MAP
  221. END_MESSAGE_MAP()
  223. BOOL CPictureEx::Load(HGLOBAL hGlobal, DWORD dwSize)
  224. {
  225. IStream *pStream = NULL;
  226. UnLoad();
  228. if (!(m_pRawData = reinterpret_cast<unsigned char*> (GlobalLock(hGlobal))) )
  229. {
  230. TRACE(_T("Load: Error locking memoryn"));
  231. return FALSE;
  232. };
  234. m_nDataSize = dwSize;
  235. m_pGIFHeader = reinterpret_cast<TGIFHeader *> (m_pRawData);
  237. if ((memcmp(&m_pGIFHeader->m_cSignature,"GIF",3) != 0) &&
  238. ((memcmp(&m_pGIFHeader->m_cVersion,"87a",3) != 0) ||
  239.  (memcmp(&m_pGIFHeader->m_cVersion,"89a",3) != 0)) )
  240. {
  241. // it's neither GIF87a nor GIF89a
  242. // do the default processing
  244. // clear GIF variables
  245. m_pRawData = NULL;
  246. GlobalUnlock(hGlobal);
  248. // don't delete memory on object's release
  249. if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  250. return FALSE;
  252. if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  253. reinterpret_cast<LPVOID *>(&m_pPicture)) != S_OK)
  254. {
  255. pStream->Release();
  256. return FALSE;
  257. };
  258. pStream->Release();
  260. // store picture's size
  262. long hmWidth;
  263. long hmHeight;
  264. m_pPicture->get_Width(&hmWidth);
  265. m_pPicture->get_Height(&hmHeight);
  267. HDC hDC = ::GetDC(m_hWnd);
  268. m_PictureSize.cx = MulDiv(hmWidth, GetDeviceCaps(hDC,LOGPIXELSX), 2540);
  269. m_PictureSize.cy = MulDiv(hmHeight, GetDeviceCaps(hDC,LOGPIXELSY), 2540);
  270. ::ReleaseDC(m_hWnd,hDC);
  271. }
  272. else
  273. {
  274. // it's a GIF
  275. m_bIsGIF = TRUE;
  276. m_pGIFLSDescriptor = reinterpret_cast<TGIFLSDescriptor *>
  277. (m_pRawData + sizeof(TGIFHeader));
  278. if (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT) == 1)
  279. {
  280. // calculate the globat color table size
  281. m_nGlobalCTSize = static_cast<int>
  282. (3* (1 << (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE)+1)));
  283. // get the background color if GCT is present
  284. unsigned char *pBkClr = m_pRawData + sizeof(TGIFHeader) + 
  285. sizeof(TGIFLSDescriptor) + 3*m_pGIFLSDescriptor->m_cBkIndex;
  286. m_clrBackground = RGB(pBkClr[0],pBkClr[1],pBkClr[2]);
  287. };
  289. // store the picture's size
  290. m_PictureSize.cx = m_pGIFLSDescriptor->m_wWidth;
  291. m_PictureSize.cy = m_pGIFLSDescriptor->m_wHeight;
  293. // determine frame count for this picture
  294. UINT nFrameCount=0;
  295. ResetDataPointer();
  296. while (SkipNextGraphicBlock())
  297. nFrameCount++;
  299. #ifdef GIF_TRACING
  300. TRACE(
  301. _T(" -= GIF encounteredn"
  302.    "Logical Screen dimensions = %dx%dn"
  303.    "Global color table = %dn"
  304.    "Color depth = %dn"
  305.    "Sort flag = %dn"
  306.    "Size of Global Color Table = %dn"
  307.    "Background color index = %dn"
  308.    "Pixel aspect ratio = %dn"
  309.    "Frame count = %dn"
  310.    "Background color = %06Xhnn"
  311.   ),
  312. m_pGIFLSDescriptor->m_wWidth,
  313. m_pGIFLSDescriptor->m_wHeight,
  314. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT),
  315. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_CRESOLUTION),
  316. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_SORT),
  317. m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE),
  318. m_pGIFLSDescriptor->m_cBkIndex,
  319. m_pGIFLSDescriptor->m_cPixelAspect,
  320. nFrameCount,
  321. m_clrBackground
  322. );
  323. EnumGIFBlocks();
  324. #endif
  326. if (nFrameCount == 0) // it's an empty GIF!
  327. {
  328. m_pRawData = NULL;
  329. GlobalUnlock(hGlobal);
  330. return FALSE;
  331. };
  333. // now check the frame count
  334. // if there's only one frame, no need to animate this GIF
  335. // therefore, treat it like any other pic
  337. if (nFrameCount == 1)
  338. {
  339. // clear GIF variables
  340. m_pRawData = NULL;
  341. GlobalUnlock(hGlobal);
  343. // don't delete memory on object's release
  344. if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)
  345. return FALSE;
  347. if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,
  348. (LPVOID *)&m_pPicture) != S_OK)
  349. {
  350. pStream->Release();
  351. return FALSE;
  352. };
  354. pStream->Release();
  355. }
  356. else
  357. {
  358. // if, on the contrary, there are several frames
  359. // then store separate frames in an array
  361. TFrame frame;
  362. UINT nBlockLen;
  363. HGLOBAL hFrameData;
  364. UINT nCurFrame = 0;
  366. ResetDataPointer();
  367. while (hFrameData = GetNextGraphicBlock(&nBlockLen,
  368. &frame.m_nDelay, &frame.m_frameSize,
  369. &frame.m_frameOffset, &frame.m_nDisposal) )
  370. {
  371. #ifdef GIF_TRACING
  372. //////////////////////////////////////////////
  373. // uncomment the following strings if you want 
  374. // to write separate frames on disk
  375. //
  376. // CString szName;
  377. // szName.Format(_T("%.4d.gif"),nCurFrame);
  378. // WriteDataOnDisk(szName,hFrameData,nBlockLen);
  379. // nCurFrame++;
  380. #endif // GIF_TRACING
  382. IStream *pStream = NULL;
  384. // delete memory on object's release
  385. if (CreateStreamOnHGlobal(hFrameData,TRUE,&pStream) != S_OK)
  386. {
  387. GlobalFree(hFrameData);
  388. continue;
  389. };
  391. if (OleLoadPicture(pStream,nBlockLen,FALSE,
  392. IID_IPicture,
  393. reinterpret_cast<LPVOID *>(&frame.m_pPicture)) != S_OK)
  394. {
  395. pStream->Release();
  396. continue;
  397. };
  398. pStream->Release();
  400. // everything went well, add this frame
  401. m_arrFrames.push_back(frame);
  402. };
  404. // clean after ourselves
  405. m_pRawData = NULL;
  406. GlobalUnlock(hGlobal);
  408. if (m_arrFrames.empty()) // couldn't load any frames
  409. return FALSE;
  410. };
  411. }; // if (!IsGIF...
  413. return PrepareDC(m_PictureSize.cx,m_PictureSize.cy);
  414. }
  416. void CPictureEx::UnLoad()
  417. {
  418. Stop();
  419. if (m_pPicture)
  420. {
  421. m_pPicture->Release();
  422. m_pPicture = NULL;
  423. };
  425. std::vector<TFrame>::iterator it;
  426. for (it=m_arrFrames.begin();it<m_arrFrames.end();it++)
  427. (*it).m_pPicture->Release();
  428. m_arrFrames.clear();
  430. if (m_hMemDC)
  431. {
  432. SelectObject(m_hMemDC,m_hOldBitmap);
  433. ::DeleteDC(m_hMemDC);
  434. ::DeleteObject(m_hBitmap);
  435. m_hMemDC  = NULL;
  436. m_hBitmap = NULL;
  437. };
  439. if (m_hDispMemDC)
  440. {
  441. SelectObject(m_hDispMemDC,m_hDispOldBM);
  442. ::DeleteDC(m_hDispMemDC);
  443. ::DeleteObject(m_hDispMemBM);
  444. m_hDispMemDC  = NULL;
  445. m_hDispMemBM = NULL;
  446. };
  448. SetRect(&m_PaintRect,0,0,0,0);
  449. m_pGIFLSDescriptor = NULL;
  450. m_pGIFHeader    = NULL;
  451. m_pRawData    = NULL;
  452. m_hThread    = NULL;
  453. m_bIsInitialized   = FALSE;
  454. m_bExitThread    = FALSE;
  455. m_bIsGIF    = FALSE;
  456. m_clrBackground    = RGB(255,255,255); // white by default
  457. m_nGlobalCTSize    = 0;
  458. m_nCurrOffset    = 0;
  459. m_nCurrFrame    = 0;
  460. m_nDataSize    = 0;
  461. }
  463. BOOL CPictureEx::Draw()
  464. {
  465. if (!m_bIsInitialized)
  466. {
  467. TRACE(_T("Call one of the CPictureEx::Load() member functions before calling Draw()n"));
  468. return FALSE;
  469. };
  471. if (IsAnimatedGIF())
  472. {
  473. // the picture needs animation
  474. // we'll start the thread that will handle it for us
  476. unsigned int nDummy;
  477. m_hThread = (HANDLE) _beginthreadex(NULL,0,_ThreadAnimation,this,
  478. CREATE_SUSPENDED,&nDummy);
  479. if (!m_hThread)
  480. {
  481. TRACE(_T("Draw: Couldn't start a GIF animation threadn"));
  482. return FALSE;
  483. } 
  484. else 
  485. ResumeThread(m_hThread);
  486. } 
  487. else
  488. {
  489. if (m_pPicture)
  490. {
  491. long hmWidth;
  492. long hmHeight;
  493. m_pPicture->get_Width(&hmWidth);
  494. m_pPicture->get_Height(&hmHeight);
  495. if (m_pPicture->Render(m_hMemDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy, 
  496. 0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  497. {
  498. Invalidate(FALSE);
  499. return TRUE;
  500. };
  501. };
  502. };
  504. return FALSE;
  505. }
  507. SIZE CPictureEx::GetSize() const
  508. {
  509. return m_PictureSize;
  510. }
  512. BOOL CPictureEx::Load(LPCTSTR szFileName)
  513. {
  514. ASSERT(szFileName);
  516. CFile file;
  517. HGLOBAL hGlobal;
  518. DWORD dwSize;
  520. if (!file.Open(szFileName,
  521. CFile::modeRead | 
  522. CFile::shareDenyWrite) )
  523. {
  524. TRACE(_T("Load (file): Error opening file %sn"),szFileName);
  525. return FALSE;
  526. };
  528. dwSize = file.GetLength();
  529. hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  530. if (!hGlobal)
  531. {
  532. TRACE(_T("Load (file): Error allocating memoryn"));
  533. return FALSE;
  534. };
  536. char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal));
  537. if (!pData)
  538. {
  539. TRACE(_T("Load (file): Error locking memoryn"));
  540. GlobalFree(hGlobal);
  541. return FALSE;
  542. };
  544. TRY
  545. {
  546. file.Read(pData,dwSize);
  547. }
  548. CATCH(CFileException, e);                                          
  549. {
  550. TRACE(_T("Load (file): An exception occured while reading the file %sn"),
  551. szFileName);
  552. GlobalFree(hGlobal);
  553. e->Delete();
  554. file.Close();
  555. return FALSE;
  556. }
  557. END_CATCH
  558. GlobalUnlock(hGlobal);
  559. file.Close();
  561. BOOL bRetValue = Load(hGlobal,dwSize);
  562. GlobalFree(hGlobal);
  563. return bRetValue;
  564. }
  566. BOOL CPictureEx::Load(LPCTSTR szResourceName, LPCTSTR szResourceType)
  567. {
  568. ASSERT(szResourceName);
  569. ASSERT(szResourceType);
  571. HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,szResourceType);
  572. HGLOBAL hResData;
  573. if (!hPicture || !(hResData = LoadResource(AfxGetResourceHandle(),hPicture)))
  574. {
  575. TRACE(_T("Load (resource): Error loading resource %sn"),szResourceName);
  576. return FALSE;
  577. };
  578. DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);
  580. // hResData is not the real HGLOBAL (we can't lock it)
  581. // let's make it real
  583. HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);
  584. if (!hGlobal)
  585. {
  586. TRACE(_T("Load (resource): Error allocating memoryn"));
  587. FreeResource(hResData);
  588. return FALSE;
  589. };
  591. char *pDest = reinterpret_cast<char *> (GlobalLock(hGlobal));
  592. char *pSrc = reinterpret_cast<char *> (LockResource(hResData));
  593. if (!pSrc || !pDest)
  594. {
  595. TRACE(_T("Load (resource): Error locking memoryn"));
  596. GlobalFree(hGlobal);
  597. FreeResource(hResData);
  598. return FALSE;
  599. };
  600. CopyMemory(pDest,pSrc,dwSize);
  601. FreeResource(hResData);
  602. GlobalUnlock(hGlobal);
  604. BOOL bRetValue = Load(hGlobal,dwSize);
  605. GlobalFree(hGlobal);
  606. return bRetValue;
  607. }
  609. void CPictureEx::ResetDataPointer()
  610. {
  611. // skip header and logical screen descriptor
  612. m_nCurrOffset = 
  613. sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  614. }
  616. BOOL CPictureEx::SkipNextGraphicBlock()
  617. {
  618. if (!m_pRawData) return FALSE;
  620. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  622. enum GIFBlockTypes nBlock;
  624. nBlock = GetNextBlock();
  626. while ((nBlock != BLOCK_CONTROLEXT) &&
  627.    (nBlock != BLOCK_IMAGE) &&
  628.    (nBlock != BLOCK_PLAINTEXT) &&
  629.    (nBlock != BLOCK_UNKNOWN) &&
  630.    (nBlock != BLOCK_TRAILER) )
  631. {
  632. if (!SkipNextBlock()) return NULL;
  633. nBlock = GetNextBlock();
  634. };
  636. if ((nBlock == BLOCK_UNKNOWN) ||
  637. (nBlock == BLOCK_TRAILER))
  638. return FALSE;
  640. // it's either a control ext.block, an image or a plain text
  642. if (GetNextBlockLen() <= 0) return FALSE;
  644. if (nBlock == BLOCK_CONTROLEXT)
  645. {
  646. if (!SkipNextBlock()) return FALSE;
  647. nBlock = GetNextBlock();
  649. // skip everything until we meet an image block or a plain-text block
  650. while ((nBlock != BLOCK_IMAGE) &&
  651.    (nBlock != BLOCK_PLAINTEXT) &&
  652.    (nBlock != BLOCK_UNKNOWN) &&
  653.    (nBlock != BLOCK_TRAILER) )
  654. {
  655. if (!SkipNextBlock()) return NULL;
  656. nBlock = GetNextBlock();
  657. };
  659. if ((nBlock == BLOCK_UNKNOWN) ||
  660. (nBlock == BLOCK_TRAILER))
  661. return FALSE;
  662. };
  664. // skip the found data block (image or plain-text)
  665. if (!SkipNextBlock()) return FALSE;
  667. return TRUE;
  668. }
  670. UINT CPictureEx::GetSubBlocksLen(UINT nStartingOffset) const
  671. {
  672. UINT nRet = 0;
  673. UINT nCurOffset = nStartingOffset;
  675. while (m_pRawData[nCurOffset] != 0)
  676. {
  677. nRet += m_pRawData[nCurOffset]+1;
  678. nCurOffset += m_pRawData[nCurOffset]+1;
  679. };
  681. return nRet+1;
  682. }
  684. enum CPictureEx::GIFBlockTypes CPictureEx::GetNextBlock() const
  685. {
  686. switch(m_pRawData[m_nCurrOffset])
  687. {
  688. case 0x21:
  689. // extension block
  690. switch(m_pRawData[m_nCurrOffset+1])
  691. {
  692. case 0x01:
  693. // plain text extension
  694. return BLOCK_PLAINTEXT;
  695. break;
  697. case 0xF9:
  698. // graphic control extension
  699. return BLOCK_CONTROLEXT;
  700. break;
  702. case 0xFE:
  703. // comment extension
  704. return BLOCK_COMMEXT;
  705. break;
  707. case 0xFF:
  708. // application extension
  709. return BLOCK_APPEXT;
  710. break;
  711. };
  712. break;
  714. case 0x3B:
  715. // trailer
  716. return BLOCK_TRAILER;
  717. break;
  719. case 0x2C:
  720. // image data
  721. return BLOCK_IMAGE;
  722. break;
  723. };
  725. return BLOCK_UNKNOWN;
  726. }
  728. BOOL CPictureEx::SkipNextBlock()
  729. {
  730. if (!m_pRawData) return FALSE;
  732. int nLen = GetNextBlockLen();
  733. if ((nLen <= 0) || ((m_nCurrOffset+nLen) > m_nDataSize))
  734. return FALSE;
  736. m_nCurrOffset += nLen;
  737. return TRUE;
  738. }
  740. int CPictureEx::GetNextBlockLen() const
  741. {
  742. GIFBlockTypes nBlock = GetNextBlock();
  744. int nTmp;
  746. switch(nBlock)
  747. {
  748. case BLOCK_UNKNOWN:
  749. return -1;
  750. break;
  752. case BLOCK_TRAILER:
  753. return 1;
  754. break;
  756. case BLOCK_APPEXT:
  757. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFAppExtension));
  758. if (nTmp > 0)
  759. return sizeof(TGIFAppExtension)+nTmp;
  760. break;
  762. case BLOCK_COMMEXT:
  763. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFCommentExt));
  764. if (nTmp > 0)
  765. return sizeof(TGIFCommentExt)+nTmp;
  766. break;
  768. case BLOCK_CONTROLEXT:
  769. return sizeof(TGIFControlExt);
  770. break;
  772. case BLOCK_PLAINTEXT:
  773. nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFPlainTextExt));
  774. if (nTmp > 0)
  775. return sizeof(TGIFPlainTextExt)+nTmp;
  776. break;
  778. case BLOCK_IMAGE:
  779. TGIFImageDescriptor *pIDescr = 
  780. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  781. int nLCTSize = (int)
  782. (pIDescr->GetPackedValue(ID_PACKED_LOCALCT)*3*
  783. (1 << (pIDescr->GetPackedValue(ID_PACKED_LOCALCTSIZE)+1)));
  785. int nTmp = GetSubBlocksLen(m_nCurrOffset+
  786. sizeof(TGIFImageDescriptor) + nLCTSize + 1);
  787. if (nTmp > 0)
  788. return sizeof(TGIFImageDescriptor) + nLCTSize + 1 + nTmp;
  789. break;
  790. };
  792. return 0;
  793. }
  795. UINT WINAPI CPictureEx::_ThreadAnimation(LPVOID pParam)
  796. {
  797. ASSERT(pParam);
  798. CPictureEx *pPic = reinterpret_cast<CPictureEx *> (pParam);
  800. pPic->m_bIsPlaying = TRUE;
  801. pPic->ThreadAnimation();
  802. pPic->m_bIsPlaying = FALSE;
  804. // this thread has finished its work so we close the handle
  805. CloseHandle(pPic->m_hThread); 
  806. // and init the handle to zero (so that Stop() doesn't Wait on it)
  807. pPic->m_hThread = 0;
  808. return 0;
  809. }
  811. void CPictureEx::ThreadAnimation()
  812. {
  813. // first, restore background (for stop/draw support)
  814. // disposal method #2
  815. if (m_arrFrames[m_nCurrFrame].m_nDisposal == 2)
  816. {
  817. HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  818. if (hBrush)
  819. {
  820. RECT rect = {
  821. m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  822. m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  823. m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  824. m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };
  825. FillRect(m_hMemDC,&rect,hBrush);
  826. DeleteObject(hBrush);
  827. };
  828. } 
  829. else
  830. // disposal method #3
  831. if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == 3) )
  832. {
  833. // put it back
  834. BitBlt(m_hMemDC,
  835. m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  836. m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  837. m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  838. m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  839. m_hDispMemDC,0,0, SRCCOPY);
  840. // init variables
  841. SelectObject(m_hDispMemDC,m_hDispOldBM);
  842. DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;
  843. DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;
  844. };
  846. while (!m_bExitThread)
  847. {
  848. if (m_arrFrames[m_nCurrFrame].m_pPicture)
  849. {
  850. ///////////////////////////////////////////////////////
  851. // Before rendering a frame we should take care of what's 
  852. // behind that frame. TFrame::m_nDisposal will be our guide:
  853. //   0 - no disposal specified (do nothing)
  854. //   1 - do not dispose (again, do nothing)
  855. //   2 - restore to background color (m_clrBackground)
  856. //   3 - restore to previous
  858. //////// disposal method #3
  859. if (m_arrFrames[m_nCurrFrame].m_nDisposal == 3)
  860. {
  861. // prepare a memory DC and store the background in it
  862. m_hDispMemDC = CreateCompatibleDC(m_hMemDC);
  863. m_hDispMemBM = CreateCompatibleBitmap(m_hMemDC,
  864. m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  865. m_arrFrames[m_nCurrFrame].m_frameSize.cy);
  867. if (m_hDispMemDC && m_hDispMemBM)
  868. {
  869. m_hDispOldBM = reinterpret_cast<HBITMAP> (SelectObject(m_hDispMemDC,m_hDispMemBM));
  870. BitBlt(m_hDispMemDC,0,0,
  871. m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  872. m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  873. m_hMemDC,
  874. m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  875. m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  876. SRCCOPY);
  877. };
  878. };
  879. ///////////////////////
  881. long hmWidth;
  882. long hmHeight;
  883. m_arrFrames[m_nCurrFrame].m_pPicture->get_Width(&hmWidth);
  884. m_arrFrames[m_nCurrFrame].m_pPicture->get_Height(&hmHeight);
  886. if (m_arrFrames[m_nCurrFrame].m_pPicture->Render(m_hMemDC, 
  887. m_arrFrames[m_nCurrFrame].m_frameOffset.cx, 
  888. m_arrFrames[m_nCurrFrame].m_frameOffset.cy, 
  889. m_arrFrames[m_nCurrFrame].m_frameSize.cx, 
  890. m_arrFrames[m_nCurrFrame].m_frameSize.cy, 
  891. 0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
  892. {
  893. Invalidate(FALSE);
  894. };
  896. if (m_bExitThread) break;
  898. // if the delay time is too short (like in old GIFs), wait for 100ms
  899. if (m_arrFrames[m_nCurrFrame].m_nDelay < 5) 
  900. WaitForSingleObject(m_hExitEvent, 100);
  901. else
  902. WaitForSingleObject(m_hExitEvent, 10*m_arrFrames[m_nCurrFrame].m_nDelay);
  904. if (m_bExitThread) break;
  906. // disposal method #2
  907. if (m_arrFrames[m_nCurrFrame].m_nDisposal == 2)
  908. {
  909. HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  910. if (hBrush)
  911. {
  912. RECT rect = {
  913. m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  914. m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  915. m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  916. m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };
  917. FillRect(m_hMemDC,&rect,hBrush);
  918. DeleteObject(hBrush);
  919. };
  920. } 
  921. else
  922. if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == 3) )
  923. {
  924. // put it back
  925. BitBlt(m_hMemDC,
  926. m_arrFrames[m_nCurrFrame].m_frameOffset.cx,
  927. m_arrFrames[m_nCurrFrame].m_frameOffset.cy,
  928. m_arrFrames[m_nCurrFrame].m_frameSize.cx,
  929. m_arrFrames[m_nCurrFrame].m_frameSize.cy,
  930. m_hDispMemDC,0,0, SRCCOPY);
  931. // init variables
  932. SelectObject(m_hDispMemDC,m_hDispOldBM);
  933. DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;
  934. DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;
  935. };
  936. };
  937. m_nCurrFrame++;
  938. if (m_nCurrFrame == m_arrFrames.size())
  939. {
  940. m_nCurrFrame
  941. = 0; 
  942. // init the screen for the first frame,
  943. HBRUSH hBrush = CreateSolidBrush(m_clrBackground);
  944. if (hBrush)
  945. {
  946. RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  947. FillRect(m_hMemDC,&rect,hBrush);
  948. DeleteObject(hBrush);
  949. };
  950. };
  951. };
  952. }
  954. void CPictureEx::Stop()
  955. {
  956. m_bIsPlaying = FALSE;
  957. m_bExitThread = TRUE;
  958. SetEvent(m_hExitEvent);
  959. if (m_hThread)
  960. {
  961. // we'll wait for 5 seconds then continue execution
  962. WaitForSingleObject(m_hThread,5000);
  963. CloseHandle(m_hThread);
  964. m_hThread = NULL;
  965. }
  967. // make it possible to Draw() again
  968. ResetEvent(m_hExitEvent);
  969. m_bExitThread = FALSE;
  970. }
  972. HGLOBAL CPictureEx::GetNextGraphicBlock(UINT *pBlockLen, 
  973. UINT *pDelay, SIZE *pBlockSize, SIZE *pBlockOffset, 
  974. UINT *pDisposal)
  975. {
  976. if (!m_pRawData) return NULL;
  978. // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data
  980. *pDisposal = 0;
  981. enum GIFBlockTypes nBlock;
  982. nBlock = GetNextBlock();
  984. while (
  985. (nBlock != BLOCK_CONTROLEXT) &&
  986. (nBlock != BLOCK_IMAGE) &&
  987. (nBlock != BLOCK_PLAINTEXT) &&
  988. (nBlock != BLOCK_UNKNOWN) &&
  989. (nBlock != BLOCK_TRAILER)
  990. )
  991. {
  992. if (!SkipNextBlock()) return NULL;
  993. nBlock = GetNextBlock();
  994. };
  996. if ((nBlock == BLOCK_UNKNOWN) ||
  997. (nBlock == BLOCK_TRAILER))
  998. return NULL;
  1000. // it's either a control ext.block, an image or a plain text
  1002. int nStart = m_nCurrOffset;
  1003. int nBlockLen = GetNextBlockLen();
  1005. if (nBlockLen <= 0) return NULL;
  1007. if (nBlock == BLOCK_CONTROLEXT)
  1008. {
  1009. // get the following data
  1010. TGIFControlExt *pControl = 
  1011. reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  1012. // store delay time
  1013. *pDelay = pControl->m_wDelayTime;
  1014. // store disposal method
  1015. *pDisposal = pControl->GetPackedValue(GCX_PACKED_DISPOSAL);
  1017. if (!SkipNextBlock()) return NULL;
  1018. nBlock = GetNextBlock();
  1020. // skip everything until we find data to display 
  1021. // (image block or plain-text block)
  1023. while (
  1024. (nBlock != BLOCK_IMAGE) &&
  1025. (nBlock != BLOCK_PLAINTEXT) &&
  1026. (nBlock != BLOCK_UNKNOWN) &&
  1027. (nBlock != BLOCK_TRAILER)
  1028. )
  1029. {
  1030. if (!SkipNextBlock()) return NULL;
  1031. nBlock = GetNextBlock();
  1032. nBlockLen += GetNextBlockLen();
  1033. };
  1035. if ((nBlock == BLOCK_UNKNOWN) || (nBlock == BLOCK_TRAILER))
  1036. return NULL;
  1037. nBlockLen += GetNextBlockLen();
  1038. }
  1039. else
  1040. *pDelay = -1; // to indicate that there was no delay value
  1042. if (nBlock == BLOCK_IMAGE)
  1043. {
  1044. // store size and offsets
  1045. TGIFImageDescriptor *pImage = 
  1046. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  1047. pBlockSize->cx = pImage->m_wWidth;
  1048. pBlockSize->cy = pImage->m_wHeight;
  1049. pBlockOffset->cx = pImage->m_wLeftPos;
  1050. pBlockOffset->cy = pImage->m_wTopPos;
  1051. };
  1053. if (!SkipNextBlock()) return NULL;
  1055. HGLOBAL hGlobal = GlobalAlloc(GMEM_FIXED,
  1056. sizeof(TGIFHeader) +
  1057. sizeof(TGIFLSDescriptor) +
  1058. m_nGlobalCTSize +
  1059. nBlockLen + 
  1060. 1);  // for the trailer
  1062. if (!hGlobal) return NULL;
  1064. int nOffset = 0; 
  1066. // GMEM_FIXED means we get a pointer
  1067. unsigned char *pGlobal = reinterpret_cast<unsigned char *> (hGlobal);
  1069. CopyMemory(pGlobal,m_pRawData, 
  1070. sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize);
  1071. nOffset += sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;
  1073. CopyMemory(pGlobal + nOffset,&m_pRawData[nStart], nBlockLen);
  1074. nOffset += nBlockLen;
  1076. pGlobal[nOffset] = 0x3B; // trailer
  1077. nOffset++;
  1079. *pBlockLen = nOffset;
  1081. return hGlobal;
  1082. }
  1084. BOOL CPictureEx::IsGIF() const
  1085. {
  1086. return m_bIsGIF;
  1087. }
  1089. BOOL CPictureEx::IsAnimatedGIF() const
  1090. {
  1091. return (m_bIsGIF && (m_arrFrames.size() > 1));
  1092. }
  1094. BOOL CPictureEx::IsPlaying() const
  1095. {
  1096. return m_bIsPlaying;
  1097. }
  1099. int CPictureEx::GetFrameCount() const
  1100. {
  1101. if (!IsAnimatedGIF())
  1102. return 0;
  1104. return m_arrFrames.size();
  1105. }
  1107. COLORREF CPictureEx::GetBkColor() const
  1108. {
  1109. return m_clrBackground;
  1110. }
  1112. /* //Old Paint
  1113. void CPictureEx::OnPaint() 
  1114. {
  1115. CPaintDC dc(this); // device context for painting
  1117. LONG nPaintWidth = m_PaintRect.right-m_PaintRect.left;
  1119. if (nPaintWidth > 0)
  1120. {
  1121. LONG nPaintHeight = m_PaintRect.bottom - m_PaintRect.top;
  1122. ::BitBlt(dc.m_hDC, 0, 0, nPaintWidth, nPaintHeight,
  1123. m_hMemDC, m_PaintRect.left, m_PaintRect.top, SRCCOPY);
  1124. }
  1125. else
  1126. {
  1127. ::BitBlt(dc.m_hDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy,
  1128. m_hMemDC, 0, 0, SRCCOPY);
  1129. };
  1130. */
  1132. void CPictureEx::OnPaint() 
  1133. {
  1134. CPaintDC dc(this); // device context for painting
  1136. LONG nPaintWidth = m_PaintRect.right-m_PaintRect.left;
  1138. if (nPaintWidth > 0)
  1139. {
  1140. LONG nPaintHeight = m_PaintRect.bottom - m_PaintRect.top;
  1141. ::BitBlt(dc.m_hDC, m_PaintRect.left, m_PaintRect.top, m_PictureSize.cx, m_PictureSize.cy,
  1142. m_hMemDC, 0, 0, SRCCOPY);
  1143. }
  1144. else
  1145. {
  1146. ::BitBlt(dc.m_hDC, 0, 0, m_PictureSize.cx, m_PictureSize.cy,
  1147. m_hMemDC, 0, 0, SRCCOPY);
  1148. };
  1149. }
  1151. BOOL CPictureEx::PrepareDC(int nWidth, int nHeight)
  1152. {
  1153. SetWindowPos(NULL,0,0,nWidth,nHeight,SWP_NOMOVE | SWP_NOZORDER);
  1155. HDC hWinDC = ::GetDC(m_hWnd);
  1156. if (!hWinDC) return FALSE;
  1158. m_hMemDC = CreateCompatibleDC(hWinDC);
  1159. if (!m_hMemDC) 
  1160. {
  1161. ::ReleaseDC(m_hWnd,hWinDC);
  1162. return FALSE;
  1163. };
  1165. m_hBitmap  = CreateCompatibleBitmap(hWinDC,nWidth,nHeight);
  1166. if (!m_hBitmap) 
  1167. {
  1168. ::ReleaseDC(m_hWnd,hWinDC);
  1169. ::DeleteDC(m_hMemDC);
  1170. return FALSE;
  1171. };
  1173. m_hOldBitmap = reinterpret_cast<HBITMAP> 
  1174. (SelectObject(m_hMemDC,m_hBitmap));
  1176. // fill the background
  1177. m_clrBackground = GetSysColor(COLOR_3DFACE);
  1178. RECT rect = {0,0,nWidth,nHeight};
  1179. FillRect(m_hMemDC,&rect,(HBRUSH)(COLOR_WINDOW));
  1181. ::ReleaseDC(m_hWnd,hWinDC);
  1182. m_bIsInitialized = TRUE;
  1183. return TRUE;
  1184. }
  1186. void CPictureEx::OnDestroy() 
  1187. {
  1188. Stop();
  1189. CStatic::OnDestroy();
  1190. }
  1192. void CPictureEx::SetBkColor(COLORREF clr)
  1193. {
  1194. if (!m_bIsInitialized) return;
  1196. m_clrBackground = clr;
  1198. HBRUSH hBrush = CreateSolidBrush(clr);
  1199. if (hBrush)
  1200. {
  1201. RECT rect = {0,0,m_PictureSize.cx,m_PictureSize.cy};
  1202. FillRect(m_hMemDC,&rect,hBrush);
  1203. DeleteObject(hBrush);
  1204. };
  1205. }
  1207. #ifdef GIF_TRACING
  1208. void CPictureEx::WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize)
  1209. {
  1210. CFile file;
  1212. if (!file.Open(szFileName,
  1213. CFile::modeCreate |
  1214. CFile::modeWrite |
  1215. CFile::shareDenyNone))
  1216. {
  1217. TRACE(_T("WriteData: Error creating file %sn"),szFileName);
  1218. return;
  1219. };
  1221. char *pData = reinterpret_cast<char *> (GlobalLock(hData));
  1222. if (!pData)
  1223. {
  1224. TRACE(_T("WriteData: Error locking memoryn"));
  1225. return;
  1226. };
  1228. TRY
  1229. {
  1230. file.Write(pData,dwSize);
  1231. }
  1232. CATCH(CFileException, e);                                          
  1233. {
  1234. TRACE(_T("WriteData: An exception occured while writing to the file %sn"),
  1235. szFileName);
  1236. e->Delete();
  1237. GlobalUnlock(hData);
  1238. file.Close();
  1239. return;
  1240. }
  1241. END_CATCH
  1243. GlobalUnlock(hData);
  1244. file.Close();
  1245. }
  1247. void CPictureEx::EnumGIFBlocks()
  1248. {
  1249. enum GIFBlockTypes nBlock;
  1251. ResetDataPointer();
  1252. while(m_nCurrOffset < m_nDataSize)
  1253. {
  1254. nBlock = GetNextBlock();
  1255. switch(nBlock)
  1256. {
  1257. case BLOCK_UNKNOWN:
  1258. TRACE(_T("- Unknown blockn"));
  1259. return;
  1260. break;
  1262. case BLOCK_TRAILER:
  1263. TRACE(_T("- Trailer blockn"));
  1264. break;
  1266. case BLOCK_APPEXT:
  1267. TRACE(_T("- Application extension blockn"));
  1268. break;
  1270. case BLOCK_COMMEXT:
  1271. TRACE(_T("- Comment extension blockn"));
  1272. break;
  1274. case BLOCK_CONTROLEXT:
  1275. {
  1276. TGIFControlExt *pControl = 
  1277. reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);
  1278. TRACE(_T("- Graphic control extension block (delay %d, disposal %d)n"),
  1279. pControl->m_wDelayTime, pControl->GetPackedValue(GCX_PACKED_DISPOSAL));
  1280. };
  1281. break;
  1283. case BLOCK_PLAINTEXT:
  1284. TRACE(_T("- Plain text extension blockn"));
  1285. break;
  1287. case BLOCK_IMAGE:
  1288. TGIFImageDescriptor *pIDescr = 
  1289. reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);
  1290. TRACE(_T("- Image data block (%dx%d  %d,%d)n"),
  1291. pIDescr->m_wWidth,
  1292. pIDescr->m_wHeight,
  1293. pIDescr->m_wLeftPos,
  1294. pIDescr->m_wTopPos);
  1295. break;
  1296. };
  1298. SkipNextBlock();
  1299. };
  1301. TRACE(_T("n"));
  1302. }
  1303. #endif // GIF_TRACING
  1305. BOOL CPictureEx::SetPaintRect(const RECT *lpRect)
  1306. {
  1307. return CopyRect(&m_PaintRect, lpRect);
  1308. }
  1310. BOOL CPictureEx::GetPaintRect(RECT *lpRect)
  1311. {
  1312. return CopyRect(lpRect, &m_PaintRect);
  1313. }