BitmapData_as.h

Go to the documentation of this file.

// BitmapData_as.h:  ActionScript "BitmapData" class, for Gnash.
//
//   Copyright (C) 2005, 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_ASOBJ_BITMAPDATA_H
#define GNASH_ASOBJ_BITMAPDATA_H

#include <list>
#include <cstdint>
#include <memory>
#include <cassert>
#include <boost/intrusive_ptr.hpp>
#include <memory>

#include "Relay.h"
#include "CachedBitmap.h"
#include "GnashImage.h"
#include "ImageIterators.h"

namespace gnash {
    class as_object;
    struct ObjectURI;
    class MovieClip;
    class Transform;
    class DisplayObject;
    namespace image {
        class GnashImage;
    }
}

namespace gnash {

//
//
//
class BitmapData_as : public Relay
{
public:

    enum Channel {
        CHANNEL_RED = 1,
        CHANNEL_GREEN = 2,
        CHANNEL_BLUE = 4,
        CHANNEL_ALPHA = 8
    };

    typedef image::pixel_iterator<image::ARGB> iterator;

    //
        BitmapData_as(as_object* owner, std::unique_ptr<image::GnashImage> im);

    virtual ~BitmapData_as() {}

    //
    size_t width() const {
        assert(data());
        return data()->width();
    }
    
    //
    size_t height() const {
        assert(data());
        return data()->height();
    }

    //
    bool transparent() const {
        assert(data());
        return (data()->type() == image::TYPE_RGBA);
    }

    //
    const CachedBitmap* bitmapInfo() const {
        return _cachedBitmap.get();
    }

    //
    void dispose();
    
    void draw(MovieClip& mc, const Transform& transform);

    //
    void attach(DisplayObject* obj) {
        _attachedObjects.push_back(obj);
    }

    virtual void setReachable();

    //
    bool disposed() const {
        return !data();
    }
 
    iterator begin() const {
        assert(!disposed());
        return image::begin<image::ARGB>(*data());
    }
    
    iterator end() const {
        assert(!disposed());
        return image::end<image::ARGB>(*data());
    }

    void updateObjects() const;

private:
    
    image::GnashImage* data() const {
        return _cachedBitmap.get() ? &_cachedBitmap->image() : _image.get();
    }

    as_object* _owner;

    boost::intrusive_ptr<CachedBitmap> _cachedBitmap;

    std::unique_ptr<image::GnashImage> _image;

    std::list<DisplayObject*> _attachedObjects;

};

void bitmapdata_class_init(as_object& where, const ObjectURI& uri);

void registerBitmapDataNative(as_object& global);

} // end of gnash namespace

#endif