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


#ifdef ICON_O_MATIC
#	include "IconObject.h"
#	include "Observer.h"
#endif
#include "Container.h"
#include "IconBuild.h"
#include "PathSource.h"
#include "Transformable.h"
#include "VectorPath.h"

#include <List.h>
#include <Rect.h>


class BMessage;

_BEGIN_ICON_NAMESPACE

class Style;


#ifdef ICON_O_MATIC
// TODO: merge Observer and ShapeListener interface
// ie add "AppearanceChanged(Shape* shape)"
class ShapeListener {
 public:
								ShapeListener();
	virtual						~ShapeListener();

	// TODO: this is not useful for all subclasses of Shape (e.g. ReferenceImage)
	virtual	void				StyleChanged(Style* oldStyle,
											 Style* newStyle) = 0;
};
#endif // ICON_O_MATIC

#ifdef ICON_O_MATIC
class Shape : public IconObject,
			  public _ICON_NAMESPACE Transformable,
			  public Observer,	// observing all the paths and the style
			  public ContainerListener<VectorPath>,
			  public ContainerListener<Transformer>,
			  public PathListener {
#else
class Shape : public _ICON_NAMESPACE Transformable,
			  public ContainerListener<Transformer> {
#endif

 public:
									Shape(_ICON_NAMESPACE Style* style);
									Shape(const Shape& other);
	virtual							~Shape();

	// IconObject interface
	virtual	status_t				Unarchive(BMessage* archive);
#ifdef ICON_O_MATIC
	virtual	status_t				Archive(BMessage* into,
											bool deep = true) const;

	virtual	PropertyObject*			MakePropertyObject() const;
	virtual	bool					SetToPropertyObject(
										const PropertyObject* object);

	// Transformable interface
	virtual	void					TransformationChanged();

	// Observer interface
	virtual	void					ObjectChanged(const Observable* object);

	// ContainerListener<VectorPath> interface
	virtual	void					ItemAdded(VectorPath* path, int32 index);
	virtual	void					ItemRemoved(VectorPath* path);

	// PathListener interface
	virtual	void					PointAdded(int32 index);
	virtual	void					PointRemoved(int32 index);
	virtual	void					PointChanged(int32 index);
	virtual	void					PathChanged();
	virtual	void					PathClosedChanged();
	virtual	void					PathReversed();
#else
	inline	void					Notify() {}
#endif // ICON_O_MATIC

	// ContainerListener<Transformer> interface
	virtual	void					ItemAdded(Transformer* t, int32 index);
	virtual	void					ItemRemoved(Transformer* t);

	// Shape
	virtual	status_t				InitCheck() const;
	virtual Shape*					Clone() const = 0;

	inline	Container<VectorPath>*	Paths() const
									{ return fPaths; }
	const	Container<Transformer>*	Transformers() const
									{ return &fTransformers; }
			Container<Transformer>* Transformers()
									{ return &fTransformers; }

      public:
	inline	_ICON_NAMESPACE Style*	Style() const
										{ return fStyle; }

	inline	BRect					LastBounds() const
										{ return fLastBounds; }
			BRect					Bounds(bool updateLast = false) const;

			_ICON_NAMESPACE VertexSource&	VertexSource();
			void					SetGlobalScale(double scale);

			void					SetHinting(bool hinting);
			bool					Hinting() const
										{ return fHinting; }

	virtual bool					Visible(float scale) const = 0;

#ifdef ICON_O_MATIC
			bool					AddListener(ShapeListener* listener);
			bool					RemoveListener(ShapeListener* listener);

 private:
			void					_NotifyStyleChanged(_ICON_NAMESPACE Style* oldStyle,
														_ICON_NAMESPACE Style* newStyle) const;

			void					_NotifyRerender() const;
#endif // ICON_O_MATIC

 protected:
			void					SetStyle(_ICON_NAMESPACE Style* style);

 private:
			Container<VectorPath>*	fPaths;
			_ICON_NAMESPACE Style*	fStyle;

			PathSource				fPathSource;
			Container<Transformer>	fTransformers;
	mutable	bool					fNeedsUpdate;

	mutable	BRect					fLastBounds;

			bool					fHinting;

#ifdef ICON_O_MATIC
			BList					fListeners;
#endif
};

_END_ICON_NAMESPACE


#endif	// SHAPE_H