TnbMfcAnimateStatic.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbBitmapAnimater.h"
#include "TnbMfcRgnControl.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CAnimateStatic : public CRgnControlAddinT<CWnd>, public CBitmapAnimater
{
    DEFSUPER(CRgnControlAddinT<CWnd>);
    typedef CBitmapAnimater _animater;
public:
 
    CAnimateStatic(void) 
        : _super(), m_interval(1000), m_nowIndex(0), m_mode(0), m_useCache(false), m_isStopInDrag(false), m_doAnimate(false)
    {
    }
 
    bool StartAnimation(bool mode, DWORD interval, bool useCache = false, bool isStopInDrag = false)
    {
        m_Stop();
        if ( _animater::GetLength() > 0 )
        {
            m_mode = mode;
            m_interval = interval;
            m_useCache = useCache;
            m_isStopInDrag = isStopInDrag;
            _animater::FlashCache();
            //
            m_nowIndex = 0;
            m_nowBitmap.Null();
            m_doAnimate = true;
            m_Start();
            return true;
        }
        return false;
    }
 
    void StopAnimation(void)
    {
        m_doAnimate = false;
        m_Stop();
    }
 
    bool SetFirstFrame(CBitmapHandle bmp, const IBitmapWipable& defaultWiper)
    {
        bool r = _animater::SetFirstFrame(bmp, defaultWiper);
        m_Resize();
        return r;
    }
 
    bool SetFirstFrame(CBitmapHandle bmp)
    {
        bool r = _animater::SetFirstFrame(bmp);
        m_Resize();
        return r;
    }
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    /* 旧名
     * アニメ開始。 StartAnimation() を使ってください。
     */
    bool SetAnimationParameter(bool mode, DWORD interval, bool useCache = false, bool isStopInDrag = false)
    {
        return StartAnimation(mode, interval, useCache, isStopInDrag);
    }
    #endif
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_ERASEBKGND:
            TTRACE0("WM_ERASEBKGND\n");
            if ( _animater::GetLength() != 0 )
            {
                return 0;
            }
        case WM_PRINTCLIENT:
            TTRACE0("WM_PRINTCLIENT\n");
            {
                CDC* pDc = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                m_Draw(pDc);
            }
            return 0;
        case WM_PAINT:
            TTRACE0("WM_PAINT\n");
            {
                CPaintDC dc(this); // 描画用のデバイス コンテキスト
                RECT rc;
                GetClientRect(&rc);
                if ( ::RectVisible(dc, &rc) )
                {
                    m_Draw(&dc);
                }
            }
            return 0;
        case WM_ENABLE:
            TTRACE0("WM_ENABLE\n");
            (wParam != 0) ? m_Start() : m_Stop();
            return 0;
        case WM_SHOWWINDOW:
            TTRACE0("WM_SHOWWINDOW\n");
            if ( wParam != 0 )
            {
                m_nowIndex = 0;
                m_nowBitmap.Null();
                m_Start();
            }
            else
            {
                m_Stop();
            }
            return 0;
        case WM_TIMER:
            TTRACE0("WM_TIMER\n");
            if ( wParam == TIMERID_ANIMA )
            {
                if ( ! ::IsWindowEnabled(m_hWnd) )
                {
                    m_Stop();
                }
                else if ( m_IsAnimation() )
                {
                    if ( m_mode > 0 )
                    {
                        m_nowIndex++;
                        if ( m_nowIndex >= _animater::GetLength() )
                        {
                            m_nowIndex = _animater::GetLength() - 2;
                            m_mode = -1;
                        }
                    }
                    else if ( m_mode < 0 )
                    {
                        if ( m_nowIndex > 0 )
                        {
                            m_nowIndex--;
                        }
                        else
                        {
                            m_nowIndex = 1;
                            m_mode = 1;
                        }
                    }
                    else 
                    {
                        m_nowIndex++;
                        if ( m_nowIndex >= _animater::GetLength() )
                        {
                            m_nowIndex = 0;
                        }
                    }
                    m_nowBitmap.Null();
//                  RedrawWindow(NULL, NULL, RDW_INVALIDATE);
                    RedrawWindow();
                }
            }
            break;
        case WM_LBUTTONDOWN:
            return 0;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::ModifyStyle(0, SS_NOTIFY);
        _super::PreSubclassWindow();
        m_Resize();
    }
 
private:
    enum { TIMERID_ANIMA = 10000 };
    DWORD                   m_interval;     
    bool                    m_doAnimate;    
    INDEX                   m_nowIndex;     
    CBitmapHandle           m_nowBitmap;    
    int                     m_mode;         
    bool                    m_useCache;     
    bool                    m_isStopInDrag; 
    void m_Resize(void)
    {
        if ( _animater::GetLength() == 0 ) { return; }
        SIZE size;
        if ( _animater::FrameAt(0).GetSize(size) )
        {
            MFCLIB::ChangeClientSize(this, size.cx, size.cy);
        }
    }
    void m_Draw(CDC* pDC)
    {
        if ( m_nowBitmap.IsNull() && _animater::GetLength() != 0 )
        {
            m_nowBitmap = m_useCache ? _animater::FrameAtWithCache(m_nowIndex): _animater::FrameAt(m_nowIndex);
        }
        if ( m_clientRgn != NULL )
        {
            MFCLIB::SelectClipRgnOrg(pDC, m_clientRgn);
        }
        if ( ! m_nowBitmap.IsNull() )
        {
            m_nowBitmap.Draw(*pDC);
        }
    }
    bool m_IsAnimation(void)
    {
        if ( m_isStopInDrag && ::GetCapture() != NULL )
        {
            return false;
        }
        return _animater::GetLength() > 1;
    }
    void m_Start(void)
    {
        if ( m_doAnimate && ::IsWindow(m_hWnd) )
        {
            SetTimer(TIMERID_ANIMA, m_interval, NULL);
        }
    }
    void m_Stop(void)
    {
        if ( ::IsWindow(m_hWnd) )
        {
            KillTimer(TIMERID_ANIMA);
        }
    }
 
};
 
 
 
}; //MFC
}; //TNB