#pragma once

#ifndef TCOLORSTYLES_H

#define TCOLORSTYLES_H

// TnzCore includes

#include "tfilepath.h"

#include "traster.h"

// Qt includes

#include <qstring></qstring>

#undef DVAPI

#undef DVVAR

#ifdef TVRENDER_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//=================================================

//    Forward declarations

class TStroke;

class TRegion;

class TStrokeProp;

class TRegionProp;

class TVectorRenderData;

class TFlash;

class TInputStreamInterface;

class TOutputStreamInterface;

class TRasterStyleFx;

class QStringList;

//=================================================

//************************************************************************

//    TRasterStyleFx  definition

//************************************************************************

class DVAPI TRasterStyleFx

{

public:

	struct Params {

		TRasterP m_r;

		TPoint m_p;

		TRasterP m_rOrig;

		int m_colorIndex;

		int m_frame;

	public:

		Params(const TRasterP &r, const TPoint &p,

			   const TRasterP &rOrig, int index, int frame)

			: m_r(r), m_p(p), m_rOrig(rOrig), m_colorIndex(index), m_frame(frame)

		{

			assert(m_r);

		}

	};

public:

	virtual ~TRasterStyleFx() {}

	virtual bool isInkStyle() const = 0;

	virtual bool isPaintStyle() const = 0;

	virtual bool inkFxNeedRGBMRaster() const

	{

		return false;

	}

	virtual bool compute(const Params ¶ms) const = 0;

	virtual void getEnlargement(int &borderIn, int &borderOut) const

	{

		borderIn = borderOut = 0;

	}

};

//************************************************************************

//    TColorStyle  definition

//************************************************************************

/*!

  \brief Abstract class representing a color style in a Toonz palette.

*/

class DVAPI TColorStyle : public TSmartObject

{

public:

	//! Helper class to declare color styles

	class Declaration

	{

	public:

		Declaration(TColorStyle *style)

		{

			declare(style);

		}

	};

	enum ParamType {

		BOOL,	//!< Boolean parameter type.

		INT,	 //!< Integer parameter type.

		ENUM,	//!< Enum parameter type (maps to integer values).

		DOUBLE,  //!< Double parameter type (getParamType() default).

		FILEPATH //!< TFilePath parameter type.

	};

	struct double_tag {

	};

	struct bool_tag {

	};

	struct int_tag {

	};

	struct TFilePath_tag {

	};

private:

	std::wstring m_name;		 //!< User-define style name.

	std::wstring m_globalName;   //!< User-define style \a global name.

	std::wstring m_originalName; //!< If the style is copied from studio palette, its original name is stored

	int m_versionNumber; //!< Style's version number.

	unsigned int m_flags; //!< Style attributes.

	bool m_enabled;		  //!< Style's \a enabled status.

	bool m_isEditedFromOriginal; //

								 //!  style is edited from the original one.

protected:

	TRaster32P m_icon; //!< Icon shown on TPalette viewers.

	bool m_validIcon;  //!< Icon's validity status.

public:

	static int m_currentFrame; //!< Time instant in the palette's timeline.

							   //!  \deprecated  Should be done better

public:

	TColorStyle();

	TColorStyle(const TColorStyle &other); //!< Copies another style \a except its icon

	virtual ~TColorStyle();

	virtual TColorStyle *clone() const = 0;				//!< Polymorphic clone of the style.

	virtual TColorStyle ©(const TColorStyle &other) //!< Polymorphic copy of the style.

	{

		assignBlend(other, other, 0.0);

		return *this;

	}

	bool operator==(const TColorStyle &cs) const;

	bool operator!=(const TColorStyle &cs) { return !operator==(cs); }

	// Renderizer-related  objects

	virtual TStrokeProp *makeStrokeProp(const TStroke *stroke) = 0; //!< Allocates a \a new derived TStrokeProp instance

																	//!  used to draw the style on the specified stroke object.

	virtual TRegionProp *makeRegionProp(const TRegion *region) = 0; //!< Allocates a \a new derived TRegionProp instance

																	//!  used to draw the style on the specified region object.

	virtual bool isRasterStyle() const { return false; }	 //!< Returns whether the style is of the raster kind.

	virtual TRasterStyleFx *getRasterStyleFx() { return 0; } //!< If the style contains raster effects it must return it,

															 //!  else returns 0.

	virtual bool isRegionStyle() const = 0; //!< Returns whether the style applies on regions.

	virtual bool isStrokeStyle() const = 0; //!< Returns whether the style applies on strokes.

	// General functions

	void setName(std::wstring name) { m_name = name; } //!< Sets the style's user-defined name.

	std::wstring getName() const { return m_name; }	//!< Returns the style's user-defined name.

	/*! \detail

    The \a global name contains information about palette id.

  */

	void setGlobalName(std::wstring name) { m_globalName = name; } //!< Sets the global name of the style.

	std::wstring getGlobalName() const { return m_globalName; }	//!< Returns the global name of the style.

	void setOriginalName(std::wstring name) { m_originalName = name; } //!< If the style is originally copied from studio palette, set this.

	std::wstring getOriginalName() const { return m_originalName; }	//!< Returns the original name of the style.

	void setIsEditedFlag(bool edited) { m_isEditedFromOriginal = edited; } //

																		   //!  style is edited from the original one.

	bool getIsEditedFlag() const { return m_isEditedFromOriginal; }		   //!< Returns whether the style is edited from the original from studio palette

	void assignNames(const TColorStyle *src); //!< Copies the style names from src.

	//! \sa tcolorflags.h

	unsigned int getFlags() const { return m_flags; }	  //!< Sets color attributes.

	void setFlags(unsigned int flags) { m_flags = flags; } //!< Returns color attributes.

	// Color-related functions

	/*! \detail

    Raster or vector pattern image styles, for example, return false.

  */

	virtual bool hasMainColor() const { return false; }				  //!< Returns whether the style has a reference \a main color.

	virtual TPixel32 getMainColor() const { return TPixel32::Black; } //!< Returns the style's main color, or black if none.

	virtual void setMainColor(const TPixel32 &color) {}				  //!< Sets the main color, if it has one.

	/*! \detail

    For example a bubble styles has two colors.

    By default it returns \p 1 if the style has only a main color else 

    returns \p 0 if the style has no color.

  */

	virtual int getColorParamCount() const

	{

		return hasMainColor() ? 1 : 0;

	} //!< Returns the number of colors (if any) of the style.

	/*! \detail

    Returns the main color by default.

  */

	virtual TPixel32 getColorParamValue(int index) const

	{

		return getMainColor();

	} //!< Returns the value of the color of index \e index.

	virtual void setColorParamValue(int index, const TPixel32 &color)

	{

		setMainColor(color);

	} //!< Sets the \a index-th color value.

	virtual TPixel32 getAverageColor() const

	{

		return getMainColor();

	} //!< Returns a color representing the average of all the style's colors

	// Parameters-related functions

	/*! \detail

	 For example: a the general cleanup style has two parameters, brightness and contrast and 

	 a black cleanup style has in addition a black and white threshold, therefore 4 parameters.

  */

	virtual int getParamCount() const { return 0; } //!< Returns the number of parameters necessary

													//!  to describe the style.

	virtual ParamType getParamType(int paramIdx) const

	{

		assert(0 <= paramIdx && paramIdx < getParamCount());

		return DOUBLE;

	} //!< Returns the type of the specified parameter.

	virtual void setParamValue(int index, bool value)

	{

		assert(false);

	} //!< Assigns a value to the specified \p bool parameter.

	virtual bool getParamValue(bool_tag, int index) const

	{

		assert(false);

		return bool();

	} //!< Retrieves the specified \p bool parameter value.

	virtual void setParamValue(int index, int value)

	{

		assert(false);

	} //!< Assigns a value to the specified \p int parameter.

	virtual int getParamValue(int_tag, int index) const

	{

		assert(false);

		return int();

	} //!< Retrieves the specified \p int parameter value.

	virtual void getParamRange(int index, int &min, int &max) const

	{

		assert(false);

	} //!< Retrieves the specified \p int parameter range.

	virtual void getParamRange(int pIndex, QStringList &stringItems) const

	{

		assert(false);

	} //!< Returns a description of each supported enum or file

	  //!  extension value in text form.

	virtual void setParamValue(int index, double value)

	{

		assert(false);

	} //!< Assigns a value to the specified \p double parameter.

	virtual double getParamValue(double_tag, int index) const

	{

		assert(false);

		return double();

	} //!< Retrieves the specified \p double parameter value.

	virtual void getParamRange(int index, double &min, double &max) const

	{

		assert(false);

	} //!< Retrieves the specified \p double parameter range.

	virtual void setParamValue(int index, const TFilePath &fp)

	{

		assert(false);

	} //!< Assigns a value to the specified \p TFilePath parameter.

	virtual TFilePath getParamValue(TFilePath_tag, int index) const

	{

		assert(false);

		return TFilePath();

	} //!< Retrieves the specified \p TFilePath parameter value.

	/*! \detail

    This function is provided to animate a palette style. Given two keyframe

    styles \p a and \p b, it calculates their linear interpolation at parameter

    \p t and assigns the result to this style instance.

    \param a    Style value at parameter <tt>t = 0</tt>.

    \param b    Style value at parameter <tt>t = 1</tt>.

    \param t    Interpolation parameter.

  */

	void assignBlend(const TColorStyle &a, const TColorStyle &b, double t); //!< Assigns the linear interpolation between the

																			//!  supplied styles.

	// Description-related functions

	/*! \detail

    For example for a stroke style we have "Constant", "Chain", "Rope", "Tulle", etc...

  */

	virtual QString getDescription() const = 0;		//!< Return a brief description of the style.

	virtual QString getParamNames(int index) const; //!< Return the string that identifies the \a index-th parameter.

	// Drawing-related  functions

	virtual void drawStroke(TFlash &flash, const TStroke *stroke) const; //!< Draws the supplied stroke in flash.

	// I/O-related  functions

	virtual int getTagId() const = 0;						//!< Returns an unique number representing the style.

	virtual void getObsoleteTagIds(std::vector<int> &) const {}; //!< \deprecated</int>

	void save(TOutputStreamInterface &) const;		   //!< Calls the local implementation of saveData() passing it also the name and the tagId of the style.

	static TColorStyle *load(TInputStreamInterface &); //!< Loads the style from disk. Calls the local implementation of loadData().

	static TColorStyle *create(int tagId); //!< Creates a new style with identifier equal to \a tagId.

	static void declare(TColorStyle *style); //!< Puts the style in the table of actual styles.

	static void getAllTags(std::vector<int> &tags);</int>

	// Misc functions

	/*! \detail

    It is used when updates must be done after changes or creation of new styles. 

  */

	void invalidateIcon() { m_validIcon = false; }			//!< Sets a flag that defines the style's icon validity.

	virtual const TRaster32P &getIcon(const TDimension &d); //!< Returns an image representing the style.

	bool isEnabled() const { return m_enabled; } //!< Returns whether the style can be used.

	void enable(bool on) { m_enabled = on; }	 //!< Sets the style's \a enabled status

	int getVersionNumber() const { return m_versionNumber; } //!< Returns the version number of the style.

protected:

	virtual void makeIcon(const TDimension &d);

	virtual void loadData(TInputStreamInterface &) = 0;

	virtual void saveData(TOutputStreamInterface &) const = 0;

	virtual void loadData(int, TInputStreamInterface &) {} //!< \deprecated  Backward compatibility

	void updateVersionNumber();

protected:

	TColorStyle &operator=(const TColorStyle &other); //!< Copies another style \a except its icon

};

//--------------------------------------------------------------------------

#ifdef _WIN32

template class DVAPI TSmartPointerT<tcolorstyle>;</tcolorstyle>

#endif

typedef TSmartPointerT<tcolorstyle> TColorStyleP;</tcolorstyle>

#endif // TCOLORSTYLES_H