/*
 * Copyright 2006-2007, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */
#ifndef GRADIENT_TRANSFORMABLE_H
#define GRADIENT_TRANSFORMABLE_H


#ifdef ICON_O_MATIC
# include <Archivable.h>
# include <Referenceable.h>

# include "Observable.h"
#endif // ICON_O_MATIC

#include "IconBuild.h"
#include "Transformable.h"

#include <GraphicsDefs.h>
#include <Gradient.h>
#include <List.h>

class BMessage;

enum gradients_type {
	GRADIENT_LINEAR = 0,
	GRADIENT_CIRCULAR,
	GRADIENT_DIAMOND,
	GRADIENT_CONIC,
	GRADIENT_XY,
	GRADIENT_SQRT_XY
};

enum interpolation_type {
	INTERPOLATION_LINEAR = 0,
	INTERPOLATION_SMOOTH
};


_BEGIN_ICON_NAMESPACE


#ifdef ICON_O_MATIC
class Gradient : public BArchivable,
				 public Observable,
				 public BReferenceable,
				 public Transformable {
#else
class Gradient : public Transformable {
#endif

 public:
								Gradient(bool empty = false);
								Gradient(BMessage* archive);
								Gradient(const Gradient& other);
	virtual						~Gradient();

#ifdef ICON_O_MATIC
			status_t			Archive(BMessage* into, bool deep = true) const;
#else
	inline	void				Notify() {}
#endif

			Gradient&			operator=(const Gradient& other);

			bool				operator==(const Gradient& other) const;
			bool				operator!=(const Gradient& other) const;
			bool				ColorStepsAreEqual(
									const Gradient& other) const;

			void				SetColors(const Gradient& other);


			int32				AddColor(const rgb_color& color, float offset);
			bool				AddColor(const BGradient::ColorStop& color,
									int32 index);

			bool				RemoveColor(int32 index);

			bool				SetColor(int32 index,
									const BGradient::ColorStop& step);
			bool				SetColor(int32 index, const rgb_color& color);
			bool				SetOffset(int32 index, float offset);

			int32				CountColors() const;
			BGradient::ColorStop* ColorAt(int32 index) const;
			BGradient::ColorStop* ColorAtFast(int32 index) const;

			void				SetType(gradients_type type);
			gradients_type		Type() const
									{ return fType; }

			void				SetInterpolation(interpolation_type type);
			interpolation_type		Interpolation() const
									{ return fInterpolation; }

			void				SetInheritTransformation(bool inherit);
			bool				InheritTransformation() const
									{ return fInheritTransformation; }

			void				MakeGradient(uint32* colors,
											 int32 count) const;

			void				FitToBounds(const BRect& bounds);
			BRect				GradientArea() const;
	virtual	void				TransformationChanged();

			void				PrintToStream() const;

 private:
			void				_MakeEmpty();

			BList				fColors;
			gradients_type		fType;
			interpolation_type	fInterpolation;
			bool				fInheritTransformation;
};


_END_ICON_NAMESPACE


#endif	// GRADIENT_TRANSFORMABLE_H