as_prop_flags.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008 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_AS_PROP_FLAGS_H
#define GNASH_AS_PROP_FLAGS_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

namespace gnash {

class as_prop_flags
{

        int _flags;

        bool _protected;

public:

        enum Flags {

                dontEnum        = 1 << 0,

                dontDelete      = 1 << 1,

                readOnly        = 1 << 2,

                staticProp      = 1 << 3,

                isProtected     = 1 << 4,

                onlySWF6Up      = 1 << 7, // 128

                ignoreSWF6      = 1 << 8, // 256

                onlySWF7Up      = 1 << 10, // 1024

                onlySWF8Up      = 1 << 12 // 4096

        };

        //
        static const int as_prop_flags_mask = dontEnum|dontDelete|readOnly|onlySWF6Up|ignoreSWF6|onlySWF7Up|onlySWF8Up;


        as_prop_flags() : _flags(0)
        {
        }

        as_prop_flags(const bool read_only, const bool dont_delete, const bool dont_enum)
                :
                _flags(((read_only) ? readOnly : 0) |
                                ((dont_delete) ? dontDelete : 0) |
                                ((dont_enum) ? dontEnum : 0))
        {
        }

        as_prop_flags(const int flags)
                : _flags(flags)
        {
        }

        bool operator== (const as_prop_flags& o) const
        {
                return ( _flags == o._flags );
        }

        bool operator!= (const as_prop_flags& o) const
        {
                return ( _flags != o._flags );
        }

        bool get_static() const { return (_flags & staticProp) ? true : false; }

        void set_static() { _flags |= staticProp; }

        void clear_static() { _flags &= ~staticProp; }

        bool get_read_only() const { return (((_flags & readOnly)!=0)?true:false); }

        void set_read_only() { _flags |= readOnly; }

        void clear_read_only() { _flags &= ~readOnly; }

        bool get_dont_delete() const { return (((_flags & dontDelete)!=0)?true:false); }

        void set_dont_delete() { _flags |= dontDelete; }

        void clear_dont_delete() { _flags &= ~dontDelete; }

        bool get_dont_enum() const { return (((_flags & dontEnum)!=0)?true:false);      }

        void set_dont_enum() { _flags |= dontEnum; }

        void clear_dont_enum() { _flags &= ~dontEnum; }

        bool get_visible(int swfVersion) const
        {
                if ( _flags & onlySWF6Up && swfVersion  < 6 ) return false;
                if ( _flags & ignoreSWF6 && swfVersion == 6 ) return false;
                if ( _flags & onlySWF7Up && swfVersion  < 7 ) return false;
                if ( _flags & onlySWF8Up && swfVersion < 8 ) return false;
                return true;
        }

        void clear_visible(int swfVersion) 
        {
                if ( swfVersion == 6)
                {
                        // version 6, so let's forget SWFDEC_AS_VARIABLE_VERSION_7_UP flag, oops!
                        // we will still set the value though, even if that flag is set
                        _flags &= ~(onlySWF6Up|ignoreSWF6|onlySWF8Up);
                }
                else
                {
                        _flags &= ~(onlySWF6Up|ignoreSWF6|onlySWF7Up|onlySWF8Up);
                }
        }

        int get_flags() const { return _flags; }

        bool get_is_protected() const { return (_flags & isProtected) ? true : false; }

        //
        void set_is_protected(const bool is_protected)
        {
                if (is_protected)
                        _flags |= isProtected;
                else
                        _flags &= ~isProtected;
        }

        bool set_flags(const int setTrue, const int setFalse = 0)
        {
                if (get_is_protected()) return false;

                _flags &= ~setFalse;
                _flags |= setTrue;

                return true;
        }
};



} // namespace gnash

#endif // GNASH_AS_PROP_FLAGS_H

---