haiku.git

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


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

#include <agg_path_storage.h>

#include <Rect.h>
#include <String.h>

#ifdef ICON_O_MATIC
#	include "IconObject.h"

#	include <Archivable.h>
#	include <List.h>
#endif // ICON_O_MATIC

class BBitmap;
class BMessage;
class BView;


_BEGIN_ICON_NAMESPACE


struct control_point {
	BPoint		point;		// actual point on path
	BPoint		point_in;	// control point for incomming curve
	BPoint		point_out;	// control point for outgoing curve
	bool		connected;	// if all 3 points should be on one line
};

#ifdef ICON_O_MATIC
class PathListener {
 public:
								PathListener();
	virtual						~PathListener();

	virtual	void				PointAdded(int32 index) = 0;
	virtual	void				PointRemoved(int32 index) = 0;
	virtual	void				PointChanged(int32 index) = 0;
	virtual	void				PathChanged() = 0;
	virtual	void				PathClosedChanged() = 0;
	virtual	void				PathReversed() = 0;
};

class VectorPath : public BArchivable,
				   public IconObject {
#else
class VectorPath {
#endif // ICON_O_MATIC
 public:

	class Iterator {
	 public:
								Iterator() {}
		virtual					~Iterator() {}

		virtual	void			MoveTo(BPoint point) = 0;
		virtual	void			LineTo(BPoint point) = 0;
	};

								VectorPath();
								VectorPath(const VectorPath& from);
								VectorPath(BMessage* archive);

	virtual						~VectorPath();

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

	virtual	PropertyObject*		MakePropertyObject() const;
	virtual	bool				SetToPropertyObject(
									const PropertyObject* object);
#else
	inline	void				Notify() {}
#endif // ICON_O_MATIC

	// VectorPath
			VectorPath&			operator=(const VectorPath& from);
			bool				operator==(const VectorPath& from) const;

			void				MakeEmpty();

			bool				AddPoint(BPoint point);
			bool				AddPoint(const BPoint& point,
										 const BPoint& pointIn,
										 const BPoint& pointOut,
										 bool connected);
			bool				AddPoint(BPoint point, int32 index);

			bool				RemovePoint(int32 index);

								// modify existing points position
			bool				SetPoint(int32 index, BPoint point);
			bool				SetPoint(int32 index, BPoint point,
													  BPoint pointIn,
													  BPoint pointOut,
													  bool connected);
			bool				SetPointIn(int32 index, BPoint point);
			bool				SetPointOut(int32 index, BPoint point,
										   bool mirrorDist = false);

			bool				SetInOutConnected(int32 index, bool connected);

								// query existing points position
			bool				GetPointAt(int32 index, BPoint& point) const;
			bool				GetPointInAt(int32 index, BPoint& point) const;
			bool				GetPointOutAt(int32 index, BPoint& point) const;
			bool				GetPointsAt(int32 index,
											BPoint& point,
											BPoint& pointIn,
											BPoint& pointOut,
											bool* connected = NULL) const;

			int32				CountPoints() const;

#ifdef ICON_O_MATIC
								// iterates over curve segments and returns
								// the distance and index of the point that
								// started the segment that is closest
			bool				GetDistance(BPoint point,
											float* distance, int32* index) const;

								// at curve segment indicated by "index", this
								// function looks for the closest point
								// directly on the curve and returns a "scale"
								// that indicates the distance on the curve
								// between [0..1]
			bool				FindBezierScale(int32 index, BPoint point,
												double* scale) const;
								// this function can be used to get a point
								// directly on the segment indicated by "index"
								// "scale" is on [0..1] indicating the distance
								// from the start of the segment to the end
			bool				GetPoint(int32 index, double scale,
										 BPoint& point) const;
#endif // ICON_O_MATIC

			void				SetClosed(bool closed);
			bool				IsClosed() const
									{ return fClosed; }

			BRect				Bounds() const;
			BRect				ControlPointBounds() const;

			void				Iterate(Iterator* iterator,
										float smoothScale = 1.0) const;

			void				CleanUp();
			void				Reverse();
			void				ApplyTransform(const Transformable& transform);

			void				PrintToStream() const;

			bool				GetAGGPathStorage(agg::path_storage& path) const;

#ifdef ICON_O_MATIC
			bool				AddListener(PathListener* listener);
			bool				RemoveListener(PathListener* listener);
			int32				CountListeners() const;
			PathListener*		ListenerAtFast(int32 index) const;
#endif // ICON_O_MATIC


 private:
			BRect				_Bounds() const;
			void				_SetPoint(int32 index, BPoint point);
			void				_SetPoint(int32 index,
										  const BPoint& point,
										  const BPoint& pointIn,
										  const BPoint& pointOut,
										  bool connected);
			bool				_SetPointCount(int32 count);

#ifndef ICON_O_MATIC
	inline	void				_NotifyPointAdded(int32 index) const {}
	inline	void				_NotifyPointChanged(int32 index) const {}
	inline	void				_NotifyPointRemoved(int32 index) const {}
	inline	void				_NotifyPathChanged() const {}
	inline	void				_NotifyClosedChanged() const {}
	inline	void				_NotifyPathReversed() const {}
#else
			void				_NotifyPointAdded(int32 index) const;
			void				_NotifyPointChanged(int32 index) const;
			void				_NotifyPointRemoved(int32 index) const;
			void				_NotifyPathChanged() const;
			void				_NotifyClosedChanged() const;
			void				_NotifyPathReversed() const;

			BList				fListeners;
#endif // ICON_O_MATIC

			control_point*		fPath;
			bool				fClosed;

			int32				fPointCount;
			int32				fAllocCount;

	mutable	BRect				fCachedBounds;
};


_END_ICON_NAMESPACE


#endif	// VECTOR_PATH_H