Ticket #5525: splitLayout.patch

src/kits/interface/SplitLayout.cpp

@@ -5 +5 @@
 
 #include "SplitLayout.h"
 
+#include <new>
 #include <stdio.h>
 
 #include <LayoutItem.h>
 #include <LayoutUtils.h>
+#include <Message.h>
 #include <View.h>
 
 #include "OneElementLayouter.h"
 #include "SimpleLayouter.h"
 
-// ItemLayoutInfo
+// archivng constants
+namespace {
+    const char* kInfoCollapsibleField = "BSplitLayout::info::collapsible";
+    const char* kInfoWeightField = "BSplitLayout::info::weight";
+    const char* kSpacingField = "BSplitLayout::spacing"; 
+    const char* kSplitterSizeField = "BSplitLayout::splitterSize";
+    const char* kIsVerticalField = "BSplitLayout::vertical";
+    const char* kTopInsetField = "BSplitLayout::TopInset";
+    const char* kBottomInsetField = "BSplitLayout::BottomInset";
+    const char* kLeftInsetField = "BSplitLayout::LeftInset";
+    const char* kRightInsetField = "BSplitLayout::RightInset";
+}
+
+
 class BSplitLayout::ItemLayoutInfo {
 public:
     float       weight;
@@ -25 +40 @@
     bool        isCollapsible;
 
     ItemLayoutInfo()
-        : weight(1.0f),
-          layoutFrame(0, 0, -1, -1),
-          min(),
-          max(),
-          isVisible(true),
-          isCollapsible(true)
+        :
+        weight(1.0f),
+        layoutFrame(0, 0, -1, -1),
+        min(),
+        max(),
+        isVisible(true),
+        isCollapsible(true)
     {
     }
 };
 
-// ValueRange
+
 class BSplitLayout::ValueRange {
 public:
     int32 sumValue; // including spacing
@@ -47 +63 @@
     int32 nextSize;
 };
 
-// SplitterItem
+
 class BSplitLayout::SplitterItem : public BLayoutItem {
 public:
     SplitterItem(BSplitLayout* layout)
-        : fLayout(layout),
-          fFrame()
+        :
+        fLayout(layout),
+        fFrame()
     {
     }
 
+
     virtual BSize MinSize()
     {
         if (fLayout->Orientation() == B_HORIZONTAL)
@@ -128 +146 @@
     BRect           fFrame;
 };
 
-
 // #pragma mark -
 
 
-// constructor
+
 BSplitLayout::BSplitLayout(enum orientation orientation,
         float spacing)
-    : fOrientation(orientation),
-      fLeftInset(0),
-      fRightInset(0),
-      fTopInset(0),
-      fBottomInset(0),
-      fSplitterSize(6),
-      fSpacing(spacing),
+    :
+    fOrientation(orientation),
+    fLeftInset(0),
+    fRightInset(0),
+    fTopInset(0),
+    fBottomInset(0),
+    fSplitterSize(6),
+    fSpacing(spacing),
 
-      fSplitterItems(),
-      fVisibleItems(),
-      fMin(),
-      fMax(),
-      fPreferred(),
+    fSplitterItems(),
+    fVisibleItems(),
+    fMin(),
+    fMax(),
+    fPreferred(),
 
-      fHorizontalLayouter(NULL),
-      fVerticalLayouter(NULL),
-      fHorizontalLayoutInfo(NULL),
-      fVerticalLayoutInfo(NULL),
+    fHorizontalLayouter(NULL),
+    fVerticalLayouter(NULL),
+    fHorizontalLayoutInfo(NULL),
+    fVerticalLayoutInfo(NULL),
 
-      fHeightForWidthItems(),
-      fHeightForWidthVerticalLayouter(NULL),
-      fHeightForWidthHorizontalLayoutInfo(NULL),
+    fHeightForWidthItems(),
+    fHeightForWidthVerticalLayouter(NULL),
+    fHeightForWidthHorizontalLayoutInfo(NULL),
 
-      fLayoutValid(false),
+    fLayoutValid(false),
 
-      fCachedHeightForWidthWidth(-2),
-      fHeightForWidthVerticalLayouterWidth(-2),
-      fCachedMinHeightForWidth(-1),
-      fCachedMaxHeightForWidth(-1),
-      fCachedPreferredHeightForWidth(-1),
+    fCachedHeightForWidthWidth(-2),
+    fHeightForWidthVerticalLayouterWidth(-2),
+    fCachedMinHeightForWidth(-1),
+    fCachedMaxHeightForWidth(-1),
+    fCachedPreferredHeightForWidth(-1),
 
-      fDraggingStartPoint(),
-      fDraggingStartValue(0),
-      fDraggingCurrentValue(0),
-      fDraggingSplitterIndex(-1)
+    fDraggingStartPoint(),
+    fDraggingStartValue(0),
+    fDraggingCurrentValue(0),
+    fDraggingSplitterIndex(-1)
 {
 }
 
-// destructor
+
+BSplitLayout::BSplitLayout(BMessage* from)
+    :
+    BLayout(from),
+    fSplitterItems(),
+    fVisibleItems(),
+    fMin(),
+    fMax(),
+    fPreferred(),
+    
+    fHorizontalLayouter(NULL),
+    fVerticalLayouter(NULL),
+    fHorizontalLayoutInfo(NULL),
+    fVerticalLayoutInfo(NULL),
+    
+    fHeightForWidthItems(),
+    fHeightForWidthVerticalLayouter(NULL),
+    fHeightForWidthHorizontalLayoutInfo(NULL),
+    
+    fLayoutValid(false),
+    
+    fCachedHeightForWidthWidth(-2),
+    fHeightForWidthVerticalLayouterWidth(-2),
+    fCachedMinHeightForWidth(-1),
+    fCachedMaxHeightForWidth(-1),
+    fCachedPreferredHeightForWidth(-1),
+    
+    fDraggingStartPoint(),
+    fDraggingStartValue(0),
+    fDraggingCurrentValue(0),
+    fDraggingSplitterIndex(-1)
+{
+    bool isVertical;
+    from->FindBool(kIsVerticalField, &isVertical);
+    fOrientation = (isVertical) ? B_VERTICAL : B_HORIZONTAL ;
+
+    from->FindFloat(kLeftInsetField, &fLeftInset);
+    from->FindFloat(kRightInsetField, &fRightInset);
+    from->FindFloat(kTopInsetField, &fTopInset);
+    from->FindFloat(kBottomInsetField, &fBottomInset);
+    from->FindFloat(kSplitterSizeField, &fSplitterSize);
+    from->FindFloat(kSpacingField, &fSpacing);
+}
+
+
 BSplitLayout::~BSplitLayout()
 {
 }
 
-// SetInsets
+
 void
 BSplitLayout::SetInsets(float left, float top, float right, float bottom)
 {
@@ -190 +252 @@
     InvalidateLayout();
 }
 
-// GetInsets
+
 void
 BSplitLayout::GetInsets(float* left, float* top, float* right,
     float* bottom) const
@@ -205 +267 @@
         *bottom = fBottomInset;
 }
 
-// Spacing
+
 float
 BSplitLayout::Spacing() const
 {
     return fSpacing;
 }
 
-// SetSpacing
+
 void
 BSplitLayout::SetSpacing(float spacing)
 {
@@ -223 +285 @@
     }
 }
 
-// Orientation
+
 orientation
 BSplitLayout::Orientation() const
 {
     return fOrientation;
 }
 
-// SetOrientation
+
 void
 BSplitLayout::SetOrientation(enum orientation orientation)
 {
@@ -241 +303 @@
     }
 }
 
-// SplitterSize
+
 float
 BSplitLayout::SplitterSize() const
 {
     return fSplitterSize;
 }
 
-// SetSplitterSize
+
 void
 BSplitLayout::SetSplitterSize(float size)
 {
@@ -259 +321 @@
     }
 }
 
-// AddView
+
 BLayoutItem*
 BSplitLayout::AddView(BView* child)
 {
     return BLayout::AddView(child);
 }
 
-// AddView
+
 BLayoutItem*
 BSplitLayout::AddView(int32 index, BView* child)
 {
     return BLayout::AddView(index, child);
 }
 
-// AddView
+
 BLayoutItem*
 BSplitLayout::AddView(BView* child, float weight)
 {
     return AddView(-1, child, weight);
 }
 
-// AddView
+
 BLayoutItem*
 BSplitLayout::AddView(int32 index, BView* child, float weight)
 {
@@ -291 +353 @@
     return item;
 }
 
-// AddItem
+
 bool
 BSplitLayout::AddItem(BLayoutItem* item)
 {
     return BLayout::AddItem(item);
 }
 
-// AddItem
+
 bool
 BSplitLayout::AddItem(int32 index, BLayoutItem* item)
 {
     return BLayout::AddItem(index, item);
 }
 
-// AddItem
+
 bool
 BSplitLayout::AddItem(BLayoutItem* item, float weight)
 {
     return AddItem(-1, item, weight);
 }
 
-// AddItem
+
 bool
 BSplitLayout::AddItem(int32 index, BLayoutItem* item, float weight)
 {
@@ -323 +385 @@
     return success;
 }
 
-// ItemWeight
+
 float
 BSplitLayout::ItemWeight(int32 index) const
 {
@@ -333 +395 @@
     return ItemWeight(ItemAt(index));
 }
 
-// ItemWeight
+
 float
 BSplitLayout::ItemWeight(BLayoutItem* item) const
 {
@@ -342 +404 @@
     return 0;
 }
 
-// SetItemWeight
+
 void
 BSplitLayout::SetItemWeight(int32 index, float weight, bool invalidateLayout)
 {
@@ -366 +428 @@
         InvalidateLayout();
 }
 
-// SetItemWeight
+
 void
 BSplitLayout::SetItemWeight(BLayoutItem* item, float weight)
 {
@@ -374 +436 @@
         info->weight = weight;
 }
 
-// SetCollapsible
+
 void
 BSplitLayout::SetCollapsible(bool collapsible)
 {
     SetCollapsible(0, CountItems() - 1, collapsible);
 }
 
-// SetCollapsible
+
 void
 BSplitLayout::SetCollapsible(int32 index, bool collapsible)
 {
     SetCollapsible(index, index, collapsible);
 }
 
-// SetCollapsible
+
 void
 BSplitLayout::SetCollapsible(int32 first, int32 last, bool collapsible)
 {
@@ -401 +463 @@
         _ItemLayoutInfo(ItemAt(i))->isCollapsible = collapsible;
 }
 
-// MinSize
+
 BSize
 BSplitLayout::MinSize()
 {
@@ -410 +472 @@
     return _AddInsets(fMin);
 }
 
-// MaxSize
+
 BSize
 BSplitLayout::MaxSize()
 {
@@ -419 +481 @@
     return _AddInsets(fMax);
 }
 
-// PreferredSize
+
 BSize
 BSplitLayout::PreferredSize()
 {
@@ -428 +490 @@
     return _AddInsets(fPreferred);
 }
 
-// Alignment
+
 BAlignment
 BSplitLayout::Alignment()
 {
     return BAlignment(B_ALIGN_USE_FULL_WIDTH, B_ALIGN_USE_FULL_HEIGHT);
 }
 
-// HasHeightForWidth
+
 bool
 BSplitLayout::HasHeightForWidth()
 {
@@ -444 +506 @@
     return !fHeightForWidthItems.IsEmpty();
 }
 
-// GetHeightForWidth
+
 void
 BSplitLayout::GetHeightForWidth(float width, float* min, float* max,
     float* preferred)
@@ -457 +519 @@
     _AddInsets(min, max, preferred);
 }
 
-// InvalidateLayout
+
 void
 BSplitLayout::InvalidateLayout()
 {
     _InvalidateLayout(true);
 }
 
-// LayoutView
+
 void
 BSplitLayout::LayoutView()
 {
@@ -543 +605 @@
     fLayoutValid = true;
 }
 
-// SplitterItemFrame
+
 BRect
 BSplitLayout::SplitterItemFrame(int32 index) const
 {
@@ -552 +614 @@
     return BRect();
 }
 
-// IsAboveSplitter
+
 bool
 BSplitLayout::IsAboveSplitter(const BPoint& point) const
 {
     return _SplitterItemAt(point) != NULL;
 }
 
-// StartDraggingSplitter
+
 bool
 BSplitLayout::StartDraggingSplitter(BPoint point)
 {
@@ -589 +651 @@
     return false;
 }
 
-// DragSplitter
+
 bool
 BSplitLayout::DragSplitter(BPoint point)
 {
@@ -608 +670 @@
         fDraggingStartValue + valueDiff);
 }
 
-// StopDraggingSplitter
+
 bool
 BSplitLayout::StopDraggingSplitter()
 {
@@ -623 +685 @@
     return true;
 }
 
-// DraggedSplitter
+
 int32
 BSplitLayout::DraggedSplitter() const
 {
     return fDraggingSplitterIndex;
 }
 
-// ItemAdded
+
+status_t
+BSplitLayout::Archive(BMessage* into, bool deep) const
+{
+    BArchiver archiver(into);
+    status_t err = BLayout::Archive(into, deep);
+
+    if (err == B_OK)
+        into->AddBool(kIsVerticalField, fOrientation == B_VERTICAL);
+
+    if (err == B_OK)
+        err = into->AddFloat(kLeftInsetField, fLeftInset);
+
+    if (err == B_OK)
+        err = into->AddFloat(kRightInsetField, fRightInset);
+
+    if (err == B_OK)
+        err = into->AddFloat(kTopInsetField, fTopInset);
+
+    if (err == B_OK)
+        err = into->AddFloat(kBottomInsetField, fBottomInset);
+
+    if (err == B_OK)
+        err = into->AddFloat(kSplitterSizeField, fSplitterSize);
+
+    if (err == B_OK)
+        err = into->AddFloat(kSpacingField, fSpacing);
+
+    return archiver.Finish(err);
+}
+
+
+BArchivable*
+BSplitLayout::Instantiate(BMessage* from)
+{
+    if (validate_instantiation(from, "BSplitLayout"))
+        return new(std::nothrow) BSplitLayout(from);
+    return NULL;
+}
+
+
+status_t
+BSplitLayout::ItemArchived(BMessage* into, BLayoutItem* item, int32 index) const
+{
+    ItemLayoutInfo* info = (ItemLayoutInfo*)item->LayoutData();
+    
+    if (!info) // TODO: remove this check when AddItem() returns a bool
+        return B_ERROR;
+
+    status_t err = into->AddFloat(kInfoWeightField, info->weight);
+    if (err == B_OK)
+        err = into->AddBool(kInfoCollapsibleField, info->isCollapsible);
+
+    return err;
+} 
+
+
+status_t
+BSplitLayout::ItemUnarchived(const BMessage* from,
+    BLayoutItem* item, int32 index)
+{
+    ItemLayoutInfo* info = _ItemLayoutInfo(item);
+    status_t err = from->FindFloat(kInfoWeightField, index, &info->weight); 
+
+    if (err == B_OK) {
+        bool* collapsible = &info->isCollapsible;
+        err = from->FindBool(kInfoCollapsibleField, index, collapsible);
+    }
+    return err;
+}
+
+
 void
 BSplitLayout::ItemAdded(BLayoutItem* item)
 {
@@ -643 +776 @@
     SetItemWeight(item, 1);
 }
 
-// ItemRemoved
+
 void
 BSplitLayout::ItemRemoved(BLayoutItem* item)
 {
@@ -658 +791 @@
     item->SetLayoutData(NULL);
 }
 
-// _InvalidateLayout
+
 void
 BSplitLayout::_InvalidateLayout(bool invalidateView)
 {
@@ -680 +813 @@
     fLayoutValid = false;
 }
 
-// _InvalidateCachedHeightForWidth
+
 void
 BSplitLayout::_InvalidateCachedHeightForWidth()
 {
@@ -694 +827 @@
     fHeightForWidthVerticalLayouterWidth = -2;
 }
 
-// _SplitterItemAt
+
 BSplitLayout::SplitterItem*
 BSplitLayout::_SplitterItemAt(const BPoint& point, int32* index) const
 {
@@ -711 +844 @@
     return NULL;
 }
 
-// _SplitterItemAt
+
 BSplitLayout::SplitterItem*
 BSplitLayout::_SplitterItemAt(int32 index) const
 {
     return (SplitterItem*)fSplitterItems.ItemAt(index);
 }
 
-// _GetSplitterValueRange
+
 void
 BSplitLayout::_GetSplitterValueRange(int32 index, ValueRange& range)
 {
@@ -747 +880 @@
         range.sumValue += (int32)fSpacing;
 }
 
-// _SplitterValue
+
 int32
 BSplitLayout::_SplitterValue(int32 index) const
 {
@@ -761 +894 @@
         return 0;
 }
 
-// _LayoutItem
+
 void
 BSplitLayout::_LayoutItem(BLayoutItem* item, BRect frame, bool visible)
 {
@@ -790 +923 @@
         item->AlignInFrame(frame);
 }
 
-// _LayoutItem
+
 void
 BSplitLayout::_LayoutItem(BLayoutItem* item, ItemLayoutInfo* info)
 {
@@ -806 +939 @@
 
     item->AlignInFrame(info->layoutFrame);
 
+    // TODO: shouldn't this be done (as needed) by item->SetVisible();
     // if the item became visible, we need to update its internal layout
     if (visibilityChanged) {
         if (BView* itemView = item->View())
@@ -813 +947 @@
     }
 }
 
-// _SetSplitterValue
+
 bool
 BSplitLayout::_SetSplitterValue(int32 index, int32 value)
 {
@@ -1042 +1176 @@
     return true;
 }
 
-// _ItemLayoutInfo
+
 BSplitLayout::ItemLayoutInfo*
 BSplitLayout::_ItemLayoutInfo(BLayoutItem* item) const
 {
@@ -1055 +1189 @@
     return info;
 }
 
-// _UpdateSplitterWeights
+
 void
 BSplitLayout::_UpdateSplitterWeights()
 {
@@ -1078 +1212 @@
         _InvalidateCachedHeightForWidth();
 }
 
-// _ValidateMinMax
+
 void
 BSplitLayout::_ValidateMinMax()
 {
@@ -1152 +1286 @@
         view->ResetLayoutInvalidation();
 }
 
-// _InternalGetHeightForWidth
+
 void
 BSplitLayout::_InternalGetHeightForWidth(float width, bool realLayout,
     float* minHeight, float* maxHeight, float* preferredHeight)
@@ -1221 +1355 @@
         *preferredHeight = fCachedPreferredHeightForWidth;
 }
 
-// _SplitterSpace
+
 float
 BSplitLayout::_SplitterSpace() const
 {
@@ -1235 +1369 @@
     return space;
 }
 
-// _AddInsets
+
 BSize
 BSplitLayout::_AddInsets(BSize size)
 {
@@ -1253 +1387 @@
     return size;
 }
 
-// _AddInsets
+
 void
 BSplitLayout::_AddInsets(float* minHeight, float* maxHeight,
     float* preferredHeight)
@@ -1269 +1403 @@
         *preferredHeight = BLayoutUtils::AddDistances(*preferredHeight, insets);
 }
 
-// _SubtractInsets
+
 BSize
 BSplitLayout::_SubtractInsets(BSize size)
 {

src/kits/interface/SplitLayout.h

@@ -1 +1 @@
 /*
- * Copyright 2006, Haiku Inc.
+ * Copyright 2006-2010, Haiku Inc.
  * Distributed under the terms of the MIT License.
  */
 #ifndef _SPLIT_LAYOUT_H
@@ -25 +25 @@
 public:
                                 BSplitLayout(enum orientation orientation,
                                     float spacing = 0.0f);
+                                BSplitLayout(BMessage* from);
     virtual                     ~BSplitLayout();
 
             void                SetInsets(float left, float top, float right,
@@ -87 +88 @@
             bool                StopDraggingSplitter();
             int32               DraggedSplitter() const;
 
+    // archiving methods
+    virtual status_t            Archive(BMessage* into, bool deep = true) const;
+    static  BArchivable*        Instantiate(BMessage* from);
+
+    virtual status_t            ItemArchived(BMessage* into, BLayoutItem* item,
+                                    int32 index) const;
+    virtual status_t            ItemUnarchived(const BMessage* from,
+                                    BLayoutItem* item, int32 index);
+
 protected:
     virtual void                ItemAdded(BLayoutItem* item);
     virtual void                ItemRemoved(BLayoutItem* item);
@@ -121 +131 @@
 
             void                _ValidateMinMax();
 
-            void                 _InternalGetHeightForWidth(float width,
+            void                _InternalGetHeightForWidth(float width,
                                     bool realLayout, float* minHeight,
                                     float* maxHeight, float* preferredHeight);