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 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 <boost/cstdint.hpp>
#include <boost/scoped_ptr.hpp>
#include <cassert>
#include "smart_ptr.h"
#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:

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

    //
        BitmapData_as(as_object* owner, std::auto_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 setPixel(size_t x, size_t y, boost::uint32_t color) const;

    void setPixel32(size_t x, size_t y, boost::uint32_t color) const;

    //
    boost::uint32_t getPixel(size_t x, size_t y) const;

    //
    void fillRect(int x, int y, int w, int h, boost::uint32_t color);

    void floodFill(size_t x, size_t y, boost::uint32_t old,
            boost::uint32_t fill);
    
    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());
    }

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

    void updateObjects();

    as_object* _owner;

    boost::intrusive_ptr<CachedBitmap> _cachedBitmap;

    boost::scoped_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