DefineButtonTag.h

Go to the documentation of this file.

//
//   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef GNASH_SWF_DEFINEBUTTONTAG_H
#define GNASH_SWF_DEFINEBUTTONTAG_H

#include <vector>
#include <boost/ptr_container/ptr_vector.hpp>
#include <memory>
#include <cstdint>
#include <memory>

#include "DefinitionTag.h"
#include "SWFMatrix.h" 
#include "SWFCxForm.h" 
#include "action_buffer.h" 
#include "filter_factory.h"
#include "Filters.h"
#include "TypesParser.h"
#include "DefineButtonSoundTag.h"
#include "SWF.h"
#include "Button.h"

// Forward declarations
namespace gnash {
    class movie_definition;
    class event_id;
    class SWFStream;
    class DisplayObject;
}

namespace gnash {
namespace SWF {


class ButtonRecord
{

public:

    ButtonRecord()
        :
        _blendMode(0),
        _hitTest(false),
        _down(false),
        _over(false),
        _up(false),
        _definitionTag(nullptr),
        _buttonLayer(0)
    {
    }

    ButtonRecord(ButtonRecord&&) = default;

    //
    DisplayObject* instantiate(Button* button, bool name = true) const;

    //
    bool hasState(Button::MouseState st) const;

    //
    void readRGBTransform(SWFStream& in) {
        _cxform = readCxFormRGB(in);
    }

    //
    bool read(SWFStream& in, TagType t, movie_definition& m,
            unsigned long endPos);
    
    //
    bool valid() const {
        return _definitionTag.get();
    }

private:

    //
    Filters _filters;

    //
    std::uint8_t _blendMode;

    bool _hitTest;
    bool _down;
    bool _over;
    bool _up;

    // This is a ref-counted resource, so not owned by anyone.
    boost::intrusive_ptr<const DefinitionTag> _definitionTag;

    int _buttonLayer;

    SWFMatrix _matrix;

    SWFCxForm _cxform;

};
    
class ButtonAction
{
public:

    // TODO: define ownership of list elements !!
    action_buffer _actions;

    ButtonAction(SWFStream& in, TagType t, unsigned long endPos,
            movie_definition& mdef);

    bool triggeredBy(const event_id& ev) const;

    bool triggeredByKeyPress() const {
        return (_conditions & KEYPRESS);
    }

    //
    int getKeyCode() const {
        return (_conditions & KEYPRESS) >> 9;
    }

private:

    enum Condition
    {
        IDLE_TO_OVER_UP = 1 << 0,
        OVER_UP_TO_IDLE = 1 << 1,
        OVER_UP_TO_OVER_DOWN = 1 << 2,
        OVER_DOWN_TO_OVER_UP = 1 << 3,
        OVER_DOWN_TO_OUT_DOWN = 1 << 4,
        OUT_DOWN_TO_OVER_DOWN = 1 << 5,
        OUT_DOWN_TO_IDLE = 1 << 6,
        IDLE_TO_OVER_DOWN = 1 << 7,
        OVER_DOWN_TO_IDLE = 1 << 8,
        KEYPRESS = 0xFE00  // highest 7 bits
    };

    std::uint16_t _conditions;

};

class DefineButtonTag : public DefinitionTag
{
public:

    static void loader(SWFStream& in, TagType tag, movie_definition& m, 
            const RunResources& r);

    typedef std::vector<ButtonRecord> ButtonRecords; 
    typedef boost::ptr_vector<ButtonAction> ButtonActions;

    virtual ~DefineButtonTag();

    DisplayObject* createDisplayObject(Global_as& gl, DisplayObject* parent)
        const;

    ButtonRecords& buttonRecords() { return _buttonRecords; }
    
    const ButtonRecords& buttonRecords() const { return _buttonRecords; }

    bool hasSound() const { return (_soundTag.get()); }

    void addSoundTag(std::unique_ptr<SWF::DefineButtonSoundTag> soundTag) {
        // Do not replace a sound tag.
        assert(!_soundTag.get());
        _soundTag.reset(soundTag.release());
    }

    //
    const DefineButtonSoundTag::ButtonSound& buttonSound(size_t index) const {
        assert(_soundTag.get());
        return _soundTag->getSound(index);
    }

    int getSWFVersion() const;

    bool trackAsMenu() const {
        return _trackAsMenu;
    }

    bool hasKeyPressHandler() const;

    //
    template <class E>
    void forEachTrigger(const event_id& ev, E& f) const {
        for (size_t i = 0, e = _buttonActions.size(); i < e; ++i) {
            const ButtonAction& ba = _buttonActions[i];
            if (ba.triggeredBy(ev)) f(ba._actions);
        }
    }

    //
    template<class E>
    void visitKeyCodes(E& f) const {
        std::for_each(_buttonActions.begin(), _buttonActions.end(),
            std::bind(f, std::bind(
                    std::mem_fn(&ButtonAction::getKeyCode), std::placeholders::_1)));
    }
    
private:

    friend class DefineButton2Tag;

    //
    DefineButtonTag(SWFStream& in, movie_definition& m, TagType tag, 
            std::uint16_t id);

    void readDefineButtonTag(SWFStream& in, movie_definition& m);

    void readDefineButton2Tag(SWFStream& in, movie_definition& m);

    std::unique_ptr<SWF::DefineButtonSoundTag> _soundTag;

    ButtonRecords _buttonRecords;

    ButtonActions _buttonActions;

    bool _trackAsMenu;

    movie_definition& _movieDef;
};

//
class DefineButton2Tag
{
public:
    static void loader(SWFStream& in, TagType tag, movie_definition& m, 
            const RunResources& r);
};

}
}    // end namespace gnash


#endif // GNASH_BUTTON_CHARACTER_DEF_H


// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: