src/libs/alm/ALMLayout.cpp

   1 /*
   2  * Copyright 2007-2008, Christof Lutteroth, lutteroth@cs.auckland.ac.nz
   3  * Copyright 2007-2008, James Kim, jkim202@ec.auckland.ac.nz
   4  * Copyright 2010, Clemens Zeidler <haiku@clemens-zeidler.de>
   5  * Distributed under the terms of the MIT License.
   6  */
   7
   8
   9 #include "ALMLayout.h"
  10
  11
  12 #include <stdio.h>
  13 #include <vector>
  14
  15 #include <AutoDeleter.h>
  16 #include <ControlLook.h>
  17
  18 #include "RowColumnManager.h"
  19 #include "SharedSolver.h"
  20 #include "ViewLayoutItem.h"
  21
  22
  23 using BPrivate::AutoDeleter;
  24 using namespace LinearProgramming;
  25
  26
  27 const BSize kUnsetSize(B_SIZE_UNSET, B_SIZE_UNSET);
  28
  29
  30 namespace {
  31
  32 const char* kSolverField = "BALMLayout:solver";
  33 const char* kBadLayoutPolicyField = "BALMLayout:policy";
  34 const char* kXTabsField = "BALMLayout:xtabs";
  35 const char* kYTabsField = "BALMLayout:ytabs";
  36 const char* kMyTabsField = "BALMLayout:tabs";
  37 const char* kInsetsField = "BALMLayout:insets";
  38 const char* kSpacingField = "BALMLayout:spacing";
  39
  40 const char* kTabsField = "BALMLayout:item:tabs";
  41 const char* kItemAspectRatio = "BALMLayout:item:aspect";
  42 const char* kItemPenalties = "BALMLayout:item:penalties";
  43 const char* kItemInsets = "BALMLayout:item:insets";
  44
  45 int CompareXTabFunc(const XTab* tab1, const XTab* tab2);
  46 int CompareYTabFunc(const YTab* tab1, const YTab* tab2);
  47
  48 };
  49
  50
  51 namespace BALM {
  52
  53
  54 template <class T>
  55 struct BALMLayout::TabAddTransaction {
  56         ~TabAddTransaction()
  57         {
  58                 if (fTab)
  59                         fLayout->_RemoveSelfFromTab(fTab);
  60                 if (fIndex > 0)
  61                         _TabList()->RemoveItemAt(fIndex);
  62         }
  63
  64         TabAddTransaction(BALMLayout* layout)
  65                 :
  66                 fTab(NULL),
  67                 fLayout(layout),
  68                 fIndex(-1)
  69         {
  70         }
  71
  72         bool AttempAdd(T* tab)
  73         {
  74                 if (fLayout->_HasTabInLayout(tab))
  75                         return true;
  76                 if (!fLayout->_AddedTab(tab))
  77                         return false;
  78                 fTab = tab;
  79
  80                 BObjectList<T>* tabList = _TabList();
  81                 int32 index = tabList->CountItems();
  82                 if (!tabList->AddItem(tab, index))
  83                         return false;
  84                 fIndex = index;
  85                 return true;
  86         }
  87
  88         void Commit()
  89         {
  90                 fTab = NULL;
  91                 fIndex = -1;
  92         }
  93
  94 private:
  95         BObjectList<T>* _TabList();
  96
  97         T*                              fTab;
  98         BALMLayout*             fLayout;
  99         int32                   fIndex;
 100 };
 101
 102
 103 template <>
 104 BObjectList<XTab>*
 105 BALMLayout::TabAddTransaction<XTab>::_TabList()
 106 {
 107         return &fLayout->fXTabList;
 108 }
 109
 110
 111 template <>
 112 BObjectList<YTab>*
 113 BALMLayout::TabAddTransaction<YTab>::_TabList()
 114 {
 115         return &fLayout->fYTabList;
 116 }
 117
 118
 119 }; // end namespace BALM
 120
 121
 122 BALM::BALMLayout::BadLayoutPolicy::BadLayoutPolicy()
 123 {
 124 }
 125
 126
 127 BALM::BALMLayout::BadLayoutPolicy::BadLayoutPolicy(BMessage* archive)
 128         :
 129         BArchivable(archive)
 130 {
 131 }
 132
 133
 134 BALM::BALMLayout::BadLayoutPolicy::~BadLayoutPolicy()
 135 {
 136 }
 137
 138
 139 BALM::BALMLayout::DefaultPolicy::DefaultPolicy()
 140 {
 141 }
 142
 143
 144 BALM::BALMLayout::DefaultPolicy::DefaultPolicy(BMessage* archive)
 145         :
 146         BadLayoutPolicy(archive)
 147 {
 148 }
 149
 150
 151 BALM::BALMLayout::DefaultPolicy::~DefaultPolicy()
 152 {
 153 }
 154
 155
 156 bool
 157 BALM::BALMLayout::DefaultPolicy::OnBadLayout(BALMLayout* layout,
 158         ResultType result, BLayoutContext* context)
 159 {
 160         if (!context)
 161                 return true;
 162
 163         if (result == kInfeasible) {
 164                 printf("BALMLayout failed to solve your layout!\n");
 165                 return false;
 166         } else
 167                 return true;
 168 }
 169
 170
 171 status_t
 172 BALM::BALMLayout::DefaultPolicy::Archive(BMessage* archive, bool deep) const
 173 {
 174         return BadLayoutPolicy::Archive(archive, deep);
 175 }
 176
 177
 178 BArchivable*
 179 BALM::BALMLayout::DefaultPolicy::Instantiate(BMessage* archive)
 180 {
 181         if (validate_instantiation(archive, "BALM::BALMLayout::DefaultPolicy"))
 182                 return new DefaultPolicy(archive);
 183         return NULL;
 184 }
 185
 186
 187 class BALMLayout::BALMLayoutSpecListener
 188         : public LinearProgramming::SpecificationListener {
 189 public:
 190         BALMLayoutSpecListener(BALMLayout* layout)
 191                 :
 192                 fLayout(layout)
 193         {
 194         }
 195
 196         void ConstraintRemoved(Constraint* constraint)
 197         {
 198                 fLayout->fConstraints.RemoveItem(constraint);
 199         }
 200
 201 private:
 202                         BALMLayout*                     fLayout;
 203 };
 204
 205
 206 /*!
 207  * Constructor.
 208  * Creates new layout engine.
 209  *
 210  * If friendLayout is not NULL the solver of the friend layout is used.
 211  */
 212 BALMLayout::BALMLayout(float hSpacing, float vSpacing, BALMLayout* friendLayout)
 213         :
 214         fLeftInset(0),
 215         fRightInset(0),
 216         fTopInset(0),
 217         fBottomInset(0),
 218         fHSpacing(BControlLook::ComposeSpacing(hSpacing)),
 219         fVSpacing(BControlLook::ComposeSpacing(vSpacing)),
 220         fXTabsSorted(false),
 221         fYTabsSorted(false),
 222         fBadLayoutPolicy(new DefaultPolicy())
 223 {
 224         _SetSolver(friendLayout ? friendLayout->fSolver : new SharedSolver());
 225
 226         fSpecListener = new BALMLayoutSpecListener(this);
 227         Solver()->AddListener(fSpecListener);
 228
 229         fLeft = AddXTab();
 230         fRight = AddXTab();
 231         fTop = AddYTab();
 232         fBottom = AddYTab();
 233
 234         // the Left tab is always at x-position 0, and the Top tab is always at
 235         // y-position 0
 236         fLeft->SetRange(0, 0);
 237         fTop->SetRange(0, 0);
 238
 239         // cached layout values
 240         // need to be invalidated whenever the layout specification is changed
 241         fMinSize = kUnsetSize;
 242         fMaxSize = kUnsetSize;
 243         fPreferredSize = kUnsetSize;
 244 }
 245
 246
 247 BALMLayout::BALMLayout(BMessage* archive)
 248         :
 249         BAbstractLayout(BUnarchiver::PrepareArchive(archive)),
 250         fSolver(NULL),
 251         fLeft(NULL),
 252         fRight(NULL),
 253         fTop(NULL),
 254         fBottom(NULL),
 255         fMinSize(kUnsetSize),
 256         fMaxSize(kUnsetSize),
 257         fPreferredSize(kUnsetSize),
 258         fXTabsSorted(false),
 259         fYTabsSorted(false),
 260         fBadLayoutPolicy(new DefaultPolicy())
 261 {
 262         BUnarchiver unarchiver(archive);
 263
 264         BRect insets;
 265         status_t err = archive->FindRect(kInsetsField, &insets);
 266         if (err != B_OK) {
 267                 unarchiver.Finish(err);
 268                 return;
 269         }
 270
 271         fLeftInset = insets.left;
 272         fRightInset = insets.right;
 273         fTopInset = insets.top;
 274         fBottomInset = insets.bottom;
 275
 276
 277         BSize spacing;
 278         err = archive->FindSize(kSpacingField, &spacing);
 279         if (err != B_OK) {
 280                 unarchiver.Finish(err);
 281                 return;
 282         }
 283
 284         fHSpacing = spacing.width;
 285         fVSpacing = spacing.height;
 286
 287         int32 tabCount = 0;
 288         archive->GetInfo(kXTabsField, NULL, &tabCount);
 289         for (int32 i = 0; i < tabCount && err == B_OK; i++)
 290                 err = unarchiver.EnsureUnarchived(kXTabsField, i);
 291
 292         archive->GetInfo(kYTabsField, NULL, &tabCount);
 293         for (int32 i = 0; i < tabCount && err == B_OK; i++)
 294                 err = unarchiver.EnsureUnarchived(kYTabsField, i);
 295
 296         if (err == B_OK && archive->GetInfo(kBadLayoutPolicyField, NULL) == B_OK)
 297                 err = unarchiver.EnsureUnarchived(kBadLayoutPolicyField);
 298
 299         if (err == B_OK)
 300                 err = unarchiver.EnsureUnarchived(kSolverField);
 301
 302         unarchiver.Finish(err);
 303
 304         fSpecListener = new BALMLayoutSpecListener(this);
 305         Solver()->AddListener(fSpecListener);
 306 }
 307
 308
 309 BALMLayout::~BALMLayout()
 310 {
 311         Solver()->RemoveListener(fSpecListener);
 312         delete fSpecListener;
 313
 314         delete fRowColumnManager;
 315         delete fBadLayoutPolicy;
 316
 317         for (int32 i = 0; i < fConstraints.CountItems(); i++)
 318                 Solver()->RemoveConstraint(fConstraints.ItemAt(i), true);
 319
 320         if (fSolver) {
 321                 fSolver->LayoutLeaving(this);
 322                 fSolver->ReleaseReference();
 323         }
 324 }
 325
 326
 327 /**
 328  * Adds a new x-tab to the specification.
 329  *
 330  * @return the new x-tab
 331  */
 332 BReference<XTab>
 333 BALMLayout::AddXTab()
 334 {
 335         BReference<XTab> tab(new(std::nothrow) XTab(this), true);
 336         if (!tab)
 337                 return NULL;
 338         if (!Solver()->AddVariable(tab))
 339                 return NULL;
 340
 341         fXTabList.AddItem(tab);
 342         if (!tab->AddedToLayout(this)) {
 343                 fXTabList.RemoveItem(tab);
 344                 return NULL;
 345         }
 346         fXTabsSorted = false;
 347         return tab;
 348 }
 349
 350
 351 void
 352 BALMLayout::AddXTabs(BReference<XTab>* tabs, uint32 count)
 353 {
 354         for (uint32 i = 0; i < count; i++)
 355                 tabs[i] = AddXTab();
 356 }
 357
 358
 359 void
 360 BALMLayout::AddYTabs(BReference<YTab>* tabs, uint32 count)
 361 {
 362         for (uint32 i = 0; i < count; i++)
 363                 tabs[i] = AddYTab();
 364 }
 365
 366
 367 /**
 368  * Adds a new y-tab to the specification.
 369  *
 370  * @return the new y-tab
 371  */
 372 BReference<YTab>
 373 BALMLayout::AddYTab()
 374 {
 375         BReference<YTab> tab(new(std::nothrow) YTab(this), true);
 376         if (tab.Get() == NULL)
 377                 return NULL;
 378         if (!Solver()->AddVariable(tab))
 379                 return NULL;
 380
 381         fYTabList.AddItem(tab);
 382         if (!tab->AddedToLayout(this)) {
 383                 fYTabList.RemoveItem(tab);
 384                 return NULL;
 385         }
 386         fYTabsSorted = false;
 387         return tab;
 388 }
 389
 390
 391 int32
 392 BALMLayout::CountXTabs() const
 393 {
 394         return fXTabList.CountItems();
 395 }
 396
 397
 398 int32
 399 BALMLayout::CountYTabs() const
 400 {
 401         return fYTabList.CountItems();
 402 }
 403
 404
 405 XTab*
 406 BALMLayout::XTabAt(int32 index, bool ordered)
 407 {
 408         if (ordered && !fXTabsSorted) {
 409                 Layout();
 410                 fXTabList.SortItems(CompareXTabFunc);
 411                 fXTabsSorted = true;
 412         }
 413         return fXTabList.ItemAt(index);
 414 }
 415
 416
 417 XTab*
 418 BALMLayout::XTabAt(int32 index) const
 419 {
 420         return fXTabList.ItemAt(index);
 421 }
 422
 423
 424 YTab*
 425 BALMLayout::YTabAt(int32 index, bool ordered)
 426 {
 427         if (ordered && !fYTabsSorted) {
 428                 Layout();
 429                 fYTabList.SortItems(CompareYTabFunc);
 430                 fYTabsSorted = true;
 431         }
 432         return fYTabList.ItemAt(index);
 433 }
 434
 435
 436 YTab*
 437 BALMLayout::YTabAt(int32 index) const
 438 {
 439         return fYTabList.ItemAt(index);
 440 }
 441
 442
 443 const XTabList
 444 BALMLayout::GetXTabs() const
 445 {
 446         return fXTabList;
 447 }
 448
 449
 450 const YTabList
 451 BALMLayout::GetYTabs() const
 452 {
 453         return fYTabList;
 454 }
 455
 456
 457 int32
 458 BALMLayout::IndexOf(XTab* tab, bool ordered)
 459 {
 460         if (ordered && !fXTabsSorted) {
 461                 Layout();
 462                 fXTabList.SortItems(CompareXTabFunc);
 463                 fXTabsSorted = true;
 464         }
 465         return fXTabList.IndexOf(tab);
 466 }
 467
 468
 469 int32
 470 BALMLayout::IndexOf(YTab* tab, bool ordered)
 471 {
 472         if (ordered && !fYTabsSorted) {
 473                 Layout();
 474                 fYTabList.SortItems(CompareYTabFunc);
 475                 fYTabsSorted = true;
 476         }
 477         return fYTabList.IndexOf(tab);
 478 }
 479
 480
 481 int32
 482 BALMLayout::CountConstraints() const
 483 {
 484         return fConstraints.CountItems();
 485 }
 486
 487
 488 Constraint*
 489 BALMLayout::ConstraintAt(int32 index) const
 490 {
 491         return fConstraints.ItemAt(index);
 492 }
 493
 494
 495 bool
 496 BALMLayout::AddConstraint(Constraint* constraint)
 497 {
 498         fConstraints.AddItem(constraint);
 499         return Solver()->AddConstraint(constraint);
 500 }
 501
 502
 503 bool
 504 BALMLayout::RemoveConstraint(Constraint* constraint,
 505         bool deleteConstraint)
 506 {
 507         if (!fConstraints.RemoveItem(constraint))
 508                 return false;
 509         return Solver()->RemoveConstraint(constraint, deleteConstraint);
 510 }
 511
 512
 513 Constraint*
 514 BALMLayout::AddConstraint(double coeff1, Variable* var1, OperatorType op,
 515         double rightSide, double penaltyNeg, double penaltyPos)
 516 {
 517         Constraint* constraint = Solver()->AddConstraint(coeff1, var1, op,
 518                 rightSide, penaltyNeg, penaltyPos);
 519         fConstraints.AddItem(constraint);
 520         return constraint;
 521 }
 522
 523
 524 Constraint*
 525 BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
 526         Variable* var2, OperatorType op, double rightSide, double penaltyNeg,
 527         double penaltyPos)
 528 {
 529         Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
 530                 op, rightSide, penaltyNeg, penaltyPos);
 531         fConstraints.AddItem(constraint);
 532         return constraint;
 533 }
 534
 535 Constraint*
 536 BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
 537         Variable* var2, double coeff3, Variable* var3, OperatorType op,
 538         double rightSide, double penaltyNeg, double penaltyPos)
 539 {
 540         Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
 541                 coeff3, var3, op, rightSide, penaltyNeg, penaltyPos);
 542         fConstraints.AddItem(constraint);
 543         return constraint;
 544 }
 545
 546
 547 Constraint*
 548 BALMLayout::AddConstraint(double coeff1, Variable* var1, double coeff2,
 549         Variable* var2, double coeff3, Variable* var3, double coeff4,
 550         Variable* var4, OperatorType op, double rightSide, double penaltyNeg,
 551         double penaltyPos)
 552 {
 553         Constraint* constraint = Solver()->AddConstraint(coeff1, var1, coeff2, var2,
 554                 coeff3, var3, coeff4, var4, op, rightSide, penaltyNeg, penaltyPos);
 555         fConstraints.AddItem(constraint);
 556         return constraint;
 557 }
 558
 559
 560 namespace {
 561
 562
 563 int
 564 CompareXTabFunc(const XTab* tab1, const XTab* tab2)
 565 {
 566         if (tab1->Value() < tab2->Value())
 567                 return -1;
 568         else if (tab1->Value() == tab2->Value())
 569                 return 0;
 570         return 1;
 571 }
 572
 573
 574 int
 575 CompareYTabFunc(const YTab* tab1, const YTab* tab2)
 576 {
 577         if (tab1->Value() < tab2->Value())
 578                 return -1;
 579         else if (tab1->Value() == tab2->Value())
 580                 return 0;
 581         return 1;
 582 }
 583
 584
 585 }; // end anonymous namespace
 586
 587
 588 /**
 589  * Adds a new row to the specification that is glued to the given y-tabs.
 590  *
 591  * @param top
 592  * @param bottom
 593  * @return the new row
 594  */
 595 Row*
 596 BALMLayout::AddRow(YTab* _top, YTab* _bottom)
 597 {
 598         BReference<YTab> top = _top;
 599         BReference<YTab> bottom = _bottom;
 600         if (_top == NULL)
 601                 top = AddYTab();
 602         if (_bottom == NULL)
 603                 bottom = AddYTab();
 604         return new(std::nothrow) Row(Solver(), top, bottom);
 605 }
 606
 607
 608 /**
 609  * Adds a new column to the specification that is glued to the given x-tabs.
 610  *
 611  * @param left
 612  * @param right
 613  * @return the new column
 614  */
 615 Column*
 616 BALMLayout::AddColumn(XTab* _left, XTab* _right)
 617 {
 618         BReference<XTab> left = _left;
 619         BReference<XTab> right = _right;
 620         if (_left == NULL)
 621                 left = AddXTab();
 622         if (_right == NULL)
 623                 right = AddXTab();
 624         return new(std::nothrow) Column(Solver(), left, right);
 625 }
 626
 627
 628 Area*
 629 BALMLayout::AreaFor(int32 id) const
 630 {
 631         int32 areaCount = CountAreas();
 632         for (int32 i = 0; i < areaCount; i++) {
 633                 Area* area = AreaAt(i);
 634                 if (area->ID() == id)
 635                         return area;
 636         }
 637         return NULL;
 638 }
 639
 640
 641 /**
 642  * Finds the area that contains the given control.
 643  *
 644  * @param control       the control to look for
 645  * @return the area that contains the control
 646  */
 647 Area*
 648 BALMLayout::AreaFor(const BView* control) const
 649 {
 650         return AreaFor(ItemAt(IndexOfView(const_cast<BView*>(control))));
 651 }
 652
 653
 654 Area*
 655 BALMLayout::AreaFor(const BLayoutItem* item) const
 656 {
 657         if (!item)
 658                 return NULL;
 659         return static_cast<Area*>(item->LayoutData());
 660 }
 661
 662
 663 int32
 664 BALMLayout::CountAreas() const
 665 {
 666         return CountItems();
 667 }
 668
 669
 670 Area*
 671 BALMLayout::AreaAt(int32 index) const
 672 {
 673         return AreaFor(ItemAt(index));
 674 }
 675
 676
 677 XTab*
 678 BALMLayout::LeftOf(const BView* view) const
 679 {
 680         Area* area = AreaFor(view);
 681         if (!area)
 682                 return NULL;
 683         return area->Left();
 684 }
 685
 686
 687 XTab*
 688 BALMLayout::LeftOf(const BLayoutItem* item) const
 689 {
 690         Area* area = AreaFor(item);
 691         if (!area)
 692                 return NULL;
 693         return area->Left();
 694 }
 695
 696
 697 XTab*
 698 BALMLayout::RightOf(const BView* view) const
 699 {
 700         Area* area = AreaFor(view);
 701         if (!area)
 702                 return NULL;
 703         return area->Right();
 704 }
 705
 706
 707 XTab*
 708 BALMLayout::RightOf(const BLayoutItem* item) const
 709 {
 710         Area* area = AreaFor(item);
 711         if (!area)
 712                 return NULL;
 713         return area->Right();
 714 }
 715
 716
 717 YTab*
 718 BALMLayout::TopOf(const BView* view) const
 719 {
 720         Area* area = AreaFor(view);
 721         if (!area)
 722                 return NULL;
 723         return area->Top();
 724 }
 725
 726
 727 YTab*
 728 BALMLayout::TopOf(const BLayoutItem* item) const
 729 {
 730         Area* area = AreaFor(item);
 731         if (!area)
 732                 return NULL;
 733         return area->Top();
 734 }
 735
 736
 737 YTab*
 738 BALMLayout::BottomOf(const BView* view) const
 739 {
 740         Area* area = AreaFor(view);
 741         if (!area)
 742                 return NULL;
 743         return area->Bottom();
 744 }
 745
 746
 747 YTab*
 748 BALMLayout::BottomOf(const BLayoutItem* item) const
 749 {
 750         Area* area = AreaFor(item);
 751         if (!area)
 752                 return NULL;
 753         return area->Bottom();
 754 }
 755
 756
 757 BLayoutItem*
 758 BALMLayout::AddView(BView* child)
 759 {
 760         return AddView(-1, child);
 761 }
 762
 763
 764 BLayoutItem*
 765 BALMLayout::AddView(int32 index, BView* child)
 766 {
 767         return BAbstractLayout::AddView(index, child);
 768 }
 769
 770
 771 /**
 772  * Adds a new area to the specification, automatically setting preferred size constraints.
 773  *
 774  * @param left                  left border
 775  * @param top                   top border
 776  * @param right         right border
 777  * @param bottom                bottom border
 778  * @param content               the control which is the area content
 779  * @return the new area
 780  */
 781 Area*
 782 BALMLayout::AddView(BView* view, XTab* left, YTab* top, XTab* right,
 783         YTab* bottom)
 784 {
 785         BLayoutItem* item = _LayoutItemToAdd(view);
 786         Area* area = AddItem(item, left, top, right, bottom);
 787         if (!area) {
 788                 if (item != view->GetLayout())
 789                         delete item;
 790                 return NULL;
 791         }
 792         return area;
 793 }
 794
 795
 796 /**
 797  * Adds a new area to the specification, automatically setting preferred size constraints.
 798  *
 799  * @param row                   the row that defines the top and bottom border
 800  * @param column                the column that defines the left and right border
 801  * @param content               the control which is the area content
 802  * @return the new area
 803  */
 804 Area*
 805 BALMLayout::AddView(BView* view, Row* row, Column* column)
 806 {
 807         BLayoutItem* item = _LayoutItemToAdd(view);
 808         Area* area = AddItem(item, row, column);
 809         if (!area) {
 810                 if (item != view->GetLayout())
 811                         delete item;
 812                 return NULL;
 813         }
 814         return area;
 815 }
 816
 817
 818 bool
 819 BALMLayout::AddItem(BLayoutItem* item)
 820 {
 821         return AddItem(-1, item);
 822 }
 823
 824
 825 bool
 826 BALMLayout::AddItem(int32 index, BLayoutItem* item)
 827 {
 828         if (!item)
 829                 return false;
 830
 831         // simply add the item at the upper right corner of the previous item
 832         // TODO maybe find a more elegant solution
 833         XTab* left = Left();
 834         YTab* top = Top();
 835
 836         // check range
 837         if (index < 0 || index > CountItems())
 838                 index = CountItems();
 839
 840         // for index = 0 we already have set the right tabs
 841         if (index != 0) {
 842                 BLayoutItem* prevItem = ItemAt(index - 1);
 843                 Area* area = AreaFor(prevItem);
 844                 if (area) {
 845                         left = area->Right();
 846                         top = area->Top();
 847                 }
 848         }
 849         Area* area = AddItem(item, left, top);
 850         return area ? true : false;
 851 }
 852
 853
 854 Area*
 855 BALMLayout::AddItem(BLayoutItem* item, XTab* _left, YTab* _top, XTab* _right,
 856         YTab* _bottom)
 857 {
 858         if ((_left && !_left->IsSuitableFor(this))
 859                         || (_top && !_top->IsSuitableFor(this))
 860                         || (_right && !_right->IsSuitableFor(this))
 861                         || (_bottom && !_bottom->IsSuitableFor(this)))
 862                 debugger("Tab added to unfriendly layout!");
 863
 864         BReference<XTab> right = _right;
 865         if (right.Get() == NULL)
 866                 right = AddXTab();
 867         BReference<YTab> bottom = _bottom;
 868         if (bottom.Get() == NULL)
 869                 bottom = AddYTab();
 870         BReference<XTab> left = _left;
 871         if (left.Get() == NULL)
 872                 left = AddXTab();
 873         BReference<YTab> top = _top;
 874         if (top.Get() == NULL)
 875                 top = AddYTab();
 876
 877         TabAddTransaction<XTab> leftTabAdd(this);
 878         if (!leftTabAdd.AttempAdd(left))
 879                 return NULL;
 880
 881         TabAddTransaction<YTab> topTabAdd(this);
 882         if (!topTabAdd.AttempAdd(top))
 883                 return NULL;
 884
 885         TabAddTransaction<XTab> rightTabAdd(this);
 886         if (!rightTabAdd.AttempAdd(right))
 887                 return NULL;
 888
 889         TabAddTransaction<YTab> bottomTabAdd(this);
 890         if (!bottomTabAdd.AttempAdd(bottom))
 891                 return NULL;
 892
 893         // Area is added in ItemAdded
 894         if (!BAbstractLayout::AddItem(-1, item))
 895                 return NULL;
 896         Area* area = AreaFor(item);
 897         if (!area) {
 898                 RemoveItem(item);
 899                 return NULL;
 900         }
 901
 902         fSolver->Invalidate(true);
 903         area->_Init(Solver(), left, top, right, bottom, fRowColumnManager);
 904         fRowColumnManager->AddArea(area);
 905
 906         leftTabAdd.Commit();
 907         topTabAdd.Commit();
 908         rightTabAdd.Commit();
 909         bottomTabAdd.Commit();
 910         return area;
 911 }
 912
 913
 914 Area*
 915 BALMLayout::AddItem(BLayoutItem* item, Row* row, Column* column)
 916 {
 917         if (!BAbstractLayout::AddItem(-1, item))
 918                 return NULL;
 919         Area* area = AreaFor(item);
 920         if (!area)
 921                 return NULL;
 922
 923         fSolver->Invalidate(true);
 924         area->_Init(Solver(), row, column, fRowColumnManager);
 925
 926         fRowColumnManager->AddArea(area);
 927         return area;
 928 }
 929
 930
 931 /**
 932  * Gets the left variable.
 933  */
 934 XTab*
 935 BALMLayout::Left() const
 936 {
 937         return fLeft;
 938 }
 939
 940
 941 /**
 942  * Gets the right variable.
 943  */
 944 XTab*
 945 BALMLayout::Right() const
 946 {
 947         return fRight;
 948 }
 949
 950
 951 /**
 952  * Gets the top variable.
 953  */
 954 YTab*
 955 BALMLayout::Top() const
 956 {
 957         return fTop;
 958 }
 959
 960
 961 /**
 962  * Gets the bottom variable.
 963  */
 964 YTab*
 965 BALMLayout::Bottom() const
 966 {
 967         return fBottom;
 968 }
 969
 970
 971 void
 972 BALMLayout::SetBadLayoutPolicy(BadLayoutPolicy* policy)
 973 {
 974         if (fBadLayoutPolicy != policy)
 975                 delete fBadLayoutPolicy;
 976         if (policy == NULL)
 977                 policy = new DefaultPolicy();
 978         fBadLayoutPolicy = policy;
 979 }
 980
 981
 982 struct BALMLayout::BadLayoutPolicy*
 983 BALMLayout::GetBadLayoutPolicy() const
 984 {
 985         return fBadLayoutPolicy;
 986 }
 987
 988
 989 /**
 990  * Gets minimum size.
 991  */
 992 BSize
 993 BALMLayout::BaseMinSize()
 994 {
 995         ResultType result = fSolver->ValidateMinSize();
 996         if (result != kOptimal && result != kUnbounded)
 997                 fBadLayoutPolicy->OnBadLayout(this, result, NULL);
 998         return fMinSize;
 999 }
1000
1001
1002 /**
1003  * Gets maximum size.
1004  */
1005 BSize
1006 BALMLayout::BaseMaxSize()
1007 {
1008         ResultType result = fSolver->ValidateMaxSize();
1009         if (result != kOptimal && result != kUnbounded)
1010                 fBadLayoutPolicy->OnBadLayout(this, result, NULL);
1011         return fMaxSize;
1012 }
1013
1014
1015 /**
1016  * Gets preferred size.
1017  */
1018 BSize
1019 BALMLayout::BasePreferredSize()
1020 {
1021         ResultType result = fSolver->ValidatePreferredSize();
1022         if (result != kOptimal)
1023                 fBadLayoutPolicy->OnBadLayout(this, result, NULL);
1024
1025         return fPreferredSize;
1026 }
1027
1028
1029 /**
1030  * Gets the alignment.
1031  */
1032 BAlignment
1033 BALMLayout::BaseAlignment()
1034 {
1035         BAlignment alignment;
1036         alignment.SetHorizontal(B_ALIGN_HORIZONTAL_CENTER);
1037         alignment.SetVertical(B_ALIGN_VERTICAL_CENTER);
1038         return alignment;
1039 }
1040
1041
1042 status_t
1043 BALMLayout::Archive(BMessage* into, bool deep) const
1044 {
1045         BArchiver archiver(into);
1046         status_t err = BAbstractLayout::Archive(into, deep);
1047         if (err != B_OK)
1048                 return archiver.Finish(err);
1049
1050         BRect insets(fLeftInset, fTopInset, fRightInset, fBottomInset);
1051         err = into->AddRect(kInsetsField, insets);
1052         if (err != B_OK)
1053                 return archiver.Finish(err);
1054
1055         BSize spacing(fHSpacing, fVSpacing);
1056         err = into->AddSize(kSpacingField, spacing);
1057         if (err != B_OK)
1058                 return archiver.Finish(err);
1059
1060         if (deep) {
1061                 for (int32 i = CountXTabs() - 1; i >= 0 && err == B_OK; i--)
1062                         err = archiver.AddArchivable(kXTabsField, XTabAt(i));
1063
1064                 for (int32 i = CountYTabs() - 1; i >= 0 && err == B_OK; i--)
1065                         err = archiver.AddArchivable(kYTabsField, YTabAt(i));
1066
1067                 err = archiver.AddArchivable(kBadLayoutPolicyField, fBadLayoutPolicy);
1068         }
1069
1070         if (err == B_OK)
1071                 err = archiver.AddArchivable(kSolverField, fSolver);
1072
1073         if (err == B_OK)
1074                 err = archiver.AddArchivable(kMyTabsField, fLeft);
1075         if (err == B_OK)
1076                 err = archiver.AddArchivable(kMyTabsField, fTop);
1077         if (err == B_OK)
1078                 err = archiver.AddArchivable(kMyTabsField, fRight);
1079         if (err == B_OK)
1080                 err = archiver.AddArchivable(kMyTabsField, fBottom);
1081
1082         return archiver.Finish(err);
1083 }
1084
1085
1086 BArchivable*
1087 BALMLayout::Instantiate(BMessage* from)
1088 {
1089         if (validate_instantiation(from, "BALM::BALMLayout"))
1090                 return new BALMLayout(from);
1091         return NULL;
1092 }
1093
1094
1095 status_t
1096 BALMLayout::ItemArchived(BMessage* into, BLayoutItem* item, int32 index) const
1097 {
1098         BArchiver archiver(into);
1099         status_t err = BAbstractLayout::ItemArchived(into, item, index);
1100         if (err != B_OK)
1101                 return err;
1102
1103         Area* area = AreaFor(item);
1104         err = into->AddSize(kItemPenalties, area->fShrinkPenalties);
1105         if (err == B_OK)
1106                 err = into->AddSize(kItemPenalties, area->fGrowPenalties);
1107         if (err == B_OK)
1108                 err = into->AddSize(kItemInsets, area->fLeftTopInset);
1109         if (err == B_OK)
1110                 err = into->AddSize(kItemInsets, area->fRightBottomInset);
1111         if (err == B_OK)
1112                 err = into->AddDouble(kItemAspectRatio, area->fContentAspectRatio);
1113
1114         err = archiver.AddArchivable(kTabsField, area->Left());
1115         if (err == B_OK)
1116                 archiver.AddArchivable(kTabsField, area->Top());
1117         if (err == B_OK)
1118                 archiver.AddArchivable(kTabsField, area->Right());
1119         if (err == B_OK)
1120                 archiver.AddArchivable(kTabsField, area->Bottom());
1121
1122         return err;
1123 }
1124
1125
1126 status_t
1127 BALMLayout::ItemUnarchived(const BMessage* from, BLayoutItem* item,
1128         int32 index)
1129 {
1130         BUnarchiver unarchiver(from);
1131         status_t err = BAbstractLayout::ItemUnarchived(from, item, index);
1132         if (err != B_OK)
1133                 return err;
1134
1135         Area* area = AreaFor(item);
1136         XTab* left;
1137         XTab* right;
1138         YTab* bottom;
1139         YTab* top;
1140         err = unarchiver.FindObject(kTabsField, index * 4, left);
1141         if (err == B_OK)
1142                 err = unarchiver.FindObject(kTabsField, index * 4 + 1, top);
1143         if (err == B_OK)
1144                 err = unarchiver.FindObject(kTabsField, index * 4 + 2, right);
1145         if (err == B_OK)
1146                 err = unarchiver.FindObject(kTabsField, index * 4 + 3, bottom);
1147
1148         if (err != B_OK)
1149                 return err;
1150
1151         area->_Init(Solver(), left, top, right, bottom, fRowColumnManager);
1152         fRowColumnManager->AddArea(area);
1153
1154         err = from->FindSize(kItemPenalties, index * 2, &area->fShrinkPenalties);
1155         if (err != B_OK)
1156                 return err;
1157
1158         err = from->FindSize(kItemPenalties, index * 2 + 1, &area->fGrowPenalties);
1159         if (err != B_OK)
1160                 return err;
1161
1162         err = from->FindSize(kItemInsets, index * 2, &area->fLeftTopInset);
1163         if (err != B_OK)
1164                 return err;
1165
1166         err = from->FindSize(kItemInsets, index * 2 + 1, &area->fRightBottomInset);
1167
1168         if (err == B_OK) {
1169                 double contentAspectRatio;
1170                 err = from->FindDouble(kItemAspectRatio, index, &contentAspectRatio);
1171                 if (err == B_OK)
1172                         area->SetContentAspectRatio(contentAspectRatio);
1173         }
1174
1175         return err;
1176 }
1177
1178
1179 status_t
1180 BALMLayout::AllUnarchived(const BMessage* archive)
1181 {
1182         BUnarchiver unarchiver(archive);
1183
1184         SharedSolver* solver;
1185         status_t err = unarchiver.FindObject(kSolverField, solver);
1186
1187         if (err != B_OK)
1188                 return err;
1189
1190         _SetSolver(solver);
1191
1192         if (archive->GetInfo(kBadLayoutPolicyField, NULL) == B_OK) {
1193                 BadLayoutPolicy* policy;
1194                 err = unarchiver.FindObject(kBadLayoutPolicyField, policy);
1195                 if (err == B_OK)
1196                         SetBadLayoutPolicy(policy);
1197         }
1198
1199         LinearSpec* spec = Solver();
1200         int32 tabCount = 0;
1201         archive->GetInfo(kXTabsField, NULL, &tabCount);
1202         for (int32 i = 0; i < tabCount && err == B_OK; i++) {
1203                 XTab* tab;
1204                 err = unarchiver.FindObject(kXTabsField, i,
1205                         BUnarchiver::B_DONT_ASSUME_OWNERSHIP, tab);
1206                 spec->AddVariable(tab);
1207                 TabAddTransaction<XTab> adder(this);
1208                 if (adder.AttempAdd(tab))
1209                         adder.Commit();
1210                 else
1211                         err = B_NO_MEMORY;
1212         }
1213
1214         archive->GetInfo(kYTabsField, NULL, &tabCount);
1215         for (int32 i = 0; i < tabCount; i++) {
1216                 YTab* tab;
1217                 unarchiver.FindObject(kYTabsField, i,
1218                         BUnarchiver::B_DONT_ASSUME_OWNERSHIP, tab);
1219                 spec->AddVariable(tab);
1220                 TabAddTransaction<YTab> adder(this);
1221                 if (adder.AttempAdd(tab))
1222                         adder.Commit();
1223                 else
1224                         err = B_NO_MEMORY;
1225         }
1226
1227
1228         if (err == B_OK) {
1229                 XTab* leftTab = NULL;
1230                 err = unarchiver.FindObject(kMyTabsField, 0, leftTab);
1231                 fLeft = leftTab;
1232         }
1233
1234         if (err == B_OK) {
1235                 YTab* topTab = NULL;
1236                 err = unarchiver.FindObject(kMyTabsField, 1, topTab);
1237                 fTop = topTab;
1238         }
1239
1240         if (err == B_OK) {
1241                 XTab* rightTab = NULL;
1242                 err = unarchiver.FindObject(kMyTabsField, 2, rightTab);
1243                 fRight = rightTab;
1244         }
1245
1246         if (err == B_OK) {
1247                 YTab* bottomTab = NULL;
1248                 err = unarchiver.FindObject(kMyTabsField, 3, bottomTab);
1249                 fBottom = bottomTab;
1250         }
1251
1252         if (err == B_OK) {
1253                 fLeft->SetRange(0, 0);
1254                 fTop->SetRange(0, 0);
1255
1256                 err = BAbstractLayout::AllUnarchived(archive);
1257         }
1258         return err;
1259 }
1260
1261
1262 status_t
1263 BALMLayout::AllArchived(BMessage* archive) const
1264 {
1265         status_t err = BAbstractLayout::AllArchived(archive);
1266
1267         return err;
1268 }
1269
1270
1271 /**
1272  * Invalidates the layout.
1273  * Resets minimum/maximum/preferred size.
1274  */
1275 void
1276 BALMLayout::LayoutInvalidated(bool children)
1277 {
1278         fMinSize = kUnsetSize;
1279         fMaxSize = kUnsetSize;
1280         fPreferredSize = kUnsetSize;
1281         fXTabsSorted = false;
1282         fYTabsSorted = false;
1283
1284         if (fSolver)
1285                 fSolver->Invalidate(children);
1286 }
1287
1288
1289 bool
1290 BALMLayout::ItemAdded(BLayoutItem* item, int32 atIndex)
1291 {
1292         item->SetLayoutData(new(std::nothrow) Area(item));
1293         return item->LayoutData() != NULL;
1294 }
1295
1296
1297 void
1298 BALMLayout::ItemRemoved(BLayoutItem* item, int32 fromIndex)
1299 {
1300         if (Area* area = AreaFor(item)) {
1301                 fRowColumnManager->RemoveArea(area);
1302                 item->SetLayoutData(NULL);
1303                 delete area;
1304         }
1305 }
1306
1307
1308 /**
1309  * Calculate and set the layout.
1310  * If no layout specification is given, a specification is reverse engineered automatically.
1311  */
1312 void
1313 BALMLayout::DoLayout()
1314 {
1315         BLayoutContext* context = LayoutContext();
1316         ResultType result = fSolver->ValidateLayout(context);
1317         if (result != kOptimal
1318                         && !fBadLayoutPolicy->OnBadLayout(this, result, context)) {
1319                 return;
1320         }
1321
1322         // set the calculated positions and sizes for every area
1323         for (int32 i = 0; i < CountItems(); i++)
1324                 AreaFor(ItemAt(i))->_DoLayout(LayoutArea().LeftTop());
1325
1326         fXTabsSorted = false;
1327         fYTabsSorted = false;
1328 }
1329
1330
1331 LinearSpec*
1332 BALMLayout::Solver() const
1333 {
1334         return fSolver->Solver();
1335 }
1336
1337
1338 ResultType
1339 BALMLayout::ValidateLayout()
1340 {
1341         // we explicitly recaluclate the layout so set the invalidate flag first
1342         fSolver->Invalidate(true);
1343
1344         BLayoutContext* context = LayoutContext();
1345         return fSolver->ValidateLayout(context);
1346 }
1347
1348
1349 void
1350 BALMLayout::SetInsets(float left, float top, float right,
1351         float bottom)
1352 {
1353         fLeftInset = BControlLook::ComposeSpacing(left);
1354         fTopInset = BControlLook::ComposeSpacing(top);
1355         fRightInset = BControlLook::ComposeSpacing(right);
1356         fBottomInset = BControlLook::ComposeSpacing(bottom);
1357
1358         InvalidateLayout();
1359 }
1360
1361
1362 void
1363 BALMLayout::SetInsets(float horizontal, float vertical)
1364 {
1365         fLeftInset = BControlLook::ComposeSpacing(horizontal);
1366         fRightInset = fLeftInset;
1367
1368         fTopInset = BControlLook::ComposeSpacing(vertical);
1369         fBottomInset = fTopInset;
1370
1371         InvalidateLayout();
1372 }
1373
1374
1375 void
1376 BALMLayout::SetInsets(float insets)
1377 {
1378         fLeftInset = BControlLook::ComposeSpacing(insets);
1379         fRightInset = fLeftInset;
1380         fTopInset = fLeftInset;
1381         fBottomInset = fLeftInset;
1382
1383         InvalidateLayout();
1384 }
1385
1386
1387 void
1388 BALMLayout::GetInsets(float* left, float* top, float* right,
1389         float* bottom) const
1390 {
1391         if (left)
1392                 *left = fLeftInset;
1393         if (top)
1394                 *top = fTopInset;
1395         if (right)
1396                 *right = fRightInset;
1397         if (bottom)
1398                 *bottom = fBottomInset;
1399 }
1400
1401
1402 void
1403 BALMLayout::SetSpacing(float hSpacing, float vSpacing)
1404 {
1405         fHSpacing = BControlLook::ComposeSpacing(hSpacing);
1406         fVSpacing = BControlLook::ComposeSpacing(vSpacing);
1407 }
1408
1409
1410 void
1411 BALMLayout::GetSpacing(float *_hSpacing, float *_vSpacing) const
1412 {
1413         if (_hSpacing)
1414                 *_hSpacing = fHSpacing;
1415         if (_vSpacing)
1416                 *_vSpacing = fVSpacing;
1417 }
1418
1419
1420 float
1421 BALMLayout::InsetForTab(XTab* tab) const
1422 {
1423         if (tab == fLeft.Get())
1424                 return fLeftInset;
1425         if (tab == fRight.Get())
1426                 return fRightInset;
1427         return fHSpacing / 2;
1428 }
1429
1430
1431 float
1432 BALMLayout::InsetForTab(YTab* tab) const
1433 {
1434         if (tab == fTop.Get())
1435                 return fTopInset;
1436         if (tab == fBottom.Get())
1437                 return fBottomInset;
1438         return fVSpacing / 2;
1439 }
1440
1441
1442 void
1443 BALMLayout::UpdateConstraints(BLayoutContext* context)
1444 {
1445         for (int i = 0; i < CountItems(); i++)
1446                 AreaFor(ItemAt(i))->InvalidateSizeConstraints();
1447         fRowColumnManager->UpdateConstraints();
1448 }
1449
1450
1451 void BALMLayout::_RemoveSelfFromTab(XTab* tab) { tab->LayoutLeaving(this); }
1452 void BALMLayout::_RemoveSelfFromTab(YTab* tab) { tab->LayoutLeaving(this); }
1453
1454 bool BALMLayout::_HasTabInLayout(XTab* tab) { return tab->IsInLayout(this); }
1455 bool BALMLayout::_HasTabInLayout(YTab* tab) { return tab->IsInLayout(this); }
1456
1457 bool BALMLayout::_AddedTab(XTab* tab) { return tab->AddedToLayout(this); }
1458 bool BALMLayout::_AddedTab(YTab* tab) { return tab->AddedToLayout(this); }
1459
1460
1461 BLayoutItem*
1462 BALMLayout::_LayoutItemToAdd(BView* view)
1463 {
1464         if (view->GetLayout())
1465                 return view->GetLayout();
1466         return new(std::nothrow) BViewLayoutItem(view);
1467 }
1468
1469
1470 void
1471 BALMLayout::_SetSolver(SharedSolver* solver)
1472 {
1473         fSolver = solver;
1474         fSolver->AcquireReference();
1475         fSolver->RegisterLayout(this);
1476         fRowColumnManager = new RowColumnManager(Solver());
1477 }
1478
1479
1480 status_t
1481 BALMLayout::Perform(perform_code d, void* arg)
1482 {
1483         return BAbstractLayout::Perform(d, arg);
1484 }
1485
1486
1487 void BALMLayout::_ReservedALMLayout1() {}
1488 void BALMLayout::_ReservedALMLayout2() {}
1489 void BALMLayout::_ReservedALMLayout3() {}
1490 void BALMLayout::_ReservedALMLayout4() {}
1491 void BALMLayout::_ReservedALMLayout5() {}
1492 void BALMLayout::_ReservedALMLayout6() {}
1493 void BALMLayout::_ReservedALMLayout7() {}
1494 void BALMLayout::_ReservedALMLayout8() {}
1495 void BALMLayout::_ReservedALMLayout9() {}
1496 void BALMLayout::_ReservedALMLayout10() {}
1497