FillStyle.h

Go to the documentation of this file.

// FillStyle.h: variant fill styles
// 
//   Copyright (C) 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_FILL_STYLE_H
#define GNASH_FILL_STYLE_H

#include <boost/variant.hpp>
#include <vector> 
#include <iosfwd> 
#include <boost/intrusive_ptr.hpp>
#include <cassert>

#include "SWFMatrix.h"
#include "SWF.h"
#include "RGBA.h" 

namespace gnash {
    class movie_definition;
    class CachedBitmap;
}

namespace gnash {

class GradientRecord
{
public:
    GradientRecord(std::uint8_t ratio, rgba color)
        :
        ratio(ratio),
        color(std::move(color))
    { }
    
    //data:
    std::uint8_t ratio;
    rgba color;
};

//
//
//
//
//
class DSOEXPORT BitmapFill
{
public:

    enum SmoothingPolicy {
        SMOOTHING_UNSPECIFIED,
        SMOOTHING_ON,
        SMOOTHING_OFF
    };
    
    //
    enum Type {
        CLIPPED,
        TILED
    };

    //
    BitmapFill(Type t, const CachedBitmap* bi, SWFMatrix m,
            SmoothingPolicy pol);

    BitmapFill(SWF::FillType t, movie_definition* md, std::uint16_t id,
            SWFMatrix m);

    ~BitmapFill();

    //
    BitmapFill(const BitmapFill& other);
    
    BitmapFill& operator=(const BitmapFill& other);

    void setLerp(const BitmapFill& a, const BitmapFill& b, double ratio);

    //
    Type type() const {
        return _type;
    }

    SmoothingPolicy smoothingPolicy() const {
        return _smoothingPolicy;
    }

    const CachedBitmap* bitmap() const;

    const SWFMatrix& matrix() const {
        return _matrix;
    }

private:

    Type _type;

    SmoothingPolicy _smoothingPolicy;

    SWFMatrix _matrix;
    
    mutable boost::intrusive_ptr<const CachedBitmap> _bitmapInfo;

    movie_definition* _md;

    // The id of the tag containing the bitmap
    std::uint16_t _id;
};

class DSOEXPORT GradientFill
{
public:

    //
    enum Type {
        LINEAR,
        RADIAL
    };

    enum SpreadMode {
        PAD,
        REPEAT,
        REFLECT
    };

    enum InterpolationMode {
        RGB,
        LINEAR_RGB
    };

    typedef std::vector<GradientRecord> GradientRecords;

    //
    //
    GradientFill(Type t, const SWFMatrix& m,
            const GradientRecords& = GradientRecords());

    Type type() const {
        return _type;
    }

    const SWFMatrix& matrix() const {
        return _matrix;
    }

    void setLerp(const GradientFill& a, const GradientFill& b, double ratio);
    
    void setRecords(const GradientRecords& recs) {
        assert(recs.size() > 1);
        _gradients = recs;
    }

    const GradientRecords &getRecords() const {
        return _gradients;
    }

    size_t recordCount() const {
        return _gradients.size();
    }

    //
    const GradientRecord& record(size_t i) const {
        assert(i < _gradients.size());
        return _gradients[i];
    }

    //
    void setFocalPoint(double d);

    //
    double focalPoint() const {
        return _focalPoint;
    }

    SpreadMode spreadMode;
    InterpolationMode interpolation;

private:

    double _focalPoint;
    GradientRecords _gradients;
    Type _type;
    SWFMatrix _matrix;
};

//
struct DSOEXPORT SolidFill
{
public:

    explicit SolidFill(rgba c)
        :
        _color(std::move(c))
    { }

    SolidFill(const SolidFill& other)
        :
        _color(other._color)
    { }

    void setLerp(const SolidFill& a, const SolidFill& b, double ratio) {
        _color = lerp(a.color(), b.color(), ratio);
    }

    rgba color() const {
        return _color;
    }

private:
    rgba _color;
};

//
class DSOEXPORT FillStyle 
{
public:

    typedef boost::variant<BitmapFill, SolidFill, GradientFill> Fill;
    
    //
    template<typename T> FillStyle(const T& f) : fill(f) {}

    FillStyle(const FillStyle& other)
        :
        fill(other.fill)
    { }

    Fill fill;

};
 
//
void setLerp(FillStyle& f, const FillStyle& a, const FillStyle& b, double t);

DSOEXPORT std::ostream& operator<<(std::ostream& os,
        const BitmapFill::SmoothingPolicy& p);

std::ostream& operator<<(std::ostream& os, const FillStyle& fs);

std::ostream& operator<<(std::ostream& o, GradientFill::Type t);

std::ostream& operator<<(std::ostream& o, GradientFill::SpreadMode t);

std::ostream& operator<<(std::ostream& o, GradientFill::InterpolationMode t);

} // namespace gnash

#endif

// Local Variables:
// mode: C++
// indent-tabs-mode: nil
// End: