Added common layout framework for system menu rows.

ash/common/system/tray/three_view_layout.h

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_COMMON_SYSTEM_TRAY_THREE_VIEW_LAYOUT_H_
+#define ASH_COMMON_SYSTEM_TRAY_THREE_VIEW_LAYOUT_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/views/layout/layout_manager.h"
+
+namespace views {
+class BoxLayout;
+class View;
+}  // namespace views
+
+namespace ash {
+class SizeRangeLayout;
+
+// A layout manager that has 3 child containers (START, CENTER, END) which can
+// be arranged vertically or horizontally. The child containers can have
+// minimum and/or maximum preferred size defined as well as a flex weight that
+// is used to distribute excess space across the main axis, i.e. flexible width
+// for the horizontal orientation. By default all the containers have a flex
+// weight of 0, meaning no flexibility, and no minimum or maximum size.
+//
+// Views are laid out within each container as per the LayoutManager that has
+// been installed on that container. By default a BoxLayout manager is installed
+// on each container with the same orientation as this has been created with.
+// The default BoxLayout will use a center alignment for both the main axis and
+// cross axis alignment.
+class ThreeViewLayout : public views::LayoutManager {

[sky, 2016/10/14 22:11:12]

How is this different than BoxLayout? I get that it's a more restrictive and
focused version, but why not add the functionality you need to BoxLayout?

[bruthig, 2016/10/17 15:53:12]

It's different in that each of the Container views have their own layout manager
set on them whereas a BoxLayout cannot do this because each 'cell' is not backed
by a View.  In the BoxLayout it would be incorrect to apply a sub layout manager
to an arbitrary child because the BoxLayout doesn't know if the child view is a
container view or not. e.g. It should not apply layout to a LabelButton child.

Another difference is that a client of the ThreeViewLayout can add child views
to any of the Container views in any order they wish and they will be laid out
within that containers space.  This is beneficial if the client only wants to
add a child view to the END container and ensure it is aligned with the View
above it, for example in the system menu rows.

It may be possible to push the min/max preferred size behavior into the
BoxLayout but I don't think it makes sense to push these other characteristics
there because the BoxLayout has no knowledge of the children views when they are
added.  i.e. the BoxLayout can be installed on any container view that already
has the children views added and it will behave nicely.  The ThreeViewLayout on
the other hand requires all child views to be added through its API.

(It may be worth considering to extend the 'Three' view property to an arbitrary
'N' view property.  But this isn't something I would want to do in this CL.)

+ public:
+  enum Orientation {
+    HORIZONTAL,
+    VERTICAL,
+  };
+
+  // The different containers that child Views can be added to.
+  enum Container { START, CENTER, END };
+
+  // Constructs a layout with Horizontal orientation.
+  //
+  // TODO(bruthig): The |padding_between_items| can only be set on BoxLayouts
+  // during construction. Investigate whether this can be a mutable property of
+  // BoxLayouts and if so consider dropping it as a constructor parameter here.
+  explicit ThreeViewLayout(int padding_between_items);
+
+  // Constructs a layout with the specified orientation and padding between
+  // child Views.
+  ThreeViewLayout(Orientation orientation, int padding_between_items);
+
+  ~ThreeViewLayout() override;
+
+  // Set the minimum cross axis size for the layout, i.e. the minimum height for
+  // a horizontal orientation.
+  void SetMinCrossAxisSize(int min_size);
+
+  // Set the minimum size for the given |container|.
+  void SetMinSize(Container container, const gfx::Size& size);
+
+  // Set the maximum size for the given |container|.
+  void SetMaxSize(Container container, const gfx::Size& size);
+
+  // Adds the child |view| to the specified |container|.
+  void AddView(Container container, views::View* view);
+
+  // Removes all current children from the specified |container| and adds the
+  // child |view| to it.
+  void SetView(Container container, views::View* view);
+
+  // Sets the |insets| that union of the Container spaces will be laied out
+  // within.
+  void SetInsets(const gfx::Insets& insets);
+
+  // Sets the |insets| within the given |container|.
+  void SetInsets(Container container, const gfx::Insets& insets);
+
+  // Sets wither the |container| is visible. When a container is set to
+  // not-visible its space will be distributed to the other visible containers.
+  void SetContainerVisible(Container container, bool visible);
+
+  // Sets the flex weight for the given |container|. Using the preferred size as
+  // the basis, free space along the main axis is distributed to views in the
+  // ratio of their flex weights. Similarly, if the views will overflow the
+  // parent, space is subtracted in these ratios.
+  //
+  // A flex of 0 means this view is not resized. Flex values must not be
+  // negative.
+  void SetFlexForView(Container container, int flex);
+
+  // Sets the |layout_manager| used by the given |container|.
+  void SetLayoutManager(Container container,
+                        std::unique_ptr<LayoutManager> layout_manager);
+
+  // LayoutManager:
+  void Installed(views::View* host) override;
+  void Uninstalled(views::View* host) override;
+  void Layout(views::View* host) override;
+  gfx::Size GetPreferredSize(const views::View* host) const override;
+  int GetPreferredHeightForWidth(const views::View* host,
+                                 int width) const override;
+  void ViewAdded(views::View* host, views::View* view) override;
+  void ViewRemoved(views::View* host, views::View* view) override;
+
+ private:
+  // Creates a default LayoutManager for the given |orientation|.
+  std::unique_ptr<views::LayoutManager> CreateDefaultLayoutManager(
+      Orientation orientation) const;
+
+  // Returns the View for the given |container|.
+  views::View* GetContainer(Container container) const;
+
+  // Returns the layout manager for the given |container|.
+  SizeRangeLayout* GetLayoutManager(Container container) const;
+
+  // The layout manager that lays out the different Container Views.
+  std::unique_ptr<views::BoxLayout> box_layout_;
+
+  // The host View that this layout manager has been installed on.
+  views::View* host_ = nullptr;
+
+  views::View* start_container_ = nullptr;
+  SizeRangeLayout* start_container_layout_manager_ = nullptr;
+
+  views::View* center_container_ = nullptr;
+  SizeRangeLayout* center_container_layout_manager_ = nullptr;
+
+  views::View* end_container_ = nullptr;
+  SizeRangeLayout* end_container_layout_manager_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreeViewLayout);
+};
+
+}  // namespace ash
+
+#endif  // ASH_COMMON_SYSTEM_TRAY_THREE_VIEW_LAYOUT_H_