/*
 * Copyright 2007-2008, Christof Lutteroth, lutteroth@cs.auckland.ac.nz
 * Copyright 2007-2008, James Kim, jkim202@ec.auckland.ac.nz
 * Copyright 2010, Clemens Zeidler <haiku@clemens-zeidler.de>
 * Distributed under the terms of the MIT License.
 */


#include "ALMLayout.h"


#include <stdio.h>
#include <vector>

#include <AutoDeleter.h>
#include <ControlLook.h>

#include "RowColumnManager.h"
#include "SharedSolver.h"
#include "ViewLayoutItem.h"


using BPrivate::AutoDeleter;
using namespace LinearProgramming;


const BSize kUnsetSize(B_SIZE_UNSET, B_SIZE_UNSET);


namespace {

const char* kSolverField = "BALMLayout:solver";
const char* kBadLayoutPolicyField = "BALMLayout:policy";
const char* kXTabsField = "BALMLayout:xtabs";
const char* kYTabsField = "BALMLayout:ytabs";
const char* kMyTabsField = "BALMLayout:tabs";
const char* kInsetsField = "BALMLayout:insets";
const char* kSpacingField = "BALMLayout:spacing";

const char* kTabsField = "BALMLayout:item:tabs";
const char* kItemAspectRatio = "BALMLayout:item:aspect";
const char* kItemPenalties = "BALMLayout:item:penalties";
const char* kItemInsets = "BALMLayout:item:insets";

int CompareXTabFunc(const XTab* tab1, const XTab* tab2);
int CompareYTabFunc(const YTab* tab1, const YTab* tab2);

};


namespace BALM {


template <class T>
struct BALMLayout::TabAddTransaction {
        ~TabAddTransaction()
        {
                if (fTab)
                        fLayout->_RemoveSelfFromTab(fTab);
                if (fIndex > 0)
                        _TabList()->RemoveItemAt(fIndex);
        }

        TabAddTransaction(BALMLayout* layout)
                :
                fTab(NULL),
                fLayout(layout),
                fIndex(-1)
        {
        }

        bool AttempAdd(T* tab)
        {
                if (fLayout->_HasTabInLayout(tab))
                        return true;
                if (!fLayout->_AddedTab(tab))
                        return false;
                fTab = tab;

                BObjectList<T>* tabList = _TabList();
                int32 index = tabList->CountItems();
                if (!tabList->AddItem(tab, index))
                        return false;
                fIndex = index;
                return true;
        }

        void Commit()
        {
                fTab = NULL;
                fIndex = -1;
        }

private:
        BObjectList<T>* _TabList();

        T*                              fTab;
        BALMLayout*             fLayout;
        int32                   fIndex;
};


template <>
BObjectList<XTab>*
BALMLayout::TabAddTransaction<XTab>::_TabList()
{
        return &fLayout->fXTabList;
}


template <>
BObjectList<YTab>*
BALMLayout::TabAddTransaction<YTab>::_TabList()
{
        return &fLayout->fYTabList;
}


}; // end namespace BALM


BALM::BALMLayout::BadLayoutPolicy::BadLayoutPolicy()
{
}


BALM::BALMLayout::BadLayoutPolicy::BadLayoutPolicy(BMessage* archive)
        :
        BArchivable(archive)
{
}


BALM::BALMLayout::BadLayoutPolicy::~BadLayoutPolicy()
{
}


BALM::BALMLayout::DefaultPolicy::DefaultPolicy()
{
}


BALM::BALMLayout::DefaultPolicy::DefaultPolicy(BMessage* archive)
        :
        BadLayoutPolicy(archive)
{
}


BALM::BALMLayout::DefaultPolicy::~DefaultPolicy()
{
}


bool
BALM::BALMLayout::DefaultPolicy::OnBadLayout(BALMLayout* layout,
        ResultType result, BLayoutContext* context)
{
        if (!context)
                return true;

        if (result == kInfeasible) {
                printf("BALMLayout failed to solve your layout!\n");
                return false;
        } else
                return true;
}


status_t
BALM::BALMLayout::DefaultPolicy::Archive(BMessage* archive, bool deep) const
{
        return BadLayoutPolicy::Archive(archive, deep);
}


BArchivable*
BALM::BALMLayout::DefaultPolicy::Instantiate(BMessage* archive)
{
        if (validate_instantiation(archive, "BALM::BALMLayout::DefaultPolicy"))
                return new DefaultPolicy(archive);
        return NULL;
}


class BALMLayout::BALMLayoutSpecListener 
        : public LinearProgramming::SpecificationListener {
public:
        BALMLayoutSpecListener(BALMLayout* layout)
                :
                fLayout(layout)
        {               
        }

        void ConstraintRemoved(Constraint* constraint)
        {
                fLayout->fConstraints.RemoveItem(constraint);
        }

private:
                        BALMLayout*                     fLayout;
};


/*!
 * Constructor.
 * Creates new layout engine.
 *
 * If friendLayout is not NULL the solver of the friend layout is used.
 */
BALMLayout::BALMLayout(float hSpacing, float vSpacing, BALMLayout* friendLayout)
        :
        fLeftInset(0),
        fRightInset(0),
        fTopInset(0),
        fBottomInset(0),
        fHSpacing(BControlLook::ComposeSpacing(hSpacing)),
        fVSpacing(BControlLook::ComposeSpacing(vSpacing)),
        fXTabsSorted(false),
        fYTabsSorted(false),
        fBadLayoutPolicy(new DefaultPolicy())
{
        _SetSolver(friendLayout ? friendLayout->fSolver : new SharedSolver());

        fSpecListener = new BALMLayoutSpecListener(this);
        Solver()->AddListener(fSpecListener);

        fLeft = AddXTab();
        fRight = AddXTab();
        fTop = AddYTab();
        fBottom = AddYTab();

        // the Left tab is always at x-position 0, and the Top tab is always at
        // y-position 0
        fLeft->SetRange(0, 0);
        fTop->SetRange(0, 0);

        // cached layout values
        // need to be invalidated whenever the layout specification is changed
        fMinSize = kUnsetSize;
        fMaxSize = kUnsetSize;
        fPreferredSize = kUnsetSize;
}


BALMLayout::BALMLayout(BMessage* archive)
        :
        BAbstractLayout(BUnarchiver::PrepareArchive(archive)),
        fSolver(NULL),
        fLeft(NULL),
        fRight(NULL),
        fTop(NULL),
        fBottom(NULL),
        fMinSize(kUnsetSize),
        fMaxSize(kUnsetSize),
        fPreferredSize(kUnsetSize),
        fXTabsSorted(false),
        fYTabsSorted(false),
        fBadLayoutPolicy(new DefaultPolicy())
{
        BUnarchiver unarchiver(archive);

        BRect insets;
        status_t err = archive->FindRect(kInsetsField, &insets);
        if (err != B_OK) {
                unarchiver.Finish(err);
                return;
        }

        fLeftInset = insets.left;
        fRightInset = insets.right;
        fTopInset = insets.top;
        fBottomInset = insets.bottom;


        BSize spacing;
        err = archive->FindSize(kSpacingField, &spacing);
        if (err != B_OK) {
                unarchiver.Finish(err);
                return;
        }

        fHSpacing = spacing.width;
        fVSpacing = spacing.height;

        int32 tabCount = 0;
        archive->GetInfo(kXTabsField, NULL, &tabCount);
        for (int32 i = 0; i < tabCount && err == B_OK; i++)
                err = unarchiver.EnsureUnarchived(kXTabsField, i);

        archive->GetInfo(kYTabsField, NULL, &tabCount);
        for (int32 i = 0; i < tabCount && err == B_OK; i++)
                err = unarchiver.EnsureUnarchived(kYTabsField, i);

        if (err == B_OK && archive->GetInfo(kBadLayoutPolicyField, NULL) == B_OK)
                err = unarchiver.EnsureUnarchived(kBadLayoutPolicyField);

        if (err == B_OK)
                err = unarchiver.EnsureUnarchived(kSolverField);

        unarchiver.Finish(err);

        fSpecListener = new BALMLayoutSpecListener(this);
        Solver()->AddListener(fSpecListener);
}


BALMLayout::~BALMLayout()
{
        Solver()->RemoveListener(fSpecListener);
        delete fSpecListener;

        delete fRowColumnManager;
        delete fBadLayoutPolicy;

        for (int32 i = 0; i < fConstraints.CountItems(); i++)
                Solver()->RemoveConstraint(fConstraints.ItemAt(i), true);

        if (fSolver) {
                fSolver->LayoutLeaving(this);
                fSolver->ReleaseReference();
        }
}


/**
 * Adds a new x-tab to the specification.
 *
 * @return the new x-tab
 */
BReference<XTab>
BALMLayout::AddXTab()
{
        BReference<XTab> tab(new(std::nothrow) XTab(this), true);
        if (!tab)
                return NULL;
        if (!Solver()->AddVariable(tab))
                return NULL;

        fXTabList.AddItem(tab);
        if (!tab->AddedToLayout(this)) {
                fXTabList.RemoveItem(tab);
                return NULL;
        }
        fXTabsSorted = false;
        return tab;
}


void
BALMLayout::AddXTabs(BReference<XTab>* tabs, uint32 count)
{
        for (uint32 i = 0; i < count; i++)
                tabs[i] = AddXTab();
}


void
BALMLayout::AddYTabs(BReference<YTab>* tabs, uint32 count)
{
        for (uint32 i = 0; i < count; i++)
                tabs[i] = AddYTab();
}


/**
 * Adds a new y-tab to the specification.
 *
 * @return the new y-tab
 */
BReference<YTab>
BALMLayout::AddYTab()
{
        BReference<YTab> tab(new(std::nothrow) YTab(this), true);
        if (!tab.IsSet())
                return NULL;
        if (!Solver()->AddVariable(tab))
                return NULL;

        fYTabList.AddItem(tab);
        if (!tab->AddedToLayout(this)) {
                fYTabList.RemoveItem(tab);
                return NULL;
        }
        fYTabsSorted = false;
        return tab;
}


int32
BALMLayout::CountXTabs() const
{
        return fXTabList.CountItems();
}


int32
BALMLayout::CountYTabs() const
{
        return fYTabList.CountItems();
}


XTab*
BALMLayout::XTabAt(int32 index, bool ordered)
{
        if (ordered && !fXTabsSorted) {
                Layout();
                fXTabList.SortItems(CompareXTabFunc);
                fXTabsSorted = true;
        }
        return fXTabList.ItemAt(index);
}


XTab*
BALMLayout::XTabAt(int32 index) const
{
        return fXTabList.ItemAt(index);
}


YTab*
BALMLayout::YTabAt(int32 index, bool ordered)
{
        if (ordered && !fYTabsSorted) {
                Layout();
                fYTabList.SortItems(CompareYTabFunc);
                fYTabsSorted = true;
        }
        return fYTabList.ItemAt(index);
}


YTab*
BALMLayout::YTabAt(int32 index) const 
{
        return fYTabList.ItemAt(index);
}


const XTabList
BALMLayout::GetXTabs() const
{
        return fXTabList;
}


const YTabList
BALMLayout::GetYTabs() const
{
        return fYTabList;
}


int32
BALMLayout::IndexOf(XTab* tab, bool ordered)
{
        if (ordered && !fXTabsSorted) {
                Layout();
                fXTabList.SortItems(CompareXTabFunc);
                fXTabsSorted = true;
        }
        return fXTabList.IndexOf(tab);
}


int32
BALMLayout::IndexOf(YTab* tab, bool ordered)
{
        if (ordered && !fYTabsSorted) {
                Layout();
                fYTabList.SortItems(CompareYTabFunc);
                fYTabsSorted = true;
        }
        return fYTabList.IndexOf(tab);
}


int32
BALMLayout::CountConstraints() const
{
        return fConstraints.CountItems();
}


Constraint*
BALMLayout::ConstraintAt(int32 index) const
{
        return fConstraints.ItemAt(index);
}


bool
BALMLayout::AddConstraint(Constraint* constraint)
{
        fConstraints.AddItem(constraint);
        return Solver()->AddConstraint(constraint);
}


bool
BALMLayout::RemoveConstraint(Constraint* constraint,
        bool deleteConstraint)
{
        if (!fConstraints.RemoveItem(constraint))
                return false;
        return Solver()->RemoveConstraint(constraint, deleteConstraint);
}


Constraint*
BALMLayout::AddConstraint(double coeff1, Variable* var1, OperatorType op,
        double rightSide, double penaltyNeg, double penaltyPos)
{
        Constraint* constraint = Solver()->AddConstraint(coeff1, var1, op,
                rightSide, penaltyNeg, penaltyPos);
        fConstraints.AddItem(constraint);
        return constraint;
}


Constraint*
BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
        Variable* var2, OperatorType op, double rightSide, double penaltyNeg,
        double penaltyPos)
{
        Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
                op, rightSide, penaltyNeg, penaltyPos);
        fConstraints.AddItem(constraint);
        return constraint;
}

Constraint*
BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
        Variable* var2, double coeff3, Variable* var3, OperatorType op,
        double rightSide, double penaltyNeg, double penaltyPos)
{
        Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
                coeff3, var3, op, rightSide, penaltyNeg, penaltyPos);
        fConstraints.AddItem(constraint);
        return constraint;
}


Constraint*
BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
        Variable* var2, double coeff3, Variable* var3, double coeff4,
        Variable* var4, OperatorType op, double rightSide, double penaltyNeg,
        double penaltyPos)
{
        Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
                coeff3, var3, coeff4, var4, op, rightSide, penaltyNeg, penaltyPos);
        fConstraints.AddItem(constraint);
        return constraint;
}


namespace {


int
CompareXTabFunc(const XTab* tab1, const XTab* tab2)
{
        if (tab1->Value() < tab2->Value())
                return -1;
        else if (tab1->Value() == tab2->Value())
                return 0;
        return 1;
}


int
CompareYTabFunc(const YTab* tab1, const YTab* tab2)
{
        if (tab1->Value() < tab2->Value())
                return -1;
        else if (tab1->Value() == tab2->Value())
                return 0;
        return 1;
}


}; // end anonymous namespace


/**
 * Adds a new row to the specification that is glued to the given y-tabs.
 *
 * @param top
 * @param bottom
 * @return the new row
 */
Row*
BALMLayout::AddRow(YTab* _top, YTab* _bottom)
{
        BReference<YTab> top = _top;
        BReference<YTab> bottom = _bottom;
        if (_top == NULL)
                top = AddYTab();
        if (_bottom == NULL)
                bottom = AddYTab();
        return new(std::nothrow) Row(Solver(), top, bottom);
}


/**
 * Adds a new column to the specification that is glued to the given x-tabs.
 *
 * @param left
 * @param right
 * @return the new column
 */
Column*
BALMLayout::AddColumn(XTab* _left, XTab* _right)
{
        BReference<XTab> left = _left;
        BReference<XTab> right = _right;
        if (_left == NULL)
                left = AddXTab();
        if (_right == NULL)
                right = AddXTab();
        return new(std::nothrow) Column(Solver(), left, right);
}


Area*
BALMLayout::AreaFor(int32 id) const
{
        int32 areaCount = CountAreas();
        for (int32 i = 0; i < areaCount; i++) {
                Area* area = AreaAt(i);
                if (area->ID() == id)
                        return area;
        }
        return NULL;
}


/**
 * Finds the area that contains the given control.
 *
 * @param control       the control to look for
 * @return the area that contains the control
 */
Area*
BALMLayout::AreaFor(const BView* control) const
{
        return AreaFor(ItemAt(IndexOfView(const_cast<BView*>(control))));
}


Area*
BALMLayout::AreaFor(const BLayoutItem* item) const
{
        if (!item)
                return NULL;
        return static_cast<Area*>(item->LayoutData());
}


int32
BALMLayout::CountAreas() const
{
        return CountItems();
}


Area*
BALMLayout::AreaAt(int32 index) const
{
        return AreaFor(ItemAt(index));
}


XTab*
BALMLayout::LeftOf(const BView* view) const
{
        Area* area = AreaFor(view);
        if (!area)
                return NULL;
        return area->Left();
}


XTab*
BALMLayout::LeftOf(const BLayoutItem* item) const
{
        Area* area = AreaFor(item);
        if (!area)
                return NULL;
        return area->Left();
}


XTab*
BALMLayout::RightOf(const BView* view) const
{
        Area* area = AreaFor(view);
        if (!area)
                return NULL;
        return area->Right();
}


XTab*
BALMLayout::RightOf(const BLayoutItem* item) const
{
        Area* area = AreaFor(item);
        if (!area)
                return NULL;
        return area->Right();
}


YTab*
BALMLayout::TopOf(const BView* view) const
{
        Area* area = AreaFor(view);
        if (!area)
                return NULL;
        return area->Top();
}


YTab*
BALMLayout::TopOf(const BLayoutItem* item) const
{
        Area* area = AreaFor(item);
        if (!area)
                return NULL;
        return area->Top();
}


YTab*
BALMLayout::BottomOf(const BView* view) const
{
        Area* area = AreaFor(view);
        if (!area)
                return NULL;
        return area->Bottom();
}


YTab*
BALMLayout::BottomOf(const BLayoutItem* item) const
{
        Area* area = AreaFor(item);
        if (!area)
                return NULL;
        return area->Bottom();
}


BLayoutItem*
BALMLayout::AddView(BView* child)
{
        return AddView(-1, child);
}


BLayoutItem*
BALMLayout::AddView(int32 index, BView* child)
{
        return BAbstractLayout::AddView(index, child);
}


/**
 * Adds a new area to the specification, automatically setting preferred size constraints.
 *
 * @param left                  left border
 * @param top                   top border
 * @param right         right border
 * @param bottom                bottom border
 * @param content               the control which is the area content
 * @return the new area
 */
Area*
BALMLayout::AddView(BView* view, XTab* left, YTab* top, XTab* right,
        YTab* bottom)
{
        BLayoutItem* item = _LayoutItemToAdd(view);
        Area* area = AddItem(item, left, top, right, bottom);
        if (!area) {
                if (item != view->GetLayout())
                        delete item;
                return NULL;
        }
        return area;
}


/**
 * Adds a new area to the specification, automatically setting preferred size constraints.
 *
 * @param row                   the row that defines the top and bottom border
 * @param column                the column that defines the left and right border
 * @param content               the control which is the area content
 * @return the new area
 */
Area*
BALMLayout::AddView(BView* view, Row* row, Column* column)
{
        BLayoutItem* item = _LayoutItemToAdd(view);
        Area* area = AddItem(item, row, column);
        if (!area) {
                if (item != view->GetLayout())
                        delete item;
                return NULL;
        }
        return area;
}


bool
BALMLayout::AddItem(BLayoutItem* item)
{
        return AddItem(-1, item);
}


bool
BALMLayout::AddItem(int32 index, BLayoutItem* item)
{
        if (!item)
                return false;

        // simply add the item at the upper right corner of the previous item
        // TODO maybe find a more elegant solution
        XTab* left = Left();
        YTab* top = Top();

        // check range
        if (index < 0 || index > CountItems())
                index = CountItems();

        // for index = 0 we already have set the right tabs
        if (index != 0) {
                BLayoutItem* prevItem = ItemAt(index - 1);
                Area* area = AreaFor(prevItem);
                if (area) {
                        left = area->Right();
                        top = area->Top();
                }
        }
        Area* area = AddItem(item, left, top);
        return area ? true : false;
}


Area*
BALMLayout::AddItem(BLayoutItem* item, XTab* _left, YTab* _top, XTab* _right,
        YTab* _bottom)
{
        if ((_left && !_left->IsSuitableFor(this))
                        || (_top && !_top->IsSuitableFor(this))
                        || (_right && !_right->IsSuitableFor(this))
                        || (_bottom && !_bottom->IsSuitableFor(this)))
                debugger("Tab added to unfriendly layout!");

        BReference<XTab> right = _right;
        if (!right.IsSet())
                right = AddXTab();
        BReference<YTab> bottom = _bottom;
        if (!bottom.IsSet())
                bottom = AddYTab();
        BReference<XTab> left = _left;
        if (!left.IsSet())
                left = AddXTab();
        BReference<YTab> top = _top;
        if (!top.IsSet())
                top = AddYTab();

        TabAddTransaction<XTab> leftTabAdd(this);
        if (!leftTabAdd.AttempAdd(left))
                return NULL;

        TabAddTransaction<YTab> topTabAdd(this);
        if (!topTabAdd.AttempAdd(top))
                return NULL;

        TabAddTransaction<XTab> rightTabAdd(this);
        if (!rightTabAdd.AttempAdd(right))
                return NULL;

        TabAddTransaction<YTab> bottomTabAdd(this);
        if (!bottomTabAdd.AttempAdd(bottom))
                return NULL;

        // Area is added in ItemAdded
        if (!BAbstractLayout::AddItem(-1, item))
                return NULL;
        Area* area = AreaFor(item);
        if (!area) {
                RemoveItem(item);
                return NULL;
        }

        fSolver->Invalidate(true);
        area->_Init(Solver(), left, top, right, bottom, fRowColumnManager);
        fRowColumnManager->AddArea(area);

        leftTabAdd.Commit();
        topTabAdd.Commit();
        rightTabAdd.Commit();
        bottomTabAdd.Commit();
        return area;
}


Area*
BALMLayout::AddItem(BLayoutItem* item, Row* row, Column* column)
{
        if (!BAbstractLayout::AddItem(-1, item))
                return NULL;
        Area* area = AreaFor(item);
        if (!area)
                return NULL;

        fSolver->Invalidate(true);
        area->_Init(Solver(), row, column, fRowColumnManager);

        fRowColumnManager->AddArea(area);
        return area;
}


/**
 * Gets the left variable.
 */
XTab*
BALMLayout::Left() const
{
        return fLeft;
}


/**
 * Gets the right variable.
 */
XTab*
BALMLayout::Right() const
{
        return fRight;
}


/**
 * Gets the top variable.
 */
YTab*
BALMLayout::Top() const
{
        return fTop;
}


/**
 * Gets the bottom variable.
 */
YTab*
BALMLayout::Bottom() const
{
        return fBottom;
}


void
BALMLayout::SetBadLayoutPolicy(BadLayoutPolicy* policy)
{
        if (fBadLayoutPolicy != policy)
                delete fBadLayoutPolicy;
        if (policy == NULL)
                policy = new DefaultPolicy();
        fBadLayoutPolicy = policy;
}


struct BALMLayout::BadLayoutPolicy*
BALMLayout::GetBadLayoutPolicy() const
{
        return fBadLayoutPolicy;
}


/**
 * Gets minimum size.
 */
BSize
BALMLayout::BaseMinSize()
{
        ResultType result = fSolver->ValidateMinSize();
        if (result != kOptimal && result != kUnbounded)
                fBadLayoutPolicy->OnBadLayout(this, result, NULL);
        return fMinSize;
}


/**
 * Gets maximum size.
 */
BSize
BALMLayout::BaseMaxSize()
{
        ResultType result = fSolver->ValidateMaxSize();
        if (result != kOptimal && result != kUnbounded)
                fBadLayoutPolicy->OnBadLayout(this, result, NULL);
        return fMaxSize;
}


/**
 * Gets preferred size.
 */
BSize
BALMLayout::BasePreferredSize()
{
        ResultType result = fSolver->ValidatePreferredSize();
        if (result != kOptimal)
                fBadLayoutPolicy->OnBadLayout(this, result, NULL);

        return fPreferredSize;
}


/**
 * Gets the alignment.
 */
BAlignment
BALMLayout::BaseAlignment()
{
        BAlignment alignment;
        alignment.SetHorizontal(B_ALIGN_HORIZONTAL_CENTER);
        alignment.SetVertical(B_ALIGN_VERTICAL_CENTER);
        return alignment;
}


status_t
BALMLayout::Archive(BMessage* into, bool deep) const
{
        BArchiver archiver(into);
        status_t err = BAbstractLayout::Archive(into, deep);
        if (err != B_OK)
                return archiver.Finish(err);

        BRect insets(fLeftInset, fTopInset, fRightInset, fBottomInset);
        err = into->AddRect(kInsetsField, insets);
        if (err != B_OK)
                return archiver.Finish(err);

        BSize spacing(fHSpacing, fVSpacing);
        err = into->AddSize(kSpacingField, spacing);
        if (err != B_OK)
                return archiver.Finish(err);

        if (deep) {
                for (int32 i = CountXTabs() - 1; i >= 0 && err == B_OK; i--)
                        err = archiver.AddArchivable(kXTabsField, XTabAt(i));

                for (int32 i = CountYTabs() - 1; i >= 0 && err == B_OK; i--)
                        err = archiver.AddArchivable(kYTabsField, YTabAt(i));

                err = archiver.AddArchivable(kBadLayoutPolicyField, fBadLayoutPolicy);
        }

        if (err == B_OK)
                err = archiver.AddArchivable(kSolverField, fSolver);

        if (err == B_OK)
                err = archiver.AddArchivable(kMyTabsField, fLeft);
        if (err == B_OK)
                err = archiver.AddArchivable(kMyTabsField, fTop);
        if (err == B_OK)
                err = archiver.AddArchivable(kMyTabsField, fRight);
        if (err == B_OK)
                err = archiver.AddArchivable(kMyTabsField, fBottom);

        return archiver.Finish(err);
}


BArchivable*
BALMLayout::Instantiate(BMessage* from)
{
        if (validate_instantiation(from, "BALM::BALMLayout"))
                return new BALMLayout(from);
        return NULL;
}


status_t
BALMLayout::ItemArchived(BMessage* into, BLayoutItem* item, int32 index) const
{
        BArchiver archiver(into);
        status_t err = BAbstractLayout::ItemArchived(into, item, index);
        if (err != B_OK)
                return err;

        Area* area = AreaFor(item);
        err = into->AddSize(kItemPenalties, area->fShrinkPenalties);
        if (err == B_OK)
                err = into->AddSize(kItemPenalties, area->fGrowPenalties);
        if (err == B_OK)
                err = into->AddSize(kItemInsets, area->fLeftTopInset);
        if (err == B_OK)
                err = into->AddSize(kItemInsets, area->fRightBottomInset);
        if (err == B_OK)
                err = into->AddDouble(kItemAspectRatio, area->fContentAspectRatio);

        err = archiver.AddArchivable(kTabsField, area->Left());
        if (err == B_OK)
                archiver.AddArchivable(kTabsField, area->Top());
        if (err == B_OK)
                archiver.AddArchivable(kTabsField, area->Right());
        if (err == B_OK)
                archiver.AddArchivable(kTabsField, area->Bottom());

        return err;
}


status_t
BALMLayout::ItemUnarchived(const BMessage* from, BLayoutItem* item,
        int32 index)
{
        BUnarchiver unarchiver(from);
        status_t err = BAbstractLayout::ItemUnarchived(from, item, index);
        if (err != B_OK)
                return err;

        Area* area = AreaFor(item);
        XTab* left;
        XTab* right;
        YTab* bottom;
        YTab* top;
        err = unarchiver.FindObject(kTabsField, index * 4, left);
        if (err == B_OK)
                err = unarchiver.FindObject(kTabsField, index * 4 + 1, top);
        if (err == B_OK)
                err = unarchiver.FindObject(kTabsField, index * 4 + 2, right);
        if (err == B_OK)
                err = unarchiver.FindObject(kTabsField, index * 4 + 3, bottom);
        
        if (err != B_OK)
                return err;

        area->_Init(Solver(), left, top, right, bottom, fRowColumnManager);
        fRowColumnManager->AddArea(area);

        err = from->FindSize(kItemPenalties, index * 2, &area->fShrinkPenalties);
        if (err != B_OK)
                return err;

        err = from->FindSize(kItemPenalties, index * 2 + 1, &area->fGrowPenalties);
        if (err != B_OK)
                return err;

        err = from->FindSize(kItemInsets, index * 2, &area->fLeftTopInset);
        if (err != B_OK)
                return err;

        err = from->FindSize(kItemInsets, index * 2 + 1, &area->fRightBottomInset);

        if (err == B_OK) {
                double contentAspectRatio;
                err = from->FindDouble(kItemAspectRatio, index, &contentAspectRatio);
                if (err == B_OK)
                        area->SetContentAspectRatio(contentAspectRatio);
        }

        return err;
}


status_t
BALMLayout::AllUnarchived(const BMessage* archive)
{
        BUnarchiver unarchiver(archive);

        SharedSolver* solver;
        status_t err = unarchiver.FindObject(kSolverField, solver);

        if (err != B_OK)
                return err;

        _SetSolver(solver);

        if (archive->GetInfo(kBadLayoutPolicyField, NULL) == B_OK) {
                BadLayoutPolicy* policy;
                err = unarchiver.FindObject(kBadLayoutPolicyField, policy);
                if (err == B_OK)
                        SetBadLayoutPolicy(policy);
        }

        LinearSpec* spec = Solver();
        int32 tabCount = 0;
        archive->GetInfo(kXTabsField, NULL, &tabCount);
        for (int32 i = 0; i < tabCount && err == B_OK; i++) {
                XTab* tab;
                err = unarchiver.FindObject(kXTabsField, i,
                        BUnarchiver::B_DONT_ASSUME_OWNERSHIP, tab);
                spec->AddVariable(tab);
                TabAddTransaction<XTab> adder(this);
                if (adder.AttempAdd(tab))
                        adder.Commit();
                else
                        err = B_NO_MEMORY;
        }

        archive->GetInfo(kYTabsField, NULL, &tabCount);
        for (int32 i = 0; i < tabCount; i++) {
                YTab* tab;
                unarchiver.FindObject(kYTabsField, i,
                        BUnarchiver::B_DONT_ASSUME_OWNERSHIP, tab);
                spec->AddVariable(tab);
                TabAddTransaction<YTab> adder(this);
                if (adder.AttempAdd(tab))
                        adder.Commit();
                else
                        err = B_NO_MEMORY;
        }


        if (err == B_OK) {
                XTab* leftTab = NULL;
                err = unarchiver.FindObject(kMyTabsField, 0, leftTab);
                fLeft = leftTab;
        }

        if (err == B_OK) {
                YTab* topTab = NULL;
                err = unarchiver.FindObject(kMyTabsField, 1, topTab);
                fTop = topTab;
        }

        if (err == B_OK) {
                XTab* rightTab = NULL;
                err = unarchiver.FindObject(kMyTabsField, 2, rightTab);
                fRight = rightTab;
        }

        if (err == B_OK) {
                YTab* bottomTab = NULL;
                err = unarchiver.FindObject(kMyTabsField, 3, bottomTab);
                fBottom = bottomTab;
        }

        if (err == B_OK) {
                fLeft->SetRange(0, 0);
                fTop->SetRange(0, 0);

                err = BAbstractLayout::AllUnarchived(archive);
        }
        return err;
}


status_t
BALMLayout::AllArchived(BMessage* archive) const
{
        status_t err = BAbstractLayout::AllArchived(archive);

        return err;
}


/**
 * Invalidates the layout.
 * Resets minimum/maximum/preferred size.
 */
void
BALMLayout::LayoutInvalidated(bool children)
{
        fMinSize = kUnsetSize;
        fMaxSize = kUnsetSize;
        fPreferredSize = kUnsetSize;
        fXTabsSorted = false;
        fYTabsSorted = false;

        if (fSolver)
                fSolver->Invalidate(children);
}


bool
BALMLayout::ItemAdded(BLayoutItem* item, int32 atIndex)
{
        item->SetLayoutData(new(std::nothrow) Area(item));
        return item->LayoutData() != NULL;
}


void
BALMLayout::ItemRemoved(BLayoutItem* item, int32 fromIndex)
{
        if (Area* area = AreaFor(item)) {
                fRowColumnManager->RemoveArea(area);
                item->SetLayoutData(NULL);
                delete area;
        }
}


/**
 * Calculate and set the layout.
 * If no layout specification is given, a specification is reverse engineered automatically.
 */
void
BALMLayout::DoLayout()
{
        BLayoutContext* context = LayoutContext();
        ResultType result = fSolver->ValidateLayout(context);
        if (result != kOptimal
                        && !fBadLayoutPolicy->OnBadLayout(this, result, context)) {
                return;
        }

        // set the calculated positions and sizes for every area
        for (int32 i = 0; i < CountItems(); i++)
                AreaFor(ItemAt(i))->_DoLayout(LayoutArea().LeftTop());

        fXTabsSorted = false;
        fYTabsSorted = false;
}


LinearSpec*
BALMLayout::Solver() const
{
        return fSolver->Solver();
}


ResultType
BALMLayout::ValidateLayout()
{
        // we explicitly recaluclate the layout so set the invalidate flag first
        fSolver->Invalidate(true);

        BLayoutContext* context = LayoutContext();
        return fSolver->ValidateLayout(context);
}


void
BALMLayout::SetInsets(float left, float top, float right,
        float bottom)
{
        fLeftInset = BControlLook::ComposeSpacing(left);
        fTopInset = BControlLook::ComposeSpacing(top);
        fRightInset = BControlLook::ComposeSpacing(right);
        fBottomInset = BControlLook::ComposeSpacing(bottom);

        InvalidateLayout();
}


void
BALMLayout::SetInsets(float horizontal, float vertical)
{
        fLeftInset = BControlLook::ComposeSpacing(horizontal);
        fRightInset = fLeftInset;

        fTopInset = BControlLook::ComposeSpacing(vertical);
        fBottomInset = fTopInset;

        InvalidateLayout();
}


void
BALMLayout::SetInsets(float insets)
{
        fLeftInset = BControlLook::ComposeSpacing(insets);
        fRightInset = fLeftInset;
        fTopInset = fLeftInset;
        fBottomInset = fLeftInset;

        InvalidateLayout();
}


void
BALMLayout::GetInsets(float* left, float* top, float* right,
        float* bottom) const
{
        if (left)
                *left = fLeftInset;
        if (top)
                *top = fTopInset;
        if (right)
                *right = fRightInset;
        if (bottom)
                *bottom = fBottomInset;
}


void
BALMLayout::SetSpacing(float hSpacing, float vSpacing)
{
        fHSpacing = BControlLook::ComposeSpacing(hSpacing);
        fVSpacing = BControlLook::ComposeSpacing(vSpacing);
}


void
BALMLayout::GetSpacing(float *_hSpacing, float *_vSpacing) const
{
        if (_hSpacing)
                *_hSpacing = fHSpacing;
        if (_vSpacing)
                *_vSpacing = fVSpacing;
}


float
BALMLayout::InsetForTab(XTab* tab) const
{
        if (tab == fLeft.Get())
                return fLeftInset;
        if (tab == fRight.Get())
                return fRightInset;
        return fHSpacing / 2;
}


float
BALMLayout::InsetForTab(YTab* tab) const
{
        if (tab == fTop.Get())
                return fTopInset;
        if (tab == fBottom.Get())
                return fBottomInset;
        return fVSpacing / 2;
}


void
BALMLayout::UpdateConstraints(BLayoutContext* context)
{
        for (int i = 0; i < CountItems(); i++)
                AreaFor(ItemAt(i))->InvalidateSizeConstraints();
        fRowColumnManager->UpdateConstraints();
}


void BALMLayout::_RemoveSelfFromTab(XTab* tab) { tab->LayoutLeaving(this); }
void BALMLayout::_RemoveSelfFromTab(YTab* tab) { tab->LayoutLeaving(this); }

bool BALMLayout::_HasTabInLayout(XTab* tab) { return tab->IsInLayout(this); }
bool BALMLayout::_HasTabInLayout(YTab* tab) { return tab->IsInLayout(this); }

bool BALMLayout::_AddedTab(XTab* tab) { return tab->AddedToLayout(this); }
bool BALMLayout::_AddedTab(YTab* tab) { return tab->AddedToLayout(this); }


BLayoutItem*
BALMLayout::_LayoutItemToAdd(BView* view)
{
        if (view->GetLayout())
                return view->GetLayout();
        return new(std::nothrow) BViewLayoutItem(view);
}


void
BALMLayout::_SetSolver(SharedSolver* solver)
{
        fSolver = solver;
        fSolver->AcquireReference();
        fSolver->RegisterLayout(this);
        fRowColumnManager = new RowColumnManager(Solver());
}


status_t
BALMLayout::Perform(perform_code d, void* arg)
{
        return BAbstractLayout::Perform(d, arg);
}


void BALMLayout::_ReservedALMLayout1() {}
void BALMLayout::_ReservedALMLayout2() {}
void BALMLayout::_ReservedALMLayout3() {}
void BALMLayout::_ReservedALMLayout4() {}
void BALMLayout::_ReservedALMLayout5() {}
void BALMLayout::_ReservedALMLayout6() {}
void BALMLayout::_ReservedALMLayout7() {}
void BALMLayout::_ReservedALMLayout8() {}
void BALMLayout::_ReservedALMLayout9() {}
void BALMLayout::_ReservedALMLayout10() {}