/*
 * Copyright 2006 - 2010, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef	ALM_LAYOUT_H
#define	ALM_LAYOUT_H
 
 
#include <AbstractLayout.h>
#include <Size.h>
 
#include "Area.h"
#include "LinearSpec.h"
#include "Tab.h"
 
 
class BView;
class BLayoutItem;
 
 
namespace LinearProgramming {
	class Constraint;
};
 
 
namespace BPrivate {
	class SharedSolver;
};
 
 
namespace BALM {
 
 
class Column;
class ALMGroup;
class Row;
class RowColumnManager;
 
 
/*!
 * A GUI layout engine using the Auckland Layout Model (ALM).
 */
class BALMLayout : public BAbstractLayout {
public:
								BALMLayout(float hSpacing = 0.0f,
									float vSpacing = 0.0f,
									BALMLayout* friendLayout = NULL);
								BALMLayout(BMessage* archive);
	virtual						~BALMLayout();
 
			BReference<XTab>	AddXTab();
			void				AddXTabs(BReference<XTab>* tabs, uint32 count);
			BReference<YTab>	AddYTab();
			void				AddYTabs(BReference<YTab>* tabs, uint32 count);
 
			int32				CountXTabs() const;
			int32				CountYTabs() const;
			XTab*				XTabAt(int32 index, bool ordered = false);
			XTab*				XTabAt(int32 index) const;
			YTab*				YTabAt(int32 index, bool ordered = false);
			YTab*				YTabAt(int32 index) const;
	const	XTabList			GetXTabs() const;
	const	YTabList			GetYTabs() const;
 
			int32				IndexOf(XTab* tab, bool ordered = false);
			int32				IndexOf(YTab* tab, bool ordered = false);
 
			int32				CountConstraints() const;
			Constraint*			ConstraintAt(int32 index) const;
			bool				AddConstraint(Constraint* constraint);
			bool				RemoveConstraint(Constraint* constraint,
									bool deleteConstraint = true);
 
			Constraint*			AddConstraint(double coeff1, Variable* var1,
									OperatorType op, double rightSide,
									double penaltyNeg = -1,
									double penaltyPos = -1);
			Constraint*			AddConstraint(double coeff1, Variable* var1,
									double coeff2, Variable* var2,
									OperatorType op, double rightSide,
									double penaltyNeg = -1,
									double penaltyPos = -1);
			Constraint*			AddConstraint(double coeff1, Variable* var1,
									double coeff2, Variable* var2,
									double coeff3, Variable* var3,
									OperatorType op, double rightSide,
									double penaltyNeg = -1,
									double penaltyPos = -1);
			Constraint*			AddConstraint(double coeff1, Variable* var1,
									double coeff2, Variable* var2,
									double coeff3, Variable* var3,
									double coeff4, Variable* var4,
									OperatorType op, double rightSide,
									double penaltyNeg = -1,
									double penaltyPos = -1);
 
			Row*				AddRow(YTab* top, YTab* bottom);
			Column*				AddColumn(XTab* left, XTab* right);
 
			XTab*				Left() const;
			XTab*				Right() const;
			YTab*				Top() const;
			YTab*				Bottom() const;
 
			LinearProgramming::LinearSpec* Solver() const;
			LinearProgramming::ResultType ValidateLayout();
 
			void				SetInsets(float insets);
			void				SetInsets(float x, float y);
			void				SetInsets(float left, float top, float right,
									float bottom);
			void				GetInsets(float* left, float* top, float* right,
									float* bottom) const;
 
			void				SetSpacing(float hSpacing, float vSpacing);
			void				GetSpacing(float* _hSpacing,
									float* _vSpacing) const;
 
			Area*				AreaFor(int32 id) const;
			Area*				AreaFor(const BView* view) const;
			Area*				AreaFor(const BLayoutItem* item) const;
			int32				CountAreas() const;
			Area*				AreaAt(int32 index) const;
	
			XTab*				LeftOf(const BView* view) const;
			XTab*				LeftOf(const BLayoutItem* item) const;
			XTab*				RightOf(const BView* view) const;
			XTab*				RightOf(const BLayoutItem* item) const;
			YTab*				TopOf(const BView* view) const;
			YTab*				TopOf(const BLayoutItem* item) const;
			YTab*				BottomOf(const BView* view) const;
			YTab*				BottomOf(const BLayoutItem* item) const;
 
	virtual	BLayoutItem*		AddView(BView* child);
	virtual	BLayoutItem*		AddView(int32 index, BView* child);
	virtual	Area*				AddView(BView* view, XTab* left, YTab* top,
									XTab* right = NULL, YTab* bottom = NULL);
	virtual	Area*				AddView(BView* view, Row* row, Column* column);
 
	virtual	bool				AddItem(BLayoutItem* item);
	virtual	bool				AddItem(int32 index, BLayoutItem* item);
	virtual	Area*				AddItem(BLayoutItem* item, XTab* left,
									YTab* top, XTab* right = NULL,
									YTab* bottom = NULL);
	virtual	Area*				AddItem(BLayoutItem* item, Row* row,
									Column* column);
 
	struct BadLayoutPolicy;
 
			void				SetBadLayoutPolicy(BadLayoutPolicy* policy);
			BadLayoutPolicy*	GetBadLayoutPolicy() const;
 
	virtual	BSize				BaseMinSize();
	virtual	BSize				BaseMaxSize();
	virtual	BSize				BasePreferredSize();
	virtual	BAlignment			BaseAlignment();
 
	virtual	status_t 			Archive(BMessage* into, bool deep = true) const;
	static 	BArchivable*		Instantiate(BMessage* archive);
 
	virtual	status_t			Perform(perform_code d, void* arg);
 
protected:
	virtual	bool				ItemAdded(BLayoutItem* item, int32 atIndex);
	virtual	void				ItemRemoved(BLayoutItem* item, int32 fromIndex);
 
	virtual status_t			ItemArchived(BMessage* into, BLayoutItem* item,
									int32 index) const;
	virtual	status_t			ItemUnarchived(const BMessage* from,
									BLayoutItem* item, int32 index);
 
	virtual	status_t 			AllUnarchived(const BMessage* archive);
	virtual	status_t 			AllArchived(BMessage* archive) const;
 
	virtual	void				LayoutInvalidated(bool children);
	virtual	void				DoLayout();
 
public:
	struct BadLayoutPolicy : public BArchivable {
								BadLayoutPolicy();
								BadLayoutPolicy(BMessage* archive);
		virtual					~BadLayoutPolicy();
		/* return false to abandon layout, true to use layout */
		virtual bool			OnBadLayout(BALMLayout* layout,
									LinearProgramming::ResultType result,
									BLayoutContext* context) = 0;
	};
 
	struct DefaultPolicy : public BadLayoutPolicy {
								DefaultPolicy();
								DefaultPolicy(BMessage* archive);
		virtual					~DefaultPolicy();
		virtual bool			OnBadLayout(BALMLayout* layout,
									LinearProgramming::ResultType result,
									BLayoutContext* context);
		virtual status_t		Archive(BMessage* message,
									bool deep = false) const;
		static BArchivable*		Instantiate(BMessage* message);
	};
 
private:
 
	// FBC padding
	virtual	void				_ReservedALMLayout1();
	virtual	void				_ReservedALMLayout2();
	virtual	void				_ReservedALMLayout3();
	virtual	void				_ReservedALMLayout4();
	virtual	void				_ReservedALMLayout5();
	virtual	void				_ReservedALMLayout6();
	virtual	void				_ReservedALMLayout7();
	virtual	void				_ReservedALMLayout8();
	virtual	void				_ReservedALMLayout9();
	virtual	void				_ReservedALMLayout10();
 
	// forbidden methods
								BALMLayout(const BALMLayout&);
			void				operator =(const BALMLayout&);
 
private:
	template <class T>
	struct TabAddTransaction;
 
	template <class T>
	friend class TabAddTransaction;
	friend class BPrivate::SharedSolver;
 
	friend class XTab;
	friend class YTab;
	friend class Area;
 
			class BALMLayoutSpecListener;
	friend	class BALMLayoutSpecListener;
			
			float				InsetForTab(XTab* tab) const;
			float				InsetForTab(YTab* tab) const;
 
			void				UpdateConstraints(BLayoutContext* context);
 
			void				_RemoveSelfFromTab(XTab* tab);
			void				_RemoveSelfFromTab(YTab* tab);
			bool				_HasTabInLayout(XTab* tab);
			bool				_HasTabInLayout(YTab* tab);
			bool				_AddedTab(XTab* tab);
			bool				_AddedTab(YTab* tab);
 
			BLayoutItem*		_LayoutItemToAdd(BView* view);
			void				_SetSolver(BPrivate::SharedSolver* solver);
 
			BPrivate::SharedSolver* fSolver;
			BALMLayoutSpecListener* fSpecListener;
 
			BReference<XTab>	fLeft;
			BReference<XTab>	fRight;
			BReference<YTab>	fTop;
			BReference<YTab>	fBottom;
			BSize				fMinSize;
			BSize				fMaxSize;
			BSize				fPreferredSize;
 
			float				fLeftInset;
			float				fRightInset;
			float				fTopInset;
			float				fBottomInset;
 
			float				fHSpacing;
			float				fVSpacing;
 
			XTabList			fXTabList;
			bool				fXTabsSorted;
 
			YTabList			fYTabList;
			bool				fYTabsSorted;
 
			BObjectList<Constraint>	fConstraints;
 
			RowColumnManager*	fRowColumnManager;
 
			BadLayoutPolicy*	fBadLayoutPolicy;
 
			uint32				_reserved[5];
};
 
}	// namespace BALM
 
 
using BALM::BALMLayout;
 
 
#endif	// ALM_LAYOUT_H