//////////////////////////////////////////////////////////////////////

// PictureEx.cpp: implementation of the CPictureEx class.

//

// Picture displaying control with support for the following formats:

// GIF (including animated GIF87a and GIF89a), JPEG, BMP, WMF, ICO, CUR

//

// Written by Oleg Bykov (oleg_bykoff@rsdn.ru)

// Copyright (c) 2001

//

// To use CPictureEx, follow these steps:

//   - place a static control on your dialog (either a text or a bitmap)

//   - change its identifier to something else (e.g. IDC_MYPIC)

//   - associate a CStatic with it using ClassWizard

//   - in your dialog's header file replace CStatic with CPictureEx

//     (don't forget to #include "PictureEx.h" and add

//     PictureEx.h and PictureEx.cpp to your project)

//   - call one of the overloaded CPictureEx::Load() functions somewhere

//     (OnInitDialog is a good place to start)

//   - if the preceding Load() succeeded call Draw()

//

// You can also add the control by defining a member variable of type

// CPictureEx, calling CPictureEx::Create (derived from CStatic), then

// CPictureEx::Load and CPictureEx::Draw.

//

// By default, the control initializes its background to COLOR_3DFACE

// (see CPictureEx::PrepareDC()). You can change the background by

// calling CPictureEx::SetBkColor(COLORREF) after CPictureEx::Load().

//

// I decided to leave in the class the functions to write separate frames from

// animated GIF to disk. If you want to use them, uncomment #define GIF_TRACING

// and an appropriate section in CPictureEx::Load(HGLOBAL, DWORD). These functions

// won't be compiled and linked to your project unless you uncomment #define GIF_TRACING,

// so you don't have to worry.

//

// Warning: this code hasn't been subject to a heavy testing, so

// use it on your own risk. The author accepts no liability for the

// possible damage caused by this code.

//

// Version 1.0  7 Aug 2001

//              Initial release

//

// Version 1.1  6 Sept 2001

//              ATL version of the class

//

// Version 1.2  14 Oct 2001

//              - Fixed a problem with loading GIFs from resources

//                in MFC-version of the class for multi-modules apps.

//                Thanks to Ruben Avila-Carretero for finding this out.

//

//              - Got rid of waitable timer in ThreadAnimation()

//                Now CPictureEx[Wnd] works in Win95 too.

//                Thanks to Alex Egiazarov and Wayne King for the idea.

//

//              - Fixed a visual glitch of using SetBkColor.

//                Thanks to Kwangjin Lee for finding this out.

//

// Version 1.3  10 Nov 2001

//              - Fixed a DC leak. One DC leaked per each UnLoad()

//                (forgot to put a ReleaseDC() in the end of

//                CPictureExWnd::PrepareDC() function).

//

//              - Now it is possible to set a clipping rectangle using

//                CPictureEx[Wnd]::SetPaintRect(const LPRECT) function.

//                The LPRECT parameter tells the class what portion of

//                a picture should it display. If the clipping rect is

//                not set, the whole picture is shown.

//                Thanks to Fabrice Rodriguez for the idea.

//

//              - Added support for Stop/Draw. Now you can Stop() an

//                animated GIF, then Draw() it again, it will continue

//                animation from the frame it was stopped on. You can

//                also know if a GIF is currently playing with the

//                IsPlaying() function.

//

//              - Got rid of math.h and made m_bExitThread volatile.

//                Thanks to Piotr Sawicki for the suggestion.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)

#define AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include <vector>

//#define GIF_TRACING  // uncomment it if you want detailed TRACEs

class CPictureEx : public CStatic

{

public:

struct TFrame    // structure that keeps a single frame info

{

 IPicture *m_pPicture;  // pointer to the interface used for drawing

 SIZE     m_frameSize;

 SIZE     m_frameOffset;

 UINT     m_nDelay;     // delay (in 1/100s of a second)

 UINT     m_nDisposal;  // disposal method

};

#pragma pack(1)   // turn byte alignment on

enum GIFBlockTypes

{

 BLOCK_UNKNOWN,

 BLOCK_APPEXT,

 BLOCK_COMMEXT,

 BLOCK_CONTROLEXT,

 BLOCK_PLAINTEXT,

 BLOCK_IMAGE,

 BLOCK_TRAILER

};

enum ControlExtValues // graphic control extension packed field values

{

 GCX_PACKED_DISPOSAL,  // disposal method

 GCX_PACKED_USERINPUT,

 GCX_PACKED_TRANSPCOLOR

};

enum LSDPackedValues  // logical screen descriptor packed field values

{

 LSD_PACKED_GLOBALCT,

 LSD_PACKED_CRESOLUTION,

 LSD_PACKED_SORT,

 LSD_PACKED_GLOBALCTSIZE

};

enum IDPackedValues   // image descriptor packed field values

{

 ID_PACKED_LOCALCT,

 ID_PACKED_INTERLACE,

 ID_PACKED_SORT,

 ID_PACKED_LOCALCTSIZE

};

struct TGIFHeader       // GIF header

{

 char m_cSignature[]; // Signature - Identifies the GIF Data Stream

        // This field contains the fixed value 'GIF'

 char m_cVersion[]; // Version number. May be one of the following:

      // "87a" or "89a"

};

struct TGIFLSDescriptor // Logical Screen Descriptor

{

 WORD m_wWidth; // 2 bytes. Logical screen width

 WORD m_wHeight; // 2 bytes. Logical screen height

 unsigned char m_cPacked;      // packed field 

 unsigned char m_cBkIndex;     // 1 byte. Background color index

 unsigned char m_cPixelAspect; // 1 byte. Pixel aspect ratio

 inline int GetPackedValue(enum LSDPackedValues Value);

};

struct TGIFAppExtension // application extension block

{

 unsigned char m_cExtIntroducer; // extension introducer (0x21)

 unsigned char m_cExtLabel; // app. extension label (0xFF)

 unsigned char m_cBlockSize; // fixed value of 11

 char m_cAppIdentifier[];   // application identifier

 char m_cAppAuth[];  // application authentication code

};

struct TGIFControlExt // graphic control extension block

{

 unsigned char m_cExtIntroducer; // extension introducer (0x21)

 unsigned char m_cControlLabel;  // control extension label (0xF9)

 unsigned char m_cBlockSize; // fixed value of 4

 unsigned char m_cPacked;    // packed field

 WORD m_wDelayTime; // delay time

 unsigned char m_cTColorIndex; // transparent color index

 unsigned char m_cBlockTerm;   // block terminator (0x00)

public:

 inline int GetPackedValue(enum ControlExtValues Value);

};

struct TGIFCommentExt  // comment extension block

{

 unsigned char m_cExtIntroducer; // extension introducer (0x21)

 unsigned char m_cCommentLabel;  // comment extension label (0xFE)

};

struct TGIFPlainTextExt // plain text extension block

{

 unsigned char m_cExtIntroducer;  // extension introducer (0x21)

 unsigned char m_cPlainTextLabel; // text extension label (0x01)

 unsigned char m_cBlockSize; // fixed value of 12

 WORD m_wLeftPos;    // text grid left position

 WORD m_wTopPos;     // text grid top position

 WORD m_wGridWidth;  // text grid width

 WORD m_wGridHeight; // text grid height

 unsigned char m_cCellWidth;  // character cell width

 unsigned char m_cCellHeight; // character cell height

 unsigned char m_cFgColor; // text foreground color index

 unsigned char m_cBkColor; // text background color index

};

struct TGIFImageDescriptor // image descriptor block

{

 unsigned char m_cImageSeparator; // image separator byte (0x2C)

 WORD m_wLeftPos; // image left position

 WORD m_wTopPos;  // image top position

 WORD m_wWidth;   // image width

 WORD m_wHeight;  // image height

 unsigned char m_cPacked; // packed field

 inline int GetPackedValue(enum IDPackedValues Value);

};

#pragma pack() // turn byte alignment off

public:

 BOOL GetPaintRect(RECT *lpRect);

 BOOL SetPaintRect(const RECT *lpRect);

 CPictureEx();

 virtual ~CPictureEx();

 void Stop();   // stops animation

 void UnLoad(); // stops animation plus releases all resources

 BOOL IsGIF() const;

 BOOL IsPlaying() const;

 BOOL IsAnimatedGIF() const;

 SIZE GetSize() const;

 int GetFrameCount() const;

 COLORREF GetBkColor() const;

 void SetBkColor(COLORREF clr);

 // draws the picture (starts an animation thread if needed)

 // if an animation was previously stopped by Stop(),

 // continues it from the last displayed frame

 BOOL Draw();

 // loads a picture from a file

 // i.e. Load(_T("mypic.gif"));

 BOOL Load(LPCTSTR szFileName);

 // loads a picture from a global memory block (allocated by GlobalAlloc)

 // Warning: this function DOES NOT free the global memory, pointed to by hGlobal

 BOOL Load(HGLOBAL hGlobal, DWORD dwSize);

 // loads a picture from a program resource

 // i.e. Load(MAKEINTRESOURCE(IDR_MYPIC),_T("GIFTYPE"));

 BOOL Load(LPCTSTR szResourceName,LPCTSTR szResourceType);

protected:

#ifdef GIF_TRACING

 void EnumGIFBlocks();

 void WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize);

#endif // GIF_TRACING

 RECT m_PaintRect;

 SIZE m_PictureSize;

 COLORREF m_clrBackground;

 UINT m_nCurrFrame;

 UINT m_nDataSize;

 UINT m_nCurrOffset;

 UINT m_nGlobalCTSize;

 BOOL m_bIsGIF;

 BOOL m_bIsPlaying;

 volatile BOOL m_bExitThread;

 BOOL m_bIsInitialized;

 HDC m_hMemDC;

 HDC m_hDispMemDC;

 HBITMAP m_hDispMemBM;

 HBITMAP m_hDispOldBM;

 HBITMAP m_hBitmap;

 HBITMAP m_hOldBitmap;

 HANDLE m_hThread;

 HANDLE m_hExitEvent;

 IPicture * m_pPicture;

 TGIFHeader * m_pGIFHeader;

 unsigned char * m_pRawData;

 TGIFLSDescriptor * m_pGIFLSDescriptor;

 std::vector<TFrame> m_arrFrames;

 void ThreadAnimation();

 static UINT WINAPI _ThreadAnimation(LPVOID pParam);

 int GetNextBlockLen() const;

 BOOL SkipNextBlock();

 BOOL SkipNextGraphicBlock();

 BOOL PrepareDC(int nWidth, int nHeight);

 void ResetDataPointer();

 enum GIFBlockTypes GetNextBlock() const;

 UINT GetSubBlocksLen(UINT nStartingOffset) const;

 HGLOBAL GetNextGraphicBlock(UINT *pBlockLen, UINT *pDelay,

  SIZE *pBlockSize, SIZE *pBlockOffset, UINT *pDisposal);

 // Generated message map functions

 //{{AFX_MSG(CPictureEx)

 afx_msg void OnDestroy();

 afx_msg void OnPaint();

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

#endif // !defined(AFX_PICTUREEX_H__0EFE5DE0_7B68_4DB7_8B34_5DC634948438__INCLUDED_)

//////////////////////////////////////////////////////////////////////

// PictureEx.cpp: implementation of the CPictureEx class.

//

// Picture displaying control with support for the following formats:

// GIF (including animated GIF87a and GIF89a), JPEG, BMP, WMF, ICO, CUR

//

// Written by Oleg Bykov (oleg_bykoff@rsdn.ru)

// Copyright (c) 2001

//

// To use CPictureEx, follow these steps:

//   - place a static control on your dialog (either a text or a bitmap)

//   - change its identifier to something else (e.g. IDC_MYPIC)

//   - associate a CStatic with it using ClassWizard

//   - in your dialog's header file replace CStatic with CPictureEx

//     (don't forget to #include "PictureEx.h" and add

//     PictureEx.h and PictureEx.cpp to your project)

//   - call one of the overloaded CPictureEx::Load() functions somewhere

//     (OnInitDialog is a good place to start)

//   - if the preceding Load() succeeded call Draw()

//

// You can also add the control by defining a member variable of type

// CPictureEx, calling CPictureEx::Create (derived from CStatic), then

// CPictureEx::Load and CPictureEx::Draw.

//

// By default, the control initializes its background to COLOR_3DFACE

// (see CPictureEx::PrepareDC()). You can change the background by

// calling CPictureEx::SetBkColor(COLORREF) after CPictureEx::Load().

//

// I decided to leave in the class the functions to write separate frames from

// animated GIF to disk. If you want to use them, uncomment #define GIF_TRACING

// and an appropriate section in CPictureEx::Load(HGLOBAL, DWORD). These functions

// won't be compiled and linked to your project unless you uncomment #define GIF_TRACING,

// so you don't have to worry.

//

// Warning: this code hasn't been subject to a heavy testing, so

// use it on your own risk. The author accepts no liability for the

// possible damage caused by this code.

//

// Version 1.0  7 Aug 2001

//              Initial release

//

// Version 1.1  6 Sept 2001

//              ATL version of the class

//

// Version 1.2  14 Oct 2001

//              - Fixed a problem with loading GIFs from resources

//                in MFC-version of the class for multi-modules apps.

//                Thanks to Ruben Avila-Carretero for finding this out.

//

//              - Got rid of waitable timer in ThreadAnimation()

//                Now CPictureEx[Wnd] works in Win95 too.

//                Thanks to Alex Egiazarov and Wayne King for the idea.

//

//              - Fixed a visual glitch of using SetBkColor.

//                Thanks to Kwangjin Lee for finding this out.

//

// Version 1.3  10 Nov 2001

//              - Fixed a DC leak. One DC leaked per each UnLoad()

//                (forgot to put a ReleaseDC() in the end of

//                CPictureExWnd::PrepareDC() function).

//

//              - Now it is possible to set a clipping rectangle using

//                CPictureEx[Wnd]::SetPaintRect(const LPRECT) function.

//                The LPRECT parameter tells the class what portion of

//                a picture should it display. If the clipping rect is

//                not set, the whole picture is shown.

//                Thanks to Fabrice Rodriguez for the idea.

//

//              - Added support for Stop/Draw. Now you can Stop() an

//                animated GIF, then Draw() it again, it will continue

//                animation from the frame it was stopped on. You can

//                also know if a GIF is currently playing with the

//                IsPlaying() function.

//

//              - Got rid of math.h and made m_bExitThread volatile.

//                Thanks to Piotr Sawicki for the suggestion.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "PictureEx.h"

#include <process.h>

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

//////////////////////////////////////////////////////////////////////

// Nested structures member functions

//////////////////////////////////////////////////////////////////////

inline int CPictureEx::TGIFControlExt::GetPackedValue(enum ControlExtValues Value)

{

 int nRet = (int)m_cPacked;

 switch (Value)

 {

 case GCX_PACKED_DISPOSAL:

  nRet = (nRet & ) >> ;

  break;

 case GCX_PACKED_USERINPUT:

  nRet = (nRet & ) >> ;

  break;

 case GCX_PACKED_TRANSPCOLOR:

  nRet &= ;

  break;

 };

 return nRet;

}

inline int CPictureEx::TGIFLSDescriptor::GetPackedValue(enum LSDPackedValues Value)

{

 int nRet = (int)m_cPacked;

 switch (Value)

 {

 case LSD_PACKED_GLOBALCT:

  nRet = nRet >> ;

  break;

 case LSD_PACKED_CRESOLUTION:

  nRet = ((nRet & 0x70) >> ) + ;

  break;

 case LSD_PACKED_SORT:

  nRet = (nRet & ) >> ;

  break;

 case LSD_PACKED_GLOBALCTSIZE:

  nRet &= ;

  break;

 };

 return nRet;

}

inline int CPictureEx::TGIFImageDescriptor::GetPackedValue(enum IDPackedValues Value)

{

 int nRet = (int)m_cPacked;

 switch (Value)

 {

 case ID_PACKED_LOCALCT:

  nRet >>= ;

  break;

 case ID_PACKED_INTERLACE:

  nRet = ((nRet & 0x40) >> );

  break;

 case ID_PACKED_SORT:

  nRet = (nRet & 0x20) >> ;

  break;

 case ID_PACKED_LOCALCTSIZE:

  nRet &= ;

  break;

 };

 return nRet;

}

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CPictureEx::CPictureEx()

{

 // check structures size

 ASSERT(sizeof(TGIFImageDescriptor) == );

 ASSERT(sizeof(TGIFAppExtension)    == );

 ASSERT(sizeof(TGIFPlainTextExt)    == );

 ASSERT(sizeof(TGIFLSDescriptor)    ==  );

 ASSERT(sizeof(TGIFControlExt)    ==  );

 ASSERT(sizeof(TGIFCommentExt)    ==  );

 ASSERT(sizeof(TGIFHeader)     ==  );

 m_pGIFLSDescriptor = NULL;

 m_pGIFHeader    = NULL;

 m_pPicture     = NULL;

 m_pRawData     = NULL;

 m_hThread     = NULL;

 m_hBitmap          = NULL;

 m_hMemDC     = NULL;

 m_hDispMemDC       = NULL;

 m_hDispMemBM       = NULL;

 m_hDispOldBM       = NULL;

 m_bIsInitialized   = FALSE;

 m_bExitThread    = FALSE;

 m_bIsPlaying       = FALSE;

 m_bIsGIF     = FALSE;

 m_clrBackground    = RGB(,,); // white by default

 m_nGlobalCTSize    = ;

 m_nCurrOffset    = ;

 m_nCurrFrame    = ;

 m_nDataSize     = ;

 m_PictureSize.cx = m_PictureSize.cy = ;

 SetRect(&m_PaintRect,,,,);

 m_hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL);

}

CPictureEx::~CPictureEx()

{

 UnLoad();

 CloseHandle(m_hExitEvent);

}

BEGIN_MESSAGE_MAP(CPictureEx, CStatic)

 //{{AFX_MSG_MAP(CPictureEx)

 ON_WM_DESTROY()

 ON_WM_PAINT()

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()

BOOL CPictureEx::Load(HGLOBAL hGlobal, DWORD dwSize)

{

 IStream *pStream = NULL;

 UnLoad();

 if (!(m_pRawData = reinterpret_cast<unsigned char*> (GlobalLock(hGlobal))) )

 {

  TRACE(_T("Load: Error locking memory\n"));

  return FALSE;

 };

 m_nDataSize = dwSize;

 m_pGIFHeader = reinterpret_cast<TGIFHeader *> (m_pRawData);

 if ((memcmp(&m_pGIFHeader->m_cSignature,"GIF",) != ) &&

  ((memcmp(&m_pGIFHeader->m_cVersion,"87a",) != ) ||

   (memcmp(&m_pGIFHeader->m_cVersion,"89a",) != )) )

 {

 // it's neither GIF87a nor GIF89a

 // do the default processing

  // clear GIF variables

  m_pRawData = NULL;

  GlobalUnlock(hGlobal);

  // don't delete memory on object's release

  if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)

   return FALSE;

  if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,

   reinterpret_cast<LPVOID *>(&m_pPicture)) != S_OK)

  {

   pStream->Release();

   return FALSE;

  };

  pStream->Release();

  // store picture's size

  long hmWidth;

  long hmHeight;

  m_pPicture->get_Width(&hmWidth);

  m_pPicture->get_Height(&hmHeight);

  HDC hDC = ::GetDC(m_hWnd);

  m_PictureSize.cx = MulDiv(hmWidth, GetDeviceCaps(hDC,LOGPIXELSX), );

  m_PictureSize.cy = MulDiv(hmHeight, GetDeviceCaps(hDC,LOGPIXELSY), );

  ::ReleaseDC(m_hWnd,hDC);

 }

 else

 {

  // it's a GIF

  m_bIsGIF = TRUE;

  m_pGIFLSDescriptor = reinterpret_cast<TGIFLSDescriptor *>

   (m_pRawData + sizeof(TGIFHeader));

  if (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT) == )

  {

   // calculate the globat color table size

   m_nGlobalCTSize = static_cast<int>

    (* ( << (m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE)+)));

   // get the background color if GCT is present

   unsigned char *pBkClr = m_pRawData + sizeof(TGIFHeader) +

    sizeof(TGIFLSDescriptor) + *m_pGIFLSDescriptor->m_cBkIndex;

   m_clrBackground = RGB(pBkClr[],pBkClr[],pBkClr[]);

  };

  // store the picture's size

  m_PictureSize.cx = m_pGIFLSDescriptor->m_wWidth;

  m_PictureSize.cy = m_pGIFLSDescriptor->m_wHeight;

  // determine frame count for this picture

  UINT nFrameCount=;

  ResetDataPointer();

  while (SkipNextGraphicBlock())

   nFrameCount++;

#ifdef GIF_TRACING

  TRACE(

   _T(" -= GIF encountered\n"

      "Logical Screen dimensions = %dx%d\n"

      "Global color table = %d\n"

      "Color depth = %d\n"

      "Sort flag = %d\n"

      "Size of Global Color Table = %d\n"

      "Background color index = %d\n"

      "Pixel aspect ratio = %d\n"

      "Frame count = %d\n"

      "Background color = %06Xh\n\n"

     ),

   m_pGIFLSDescriptor->m_wWidth,

   m_pGIFLSDescriptor->m_wHeight,

   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCT),

   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_CRESOLUTION),

   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_SORT),

   m_pGIFLSDescriptor->GetPackedValue(LSD_PACKED_GLOBALCTSIZE),

   m_pGIFLSDescriptor->m_cBkIndex,

   m_pGIFLSDescriptor->m_cPixelAspect,

   nFrameCount,

   m_clrBackground

   );

  EnumGIFBlocks();

#endif

  if (nFrameCount == ) // it's an empty GIF!

  {

   m_pRawData = NULL;

   GlobalUnlock(hGlobal);

   return FALSE;

  };

  // now check the frame count

  // if there's only one frame, no need to animate this GIF

  // therefore, treat it like any other pic

  if (nFrameCount == )

  {

   // clear GIF variables

   m_pRawData = NULL;

   GlobalUnlock(hGlobal);

   // don't delete memory on object's release

   if (CreateStreamOnHGlobal(hGlobal,FALSE,&pStream) != S_OK)

    return FALSE;

   if (OleLoadPicture(pStream,dwSize,FALSE,IID_IPicture,

    (LPVOID *)&m_pPicture) != S_OK)

   {

    pStream->Release();

    return FALSE;

   };

   pStream->Release();

  }

  else

  {

  // if, on the contrary, there are several frames

  // then store separate frames in an array

   TFrame frame;

   UINT nBlockLen;

   HGLOBAL hFrameData;

   UINT nCurFrame = ;

   ResetDataPointer();

   while (hFrameData = GetNextGraphicBlock(&nBlockLen,

    &frame.m_nDelay, &frame.m_frameSize,

    &frame.m_frameOffset, &frame.m_nDisposal) )

   {

    #ifdef GIF_TRACING

    //////////////////////////////////////////////

    // uncomment the following strings if you want

    // to write separate frames on disk

    //

    // CString szName;

    // szName.Format(_T("%.4d.gif"),nCurFrame);

    // WriteDataOnDisk(szName,hFrameData,nBlockLen);

    // nCurFrame++;

    #endif // GIF_TRACING

    IStream *pStream = NULL;

    // delete memory on object's release

    if (CreateStreamOnHGlobal(hFrameData,TRUE,&pStream) != S_OK)

    {

     GlobalFree(hFrameData);

     continue;

    };

    if (OleLoadPicture(pStream,nBlockLen,FALSE,

     IID_IPicture,

     reinterpret_cast<LPVOID *>(&frame.m_pPicture)) != S_OK)

    {

     pStream->Release();

     continue;

    };

    pStream->Release();

    // everything went well, add this frame

    m_arrFrames.push_back(frame);

   };

   // clean after ourselves

   m_pRawData = NULL;

   GlobalUnlock(hGlobal);

   if (m_arrFrames.empty()) // couldn't load any frames

    return FALSE;

  };

 }; // if (!IsGIF...

 return PrepareDC(m_PictureSize.cx,m_PictureSize.cy);

}

void CPictureEx::UnLoad()

{

 Stop();

 if (m_pPicture)

 {

  m_pPicture->Release();

  m_pPicture = NULL;

 };

 std::vector<TFrame>::iterator it;

 for (it=m_arrFrames.begin();it<m_arrFrames.end();it++)

  (*it).m_pPicture->Release();

 m_arrFrames.clear();

 if (m_hMemDC)

 {

  SelectObject(m_hMemDC,m_hOldBitmap);

  ::DeleteDC(m_hMemDC);

  ::DeleteObject(m_hBitmap);

  m_hMemDC  = NULL;

  m_hBitmap = NULL;

 };

 if (m_hDispMemDC)

 {

  SelectObject(m_hDispMemDC,m_hDispOldBM);

  ::DeleteDC(m_hDispMemDC);

  ::DeleteObject(m_hDispMemBM);

  m_hDispMemDC  = NULL;

  m_hDispMemBM = NULL;

 };

 SetRect(&m_PaintRect,,,,);

 m_pGIFLSDescriptor = NULL;

 m_pGIFHeader    = NULL;

 m_pRawData     = NULL;

 m_hThread     = NULL;

 m_bIsInitialized   = FALSE;

 m_bExitThread    = FALSE;

 m_bIsGIF     = FALSE;

 m_clrBackground    = RGB(,,); // white by default

 m_nGlobalCTSize    = ;

 m_nCurrOffset    = ;

 m_nCurrFrame    = ;

 m_nDataSize     = ;

}

BOOL CPictureEx::Draw()

{

 if (!m_bIsInitialized)

 {

  TRACE(_T("Call one of the CPictureEx::Load() member functions before calling Draw()\n"));

  return FALSE;

 };

 if (IsAnimatedGIF())

 {

 // the picture needs animation

 // we'll start the thread that will handle it for us

  unsigned int nDummy;

  m_hThread = (HANDLE) _beginthreadex(NULL,,_ThreadAnimation,this,

   CREATE_SUSPENDED,&nDummy);

  if (!m_hThread)

  {

   TRACE(_T("Draw: Couldn't start a GIF animation thread\n"));

   return FALSE;

  }

  else

   ResumeThread(m_hThread);

 }

 else

 {

  if (m_pPicture)

  {

   long hmWidth;

   long hmHeight;

   m_pPicture->get_Width(&hmWidth);

   m_pPicture->get_Height(&hmHeight);

   if (m_pPicture->Render(m_hMemDC, , , m_PictureSize.cx, m_PictureSize.cy,

    , hmHeight, hmWidth, -hmHeight, NULL) == S_OK)

   {

    Invalidate(FALSE);

    return TRUE;

   };

  };

 };

 return FALSE;

}

SIZE CPictureEx::GetSize() const

{

 return m_PictureSize;

}

BOOL CPictureEx::Load(LPCTSTR szFileName)

{

 ASSERT(szFileName);

 CFile file;

 HGLOBAL hGlobal;

 DWORD dwSize;

 if (!file.Open(szFileName,

    CFile::modeRead |

    CFile::shareDenyWrite) )

 {

  TRACE(_T("Load (file): Error opening file %s\n"),szFileName);

  return FALSE;

 };

 dwSize = file.GetLength();

 hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);

 if (!hGlobal)

 {

  TRACE(_T("Load (file): Error allocating memory\n"));

  return FALSE;

 };

 char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal));

 if (!pData)

 {

  TRACE(_T("Load (file): Error locking memory\n"));

  GlobalFree(hGlobal);

  return FALSE;

 };

 TRY

 {

  file.Read(pData,dwSize);

 }

 CATCH(CFileException, e);

 {

  TRACE(_T("Load (file): An exception occured while reading the file %s\n"),

   szFileName);

  GlobalFree(hGlobal);

  e->Delete();

  file.Close();

  return FALSE;

 }

 END_CATCH

 GlobalUnlock(hGlobal);

 file.Close();

 BOOL bRetValue = Load(hGlobal,dwSize);

 GlobalFree(hGlobal);

 return bRetValue;

}

BOOL CPictureEx::Load(LPCTSTR szResourceName, LPCTSTR szResourceType)

{

 ASSERT(szResourceName);

 ASSERT(szResourceType);

 HRSRC hPicture = FindResource(AfxGetResourceHandle(),szResourceName,szResourceType);

 HGLOBAL hResData;

 if (!hPicture || !(hResData = LoadResource(AfxGetResourceHandle(),hPicture)))

 {

  TRACE(_T("Load (resource): Error loading resource %s\n"),szResourceName);

  return FALSE;

 };

 DWORD dwSize = SizeofResource(AfxGetResourceHandle(),hPicture);

 // hResData is not the real HGLOBAL (we can't lock it)

 // let's make it real

 HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD,dwSize);

 if (!hGlobal)

 {

  TRACE(_T("Load (resource): Error allocating memory\n"));

  FreeResource(hResData);

  return FALSE;

 };

 char *pDest = reinterpret_cast<char *> (GlobalLock(hGlobal));

 char *pSrc = reinterpret_cast<char *> (LockResource(hResData));

 if (!pSrc || !pDest)

 {

  TRACE(_T("Load (resource): Error locking memory\n"));

  GlobalFree(hGlobal);

  FreeResource(hResData);

  return FALSE;

 };

 CopyMemory(pDest,pSrc,dwSize);

 FreeResource(hResData);

 GlobalUnlock(hGlobal);

 BOOL bRetValue = Load(hGlobal,dwSize);

 GlobalFree(hGlobal);

 return bRetValue;

}

void CPictureEx::ResetDataPointer()

{

 // skip header and logical screen descriptor

 m_nCurrOffset =

  sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;

}

BOOL CPictureEx::SkipNextGraphicBlock()

{

 if (!m_pRawData) return FALSE;

 // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data

 enum GIFBlockTypes nBlock;

 nBlock = GetNextBlock();

 while ((nBlock != BLOCK_CONTROLEXT) &&

     (nBlock != BLOCK_IMAGE) &&

     (nBlock != BLOCK_PLAINTEXT) &&

     (nBlock != BLOCK_UNKNOWN) &&

     (nBlock != BLOCK_TRAILER) )

 {

  if (!SkipNextBlock()) return NULL;

  nBlock = GetNextBlock();

 };

 if ((nBlock == BLOCK_UNKNOWN) ||

  (nBlock == BLOCK_TRAILER))

  return FALSE;

 // it's either a control ext.block, an image or a plain text

 if (GetNextBlockLen() <= ) return FALSE;

 if (nBlock == BLOCK_CONTROLEXT)

 {

  if (!SkipNextBlock()) return FALSE;

  nBlock = GetNextBlock();

  // skip everything until we meet an image block or a plain-text block

  while ((nBlock != BLOCK_IMAGE) &&

      (nBlock != BLOCK_PLAINTEXT) &&

      (nBlock != BLOCK_UNKNOWN) &&

      (nBlock != BLOCK_TRAILER) )

  {

   if (!SkipNextBlock()) return NULL;

   nBlock = GetNextBlock();

  };

  if ((nBlock == BLOCK_UNKNOWN) ||

   (nBlock == BLOCK_TRAILER))

   return FALSE;

 };

 // skip the found data block (image or plain-text)

 if (!SkipNextBlock()) return FALSE;

 return TRUE;

}

UINT CPictureEx::GetSubBlocksLen(UINT nStartingOffset) const

{

 UINT nRet = ;

 UINT nCurOffset = nStartingOffset;

 while (m_pRawData[nCurOffset] != )

 {

  nRet += m_pRawData[nCurOffset]+;

  nCurOffset += m_pRawData[nCurOffset]+;

 };

 return nRet+;

}

enum CPictureEx::GIFBlockTypes CPictureEx::GetNextBlock() const

{

 switch(m_pRawData[m_nCurrOffset])

 {

 case 0x21:

 // extension block

  switch(m_pRawData[m_nCurrOffset+])

  {

  case 0x01:

  // plain text extension

   return BLOCK_PLAINTEXT;

   break;

  case 0xF9:

  // graphic control extension

   return BLOCK_CONTROLEXT;

   break;

  case 0xFE:

  // comment extension

   return BLOCK_COMMEXT;

   break;

  case 0xFF:

  // application extension

   return BLOCK_APPEXT;

   break;

  };

  break;

 case 0x3B:

 // trailer

  return BLOCK_TRAILER;

  break;

 case 0x2C:

 // image data

  return BLOCK_IMAGE;

  break;

 };

 return BLOCK_UNKNOWN;

}

BOOL CPictureEx::SkipNextBlock()

{

 if (!m_pRawData) return FALSE;

 int nLen = GetNextBlockLen();

 if ((nLen <= ) || ((m_nCurrOffset+nLen) > m_nDataSize))

  return FALSE;

 m_nCurrOffset += nLen;

 return TRUE;

}

int CPictureEx::GetNextBlockLen() const

{

 GIFBlockTypes nBlock = GetNextBlock();

 int nTmp;

 switch(nBlock)

 {

 case BLOCK_UNKNOWN:

  return -;

  break;

 case BLOCK_TRAILER:

  return ;

  break;

 case BLOCK_APPEXT:

  nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFAppExtension));

  if (nTmp > )

   return sizeof(TGIFAppExtension)+nTmp;

  break;

 case BLOCK_COMMEXT:

  nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFCommentExt));

  if (nTmp > )

   return sizeof(TGIFCommentExt)+nTmp;

  break;

 case BLOCK_CONTROLEXT:

  return sizeof(TGIFControlExt);

  break;

 case BLOCK_PLAINTEXT:

  nTmp = GetSubBlocksLen(m_nCurrOffset+sizeof(TGIFPlainTextExt));

  if (nTmp > )

   return sizeof(TGIFPlainTextExt)+nTmp;

  break;

 case BLOCK_IMAGE:

  TGIFImageDescriptor *pIDescr =

   reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);

  int nLCTSize = (int)

   (pIDescr->GetPackedValue(ID_PACKED_LOCALCT)**

   ( << (pIDescr->GetPackedValue(ID_PACKED_LOCALCTSIZE)+)));

  int nTmp = GetSubBlocksLen(m_nCurrOffset+

   sizeof(TGIFImageDescriptor) + nLCTSize + );

  if (nTmp > )

   return sizeof(TGIFImageDescriptor) + nLCTSize +  + nTmp;

  break;

 };

 return ;

}

UINT WINAPI CPictureEx::_ThreadAnimation(LPVOID pParam)

{

 ASSERT(pParam);

 CPictureEx *pPic = reinterpret_cast<CPictureEx *> (pParam);

 pPic->m_bIsPlaying = TRUE;

 pPic->ThreadAnimation();

 pPic->m_bIsPlaying = FALSE;

 // this thread has finished its work so we close the handle

 CloseHandle(pPic->m_hThread);

 // and init the handle to zero (so that Stop() doesn't Wait on it)

 pPic->m_hThread = ;

 return ;

}

void CPictureEx::ThreadAnimation()

{

 // first, restore background (for stop/draw support)

 // disposal method #2

 if (m_arrFrames[m_nCurrFrame].m_nDisposal == )

 {

  HBRUSH hBrush = CreateSolidBrush(m_clrBackground);

  if (hBrush)

  {

   RECT rect = {

    m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };

   FillRect(m_hMemDC,&rect,hBrush);

   DeleteObject(hBrush);

  };

 }

 else

  // disposal method #3

  if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == ) )

  {

   // put it back

   BitBlt(m_hMemDC,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

    m_arrFrames[m_nCurrFrame].m_frameSize.cx,

    m_arrFrames[m_nCurrFrame].m_frameSize.cy,

    m_hDispMemDC,,, SRCCOPY);

   // init variables

   SelectObject(m_hDispMemDC,m_hDispOldBM);

   DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;

   DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;

  };

 while (!m_bExitThread)

 {

  if (m_arrFrames[m_nCurrFrame].m_pPicture)

  {

  ///////////////////////////////////////////////////////

  // Before rendering a frame we should take care of what's

  // behind that frame. TFrame::m_nDisposal will be our guide:

  //   0 - no disposal specified (do nothing)

  //   1 - do not dispose (again, do nothing)

  //   2 - restore to background color (m_clrBackground)

  //   3 - restore to previous

   //////// disposal method #3

   if (m_arrFrames[m_nCurrFrame].m_nDisposal == )

   {

    // prepare a memory DC and store the background in it

    m_hDispMemDC = CreateCompatibleDC(m_hMemDC);

    m_hDispMemBM = CreateCompatibleBitmap(m_hMemDC,

       m_arrFrames[m_nCurrFrame].m_frameSize.cx,

       m_arrFrames[m_nCurrFrame].m_frameSize.cy);

    if (m_hDispMemDC && m_hDispMemBM)

    {

     m_hDispOldBM = reinterpret_cast<HBITMAP> (SelectObject(m_hDispMemDC,m_hDispMemBM));

     BitBlt(m_hDispMemDC,,,

      m_arrFrames[m_nCurrFrame].m_frameSize.cx,

      m_arrFrames[m_nCurrFrame].m_frameSize.cy,

      m_hMemDC,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

      SRCCOPY);

    };

   };

   ///////////////////////

   long hmWidth;

   long hmHeight;

   m_arrFrames[m_nCurrFrame].m_pPicture->get_Width(&hmWidth);

   m_arrFrames[m_nCurrFrame].m_pPicture->get_Height(&hmHeight);

   if (m_arrFrames[m_nCurrFrame].m_pPicture->Render(m_hMemDC,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

    m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

    m_arrFrames[m_nCurrFrame].m_frameSize.cx,

    m_arrFrames[m_nCurrFrame].m_frameSize.cy,

    , hmHeight, hmWidth, -hmHeight, NULL) == S_OK)

   {

    Invalidate(FALSE);

   };

   if (m_bExitThread) break;

   // if the delay time is too short (like in old GIFs), wait for 100ms

   if (m_arrFrames[m_nCurrFrame].m_nDelay < )

    WaitForSingleObject(m_hExitEvent, );

   else

    WaitForSingleObject(m_hExitEvent, *m_arrFrames[m_nCurrFrame].m_nDelay);

   if (m_bExitThread) break;

   // disposal method #2

   if (m_arrFrames[m_nCurrFrame].m_nDisposal == )

   {

    HBRUSH hBrush = CreateSolidBrush(m_clrBackground);

    if (hBrush)

    {

     RECT rect = {

      m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cx + m_arrFrames[m_nCurrFrame].m_frameSize.cx,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cy + m_arrFrames[m_nCurrFrame].m_frameSize.cy };

     FillRect(m_hMemDC,&rect,hBrush);

     DeleteObject(hBrush);

    };

   }

   else

    if (m_hDispMemDC && (m_arrFrames[m_nCurrFrame].m_nDisposal == ) )

    {

     // put it back

     BitBlt(m_hMemDC,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cx,

      m_arrFrames[m_nCurrFrame].m_frameOffset.cy,

      m_arrFrames[m_nCurrFrame].m_frameSize.cx,

      m_arrFrames[m_nCurrFrame].m_frameSize.cy,

      m_hDispMemDC,,, SRCCOPY);

     // init variables

     SelectObject(m_hDispMemDC,m_hDispOldBM);

     DeleteDC(m_hDispMemDC); m_hDispMemDC = NULL;

     DeleteObject(m_hDispMemBM); m_hDispMemBM = NULL;

    };

  };

  m_nCurrFrame++;

  if (m_nCurrFrame == m_arrFrames.size())

  {

   m_nCurrFrame

    = ;

  // init the screen for the first frame,

   HBRUSH hBrush = CreateSolidBrush(m_clrBackground);

   if (hBrush)

   {

    RECT rect = {,,m_PictureSize.cx,m_PictureSize.cy};

    FillRect(m_hMemDC,&rect,hBrush);

    DeleteObject(hBrush);

   };

  };

 };

}

void CPictureEx::Stop()

{

 m_bIsPlaying = FALSE;

 m_bExitThread = TRUE;

 SetEvent(m_hExitEvent);

 if (m_hThread)

 {

  // we'll wait for 5 seconds then continue execution

  WaitForSingleObject(m_hThread,);

  CloseHandle(m_hThread);

  m_hThread = NULL;

 }

 // make it possible to Draw() again

 ResetEvent(m_hExitEvent);

 m_bExitThread = FALSE;

}

HGLOBAL CPictureEx::GetNextGraphicBlock(UINT *pBlockLen,

 UINT *pDelay, SIZE *pBlockSize, SIZE *pBlockOffset,

 UINT *pDisposal)

{

 if (!m_pRawData) return NULL;

 // GIF header + LSDescriptor [+ GCT] [+ Control block] + Data

 *pDisposal = ;

 enum GIFBlockTypes nBlock;

 nBlock = GetNextBlock();

 while (

  (nBlock != BLOCK_CONTROLEXT) &&

  (nBlock != BLOCK_IMAGE) &&

  (nBlock != BLOCK_PLAINTEXT) &&

  (nBlock != BLOCK_UNKNOWN) &&

  (nBlock != BLOCK_TRAILER)

  )

 {

  if (!SkipNextBlock()) return NULL;

  nBlock = GetNextBlock();

 };

 if ((nBlock == BLOCK_UNKNOWN) ||

  (nBlock == BLOCK_TRAILER))

  return NULL;

 // it's either a control ext.block, an image or a plain text

 int nStart = m_nCurrOffset;

 int nBlockLen = GetNextBlockLen();

 if (nBlockLen <= ) return NULL;

 if (nBlock == BLOCK_CONTROLEXT)

 {

  // get the following data

  TGIFControlExt *pControl =

   reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);

  // store delay time

  *pDelay = pControl->m_wDelayTime;

  // store disposal method

  *pDisposal = pControl->GetPackedValue(GCX_PACKED_DISPOSAL);

  if (!SkipNextBlock()) return NULL;

  nBlock = GetNextBlock();

  // skip everything until we find data to display

  // (image block or plain-text block)

  while (

   (nBlock != BLOCK_IMAGE) &&

   (nBlock != BLOCK_PLAINTEXT) &&

   (nBlock != BLOCK_UNKNOWN) &&

   (nBlock != BLOCK_TRAILER)

   )

  {

   if (!SkipNextBlock()) return NULL;

   nBlock = GetNextBlock();

   nBlockLen += GetNextBlockLen();

  };

  if ((nBlock == BLOCK_UNKNOWN) || (nBlock == BLOCK_TRAILER))

   return NULL;

  nBlockLen += GetNextBlockLen();

 }

 else

  *pDelay = -; // to indicate that there was no delay value

 if (nBlock == BLOCK_IMAGE)

 {

  // store size and offsets

  TGIFImageDescriptor *pImage =

   reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);

  pBlockSize->cx = pImage->m_wWidth;

  pBlockSize->cy = pImage->m_wHeight;

  pBlockOffset->cx = pImage->m_wLeftPos;

  pBlockOffset->cy = pImage->m_wTopPos;

 };

 if (!SkipNextBlock()) return NULL;

 HGLOBAL hGlobal = GlobalAlloc(GMEM_FIXED,

  sizeof(TGIFHeader) +

  sizeof(TGIFLSDescriptor) +

  m_nGlobalCTSize +

  nBlockLen +

  );  // for the trailer

 if (!hGlobal) return NULL;

 int nOffset = ; 

 // GMEM_FIXED means we get a pointer

 unsigned char *pGlobal = reinterpret_cast<unsigned char *> (hGlobal);

 CopyMemory(pGlobal,m_pRawData,

  sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize);

 nOffset += sizeof(TGIFHeader)+sizeof(TGIFLSDescriptor)+m_nGlobalCTSize;

 CopyMemory(pGlobal + nOffset,&m_pRawData[nStart], nBlockLen);

 nOffset += nBlockLen;

 pGlobal[nOffset] = 0x3B; // trailer

 nOffset++;

 *pBlockLen = nOffset;

 return hGlobal;

}

BOOL CPictureEx::IsGIF() const

{

 return m_bIsGIF;

}

BOOL CPictureEx::IsAnimatedGIF() const

{

 return (m_bIsGIF && (m_arrFrames.size() > ));

}

BOOL CPictureEx::IsPlaying() const

{

 return m_bIsPlaying;

}

int CPictureEx::GetFrameCount() const

{

 if (!IsAnimatedGIF())

  return ;

 return m_arrFrames.size();

}

COLORREF CPictureEx::GetBkColor() const

{

 return m_clrBackground;

}

void CPictureEx::OnPaint()

{

 CPaintDC dc(this); // device context for painting

 LONG nPaintWidth = m_PaintRect.right-m_PaintRect.left;

 if (nPaintWidth > )

 {

  LONG nPaintHeight = m_PaintRect.bottom - m_PaintRect.top;

  ::BitBlt(dc.m_hDC, , , nPaintWidth, nPaintHeight,

   m_hMemDC, m_PaintRect.left, m_PaintRect.top, SRCCOPY);

 }

 else

 {

  ::BitBlt(dc.m_hDC, , , m_PictureSize.cx, m_PictureSize.cy,

   m_hMemDC, , , SRCCOPY);

 };

}

BOOL CPictureEx::PrepareDC(int nWidth, int nHeight)

{

 SetWindowPos(NULL,,,nWidth,nHeight,SWP_NOMOVE | SWP_NOZORDER);

 HDC hWinDC = ::GetDC(m_hWnd);

 if (!hWinDC) return FALSE;

 m_hMemDC = CreateCompatibleDC(hWinDC);

 if (!m_hMemDC)

 {

  ::ReleaseDC(m_hWnd,hWinDC);

  return FALSE;

 };

 m_hBitmap  = CreateCompatibleBitmap(hWinDC,nWidth,nHeight);

 if (!m_hBitmap)

 {

  ::ReleaseDC(m_hWnd,hWinDC);

  ::DeleteDC(m_hMemDC);

  return FALSE;

 };

 m_hOldBitmap = reinterpret_cast<HBITMAP>

      (SelectObject(m_hMemDC,m_hBitmap));

 // fill the background

 m_clrBackground = GetSysColor(COLOR_3DFACE);

 RECT rect = {,,nWidth,nHeight};

 FillRect(m_hMemDC,&rect,(HBRUSH)(COLOR_WINDOW));

 ::ReleaseDC(m_hWnd,hWinDC);

 m_bIsInitialized = TRUE;

 return TRUE;

}

void CPictureEx::OnDestroy()

{

 Stop();

 CStatic::OnDestroy();

}

void CPictureEx::SetBkColor(COLORREF clr)

{

 if (!m_bIsInitialized) return;

 m_clrBackground = clr;

 HBRUSH hBrush = CreateSolidBrush(clr);

 if (hBrush)

 {

  RECT rect = {,,m_PictureSize.cx,m_PictureSize.cy};

  FillRect(m_hMemDC,&rect,hBrush);

  DeleteObject(hBrush);

 };

}

#ifdef GIF_TRACING

void CPictureEx::WriteDataOnDisk(CString szFileName, HGLOBAL hData, DWORD dwSize)

{

 CFile file;

 if (!file.Open(szFileName,

   CFile::modeCreate |

   CFile::modeWrite |

   CFile::shareDenyNone))

 {

  TRACE(_T("WriteData: Error creating file %s\n"),szFileName);

  return;

 };

 char *pData = reinterpret_cast<char *> (GlobalLock(hData));

 if (!pData)

 {

  TRACE(_T("WriteData: Error locking memory\n"));

  return;

 };

 TRY

 {

  file.Write(pData,dwSize);

 }

 CATCH(CFileException, e);

 {

  TRACE(_T("WriteData: An exception occured while writing to the file %s\n"),

   szFileName);

  e->Delete();

  GlobalUnlock(hData);

  file.Close();

  return;

 }

 END_CATCH

 GlobalUnlock(hData);

 file.Close();

}

void CPictureEx::EnumGIFBlocks()

{

 enum GIFBlockTypes nBlock;

 ResetDataPointer();

 while(m_nCurrOffset < m_nDataSize)

 {

  nBlock = GetNextBlock();

  switch(nBlock)

  {

  case BLOCK_UNKNOWN:

   TRACE(_T("- Unknown block\n"));

   return;

   break;

  case BLOCK_TRAILER:

   TRACE(_T("- Trailer block\n"));

   break;

  case BLOCK_APPEXT:

   TRACE(_T("- Application extension block\n"));

   break;

  case BLOCK_COMMEXT:

   TRACE(_T("- Comment extension block\n"));

   break;

  case BLOCK_CONTROLEXT:

   {

   TGIFControlExt *pControl =

    reinterpret_cast<TGIFControlExt *> (&m_pRawData[m_nCurrOffset]);

   TRACE(_T("- Graphic control extension block (delay %d, disposal %d)\n"),

     pControl->m_wDelayTime, pControl->GetPackedValue(GCX_PACKED_DISPOSAL));

   };

   break;

  case BLOCK_PLAINTEXT:

   TRACE(_T("- Plain text extension block\n"));

   break;

  case BLOCK_IMAGE:

   TGIFImageDescriptor *pIDescr =

    reinterpret_cast<TGIFImageDescriptor *> (&m_pRawData[m_nCurrOffset]);

   TRACE(_T("- Image data block (%dx%d  %d,%d)\n"),

     pIDescr->m_wWidth,

     pIDescr->m_wHeight,

     pIDescr->m_wLeftPos,

     pIDescr->m_wTopPos);

   break;

  };

  SkipNextBlock();

 };

 TRACE(_T("\n"));

}

#endif // GIF_TRACING

BOOL CPictureEx::SetPaintRect(const RECT *lpRect)

{

 return CopyRect(&m_PaintRect, lpRect);

}

BOOL CPictureEx::GetPaintRect(RECT *lpRect)

{

 return CopyRect(lpRect, &m_PaintRect);

}