DynamicGraphic.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */
   
/* This class is based on earlier work with GG by Tony Casale.  Thanks, Tony.*/

#ifndef _GG_DynamicGraphic_h_
#define _GG_DynamicGraphic_h_

#include <GG/Control.h>
#include <GG/StaticGraphic.h>


namespace GG {
class Texture;

class GG_API DynamicGraphic : public Control
{
public: 

    typedef boost::signal<void (int)> StoppedSignalType;

    typedef boost::signal<void (int)> EndFrameSignalType;
 
    typedef StoppedSignalType::slot_type StoppedSlotType;    
    typedef EndFrameSignalType::slot_type EndFrameSlotType;  

 

    DynamicGraphic(int x, int y, int w, int h, bool loop, int frame_width, int frame_height, int margin, const std::vector<boost::shared_ptr<Texture> >& textures, Flags<GraphicStyle> style = GRAPHIC_NONE, int frames = -1, Flags<WndFlag> flags = Flags<WndFlag>());
 
    int     Frames() const;      
    bool    Playing() const;     
    bool    Looping() const;     
    double  FPS() const;         
    int     FrameIndex() const;  
    int     TimeIndex() const;   

    int     StartFrame() const;

    int     EndFrame() const;

    int     Margin() const;      
    int     FrameWidth() const;  
    int     FrameHeight() const; 

    Flags<GraphicStyle>  Style() const;

    mutable StoppedSignalType  StoppedSignal;  
    mutable EndFrameSignalType EndFrameSignal; 

 
    virtual void Render();

    void AddFrames(const Texture* texture, int frames = -1);

    void AddFrames(const boost::shared_ptr<Texture>& texture, int frames = -1);

    void AddFrames(const std::vector<boost::shared_ptr<Texture> >& textures, int frames = -1);

    void  Play();                    
    void  Pause();                   
    void  NextFrame();               
    void  PrevFrame();               
    void  Stop();                    
    void  Loop(bool b = true);       

    void  SetFPS(double fps);

    void  SetFrameIndex(int idx);    

    void  SetTimeIndex(int idx);

    void  SetStartFrame(int idx);

    void  SetEndFrame(int idx);

    void  SetStyle(Flags<GraphicStyle> style);

    virtual void DefineAttributes(WndEditor* editor);
 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(CannotAddFrame, GG::DynamicGraphic, Exception);

protected:
    struct FrameSet
    {
        boost::shared_ptr<const Texture> texture; 
        int                              frames;  

    private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };
 
    DynamicGraphic(); 

 
    int FramesInTexture(const Texture* t) const; 

    const std::vector<FrameSet>& Textures() const;    

    int CurrentTexture() const;    
    int CurrentSubTexture() const; 
    int FirstFrameTime() const;    
    int LastFrameTime() const;     


    const int   m_margin;          
    const int   m_frame_width;     
    const int   m_frame_height;    

private:
    void ValidateStyle();            

    std::vector<FrameSet> m_textures;

    double      m_FPS;               
    bool        m_playing;           
    bool        m_looping;           
    int         m_curr_texture;      
    int         m_curr_subtexture;   
    int         m_frames;            
    int         m_curr_frame;        
    int         m_first_frame_time;  
    int         m_last_frame_time;   
    int         m_first_frame_idx;   
    int         m_last_frame_idx;    

    Flags<GraphicStyle>
                m_style;             

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

} // namespace GG

// template implementations
template <class Archive>
void GG::DynamicGraphic::FrameSet::serialize(Archive& ar, const unsigned int version)
{
    boost::shared_ptr<Texture> non_const_texture;
    if (Archive::is_saving::value)
        non_const_texture = boost::const_pointer_cast<Texture>(texture);

    ar  & boost::serialization::make_nvp("texture", non_const_texture)
        & BOOST_SERIALIZATION_NVP(frames);

    if (Archive::is_loading::value)
        texture = boost::const_pointer_cast<const Texture>(non_const_texture);
}

template <class Archive>
void GG::DynamicGraphic::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & boost::serialization::make_nvp("m_margin", const_cast<int&>(m_margin))
        & boost::serialization::make_nvp("m_frame_width", const_cast<int&>(m_frame_width))
        & boost::serialization::make_nvp("m_frame_height", const_cast<int&>(m_frame_height))
        & BOOST_SERIALIZATION_NVP(m_textures)
        & BOOST_SERIALIZATION_NVP(m_FPS)
        & BOOST_SERIALIZATION_NVP(m_playing)
        & BOOST_SERIALIZATION_NVP(m_looping)
        & BOOST_SERIALIZATION_NVP(m_curr_texture)
        & BOOST_SERIALIZATION_NVP(m_curr_subtexture)
        & BOOST_SERIALIZATION_NVP(m_frames)
        & BOOST_SERIALIZATION_NVP(m_curr_frame)
        & BOOST_SERIALIZATION_NVP(m_first_frame_time)
        & BOOST_SERIALIZATION_NVP(m_last_frame_time)
        & BOOST_SERIALIZATION_NVP(m_first_frame_idx)
        & BOOST_SERIALIZATION_NVP(m_last_frame_idx)
        & BOOST_SERIALIZATION_NVP(m_style);

    if (Archive::is_loading::value)
        ValidateStyle();
}

#endif // _GG_DynamicGraphic_h_

---