blob: 5bb6ed6e554c7bfa3b5b29d3e1bf835b805a313b [file] [log] [blame]
// 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.
#include <memory>
#include "ash/ash_export.h"
#include "base/macros.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/size.h"
#include "ui/views/view.h"
namespace views {
class Border;
class BoxLayout;
class LayoutManager;
} // namespace views
namespace ash {
class SizeRangeLayout;
// A View which 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.
// Child views should not be added to |this| directly via View::AddChildView()
// or View::AddChildViewAt() and will fail a DCHECK() if attempted.
// Views added to the containers are laid out 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 ASH_EXPORT TriView : public views::View {
enum class Orientation {
// The different containers that child Views can be added to.
enum class Container { START = 0, CENTER = 1, END = 2 };
// Constructs a layout with horizontal orientation and 0 padding between
// containers.
// Creates |this| with a Horizontal orientation and the specified padding
// between containers.
// TODO(bruthig): The |padding_between_containers| 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 TriView(int padding_between_containers);
// Creates |this| with the specified orientation and 0 padding between
// containers.
explicit TriView(Orientation orientation);
// Creates this with the specified |orientation| and
// |padding_between_containers|.
TriView(Orientation orientation, int padding_between_containers);
~TriView() override;
// 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 the children from the specified |container|. If
// |delete_children| is true, the views are deleted, unless marked as not
// parent owned.
void RemoveAllChildren(Container container, bool delete_children);
// During layout the |insets| are applied to the host views entire space
// before allocating the remaining space to the container views.
void SetInsets(const gfx::Insets& insets);
// Sets the border for the given |container|.
void SetContainerBorder(Container container,
std::unique_ptr<views::Border> border);
// Sets whether the |container| is visible. During a layout the space will be
// allocated to the visible containers only. i.e. non-visible containers will
// not be allocated any space.
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.
// Note that non-zero flex values will take precedence over size constraints.
// i.e. even if |container| has a max size set the space allocated during
// layout may be larger if |flex| > 0 and similar for min size constraints.
void SetFlexForContainer(Container container, int flex);
// Sets the |layout_manager| used by the given |container|.
void SetContainerLayout(Container container,
std::unique_ptr<views::LayoutManager> layout_manager);
// View:
void ViewHierarchyChanged(
const views::View::ViewHierarchyChangedDetails& details) override;
friend class TriViewTest;
// Returns the View for the given |container|.
views::View* GetContainer(Container container);
// Returns the layout manager for the given |container|.
SizeRangeLayout* GetLayoutManager(Container container);
// Type spcific layout manager installed on |this|. Responsible for laying out
// the container Views.
views::BoxLayout* box_layout_;
SizeRangeLayout* start_container_layout_manager_;
SizeRangeLayout* center_container_layout_manager_;
SizeRangeLayout* end_container_layout_manager_;
// In order to detect direct manipulation of child views the
// ViewHierarchyChanged() event override fails on a DCHECK. However, we need
// to manipulate the child views during construction/destruction so this flag
// is used to disable the DCHECK during construction/destruction.
bool enable_hierarchy_changed_dcheck_ = false;
} // namespace ash