| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/views/bubble/bubble_border.h" |
| |
| #include <stddef.h> |
| |
| #include <memory> |
| |
| #include "base/strings/stringprintf.h" |
| #include "ui/gfx/canvas.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/geometry/vector2d.h" |
| #include "ui/views/bubble/bubble_border_arrow_utils.h" |
| #include "ui/views/test/views_test_base.h" |
| |
| namespace views { |
| |
| using BubbleBorderTest = views::ViewsTestBase; |
| |
| TEST_F(BubbleBorderTest, GetMirroredArrow) { |
| // Horizontal mirroring. |
| EXPECT_EQ(BubbleBorder::TOP_RIGHT, |
| BubbleBorder::horizontal_mirror(BubbleBorder::TOP_LEFT)); |
| EXPECT_EQ(BubbleBorder::TOP_LEFT, |
| BubbleBorder::horizontal_mirror(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_EQ(BubbleBorder::BOTTOM_RIGHT, |
| BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_EQ(BubbleBorder::BOTTOM_LEFT, |
| BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_EQ(BubbleBorder::RIGHT_TOP, |
| BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_TOP)); |
| EXPECT_EQ(BubbleBorder::LEFT_TOP, |
| BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_EQ(BubbleBorder::RIGHT_BOTTOM, |
| BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_EQ(BubbleBorder::LEFT_BOTTOM, |
| BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_EQ(BubbleBorder::TOP_CENTER, |
| BubbleBorder::horizontal_mirror(BubbleBorder::TOP_CENTER)); |
| EXPECT_EQ(BubbleBorder::BOTTOM_CENTER, |
| BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_EQ(BubbleBorder::RIGHT_CENTER, |
| BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_CENTER)); |
| EXPECT_EQ(BubbleBorder::LEFT_CENTER, |
| BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_EQ(BubbleBorder::NONE, |
| BubbleBorder::horizontal_mirror(BubbleBorder::NONE)); |
| EXPECT_EQ(BubbleBorder::FLOAT, |
| BubbleBorder::horizontal_mirror(BubbleBorder::FLOAT)); |
| |
| // Vertical mirroring. |
| EXPECT_EQ(BubbleBorder::BOTTOM_LEFT, |
| BubbleBorder::vertical_mirror(BubbleBorder::TOP_LEFT)); |
| EXPECT_EQ(BubbleBorder::BOTTOM_RIGHT, |
| BubbleBorder::vertical_mirror(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_EQ(BubbleBorder::TOP_LEFT, |
| BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_EQ(BubbleBorder::TOP_RIGHT, |
| BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_EQ(BubbleBorder::LEFT_BOTTOM, |
| BubbleBorder::vertical_mirror(BubbleBorder::LEFT_TOP)); |
| EXPECT_EQ(BubbleBorder::RIGHT_BOTTOM, |
| BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_EQ(BubbleBorder::LEFT_TOP, |
| BubbleBorder::vertical_mirror(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_EQ(BubbleBorder::RIGHT_TOP, |
| BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_EQ(BubbleBorder::BOTTOM_CENTER, |
| BubbleBorder::vertical_mirror(BubbleBorder::TOP_CENTER)); |
| EXPECT_EQ(BubbleBorder::TOP_CENTER, |
| BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_EQ(BubbleBorder::LEFT_CENTER, |
| BubbleBorder::vertical_mirror(BubbleBorder::LEFT_CENTER)); |
| EXPECT_EQ(BubbleBorder::RIGHT_CENTER, |
| BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_EQ(BubbleBorder::NONE, |
| BubbleBorder::vertical_mirror(BubbleBorder::NONE)); |
| EXPECT_EQ(BubbleBorder::FLOAT, |
| BubbleBorder::vertical_mirror(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, HasArrow) { |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_LEFT)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_TOP)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_CENTER)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_CENTER)); |
| EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::has_arrow(BubbleBorder::NONE)); |
| EXPECT_FALSE(BubbleBorder::has_arrow(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, IsArrowOnLeft) { |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_LEFT)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_TOP)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_CENTER)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_CENTER)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::NONE)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, IsArrowOnTop) { |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_LEFT)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_TOP)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_CENTER)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_CENTER)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::NONE)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, IsArrowOnHorizontal) { |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_LEFT)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_TOP)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_FALSE( |
| BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_CENTER)); |
| EXPECT_TRUE( |
| BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_CENTER)); |
| EXPECT_FALSE( |
| BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::NONE)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, IsArrowAtCenter) { |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_LEFT)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_RIGHT)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_LEFT)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_RIGHT)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_TOP)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_TOP)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_BOTTOM)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_BOTTOM)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_CENTER)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_CENTER)); |
| |
| EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_CENTER)); |
| EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_CENTER)); |
| |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::NONE)); |
| EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::FLOAT)); |
| } |
| |
| TEST_F(BubbleBorderTest, GetSizeForContentsSizeTest) { |
| views::BubbleBorder border(BubbleBorder::NONE, BubbleBorder::NO_SHADOW); |
| |
| const gfx::Insets kInsets = border.GetInsets(); |
| |
| // kSmallSize is smaller than the minimum allowable size and does not |
| // contribute to the resulting size. |
| const gfx::Size kSmallSize = gfx::Size(1, 2); |
| // kMediumSize is larger than the minimum allowable size and contributes to |
| // the resulting size. |
| const gfx::Size kMediumSize = gfx::Size(50, 60); |
| |
| const gfx::Size kSmallHorizArrow(kSmallSize.width() + kInsets.width(), |
| kSmallSize.height() + kInsets.height()); |
| |
| const gfx::Size kSmallVertArrow(kSmallHorizArrow.width(), |
| kSmallHorizArrow.height()); |
| |
| const gfx::Size kSmallNoArrow(kSmallHorizArrow.width(), |
| kSmallHorizArrow.height()); |
| |
| const gfx::Size kMediumHorizArrow(kMediumSize.width() + kInsets.width(), |
| kMediumSize.height() + kInsets.height()); |
| |
| const gfx::Size kMediumVertArrow(kMediumHorizArrow.width(), |
| kMediumHorizArrow.height()); |
| |
| const gfx::Size kMediumNoArrow(kMediumHorizArrow.width(), |
| kMediumHorizArrow.height()); |
| |
| struct TestCase { |
| BubbleBorder::Arrow arrow; |
| gfx::Size content; |
| gfx::Size expected_without_arrow; |
| }; |
| |
| const auto cases = std::to_array<TestCase>( |
| {// Content size: kSmallSize |
| {BubbleBorder::TOP_LEFT, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::TOP_CENTER, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::TOP_RIGHT, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::BOTTOM_LEFT, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::BOTTOM_CENTER, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::BOTTOM_RIGHT, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::LEFT_TOP, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::LEFT_CENTER, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::LEFT_BOTTOM, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::RIGHT_TOP, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::RIGHT_CENTER, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::RIGHT_BOTTOM, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::NONE, kSmallSize, kSmallNoArrow}, |
| {BubbleBorder::FLOAT, kSmallSize, kSmallNoArrow}, |
| |
| // Content size: kMediumSize |
| {BubbleBorder::TOP_LEFT, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::TOP_CENTER, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::TOP_RIGHT, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::BOTTOM_LEFT, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::BOTTOM_CENTER, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::BOTTOM_RIGHT, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::LEFT_TOP, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::LEFT_CENTER, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::LEFT_BOTTOM, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::RIGHT_TOP, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::RIGHT_CENTER, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::RIGHT_BOTTOM, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::NONE, kMediumSize, kMediumNoArrow}, |
| {BubbleBorder::FLOAT, kMediumSize, kMediumNoArrow}}); |
| |
| for (size_t i = 0; i < std::size(cases); ++i) { |
| SCOPED_TRACE(base::StringPrintf("i=%d arrow=%d", static_cast<int>(i), |
| cases[i].arrow)); |
| |
| border.set_arrow(cases[i].arrow); |
| EXPECT_EQ(cases[i].expected_without_arrow, |
| border.GetSizeForContentsSize(cases[i].content)); |
| } |
| } |
| |
| TEST_F(BubbleBorderTest, GetBoundsOriginTest) { |
| for (int i = 0; i < BubbleBorder::SHADOW_COUNT; ++i) { |
| const BubbleBorder::Shadow shadow = static_cast<BubbleBorder::Shadow>(i); |
| SCOPED_TRACE(testing::Message() << "BubbleBorder::Shadow: " << shadow); |
| views::BubbleBorder border(BubbleBorder::TOP_LEFT, shadow); |
| |
| const gfx::Rect kAnchor(100, 100, 20, 30); |
| const gfx::Size kContentSize(500, 600); |
| const gfx::Insets kInsets = border.GetInsets(); |
| |
| border.set_arrow(BubbleBorder::TOP_LEFT); |
| const gfx::Size kTotalSize = border.GetSizeForContentsSize(kContentSize); |
| |
| border.set_arrow(BubbleBorder::RIGHT_BOTTOM); |
| EXPECT_EQ(kTotalSize, border.GetSizeForContentsSize(kContentSize)); |
| |
| border.set_arrow(BubbleBorder::NONE); |
| EXPECT_EQ(kTotalSize, border.GetSizeForContentsSize(kContentSize)); |
| |
| const int kStrokeWidth = |
| shadow == BubbleBorder::NO_SHADOW ? 0 : BubbleBorder::kStroke; |
| |
| const int kBorderedContentHeight = |
| kContentSize.height() + (2 * kStrokeWidth); |
| |
| const int kStrokeTopInset = kStrokeWidth - kInsets.top(); |
| const int kStrokeBottomInset = kStrokeWidth - kInsets.bottom(); |
| const int kStrokeLeftInset = kStrokeWidth - kInsets.left(); |
| const int kStrokeRightInset = kStrokeWidth - kInsets.right(); |
| |
| const int kTopHorizArrowY = kAnchor.bottom() + kStrokeTopInset; |
| const int kBottomHorizArrowY = |
| kAnchor.y() - kTotalSize.height() - kStrokeBottomInset; |
| const int kLeftVertArrowX = |
| kAnchor.x() + kAnchor.width() + kStrokeLeftInset; |
| const int kRightVertArrowX = |
| kAnchor.x() - kTotalSize.width() - kStrokeRightInset; |
| |
| struct TestCase { |
| BubbleBorder::Arrow arrow; |
| int expected_x; |
| int expected_y; |
| }; |
| |
| const auto cases = std::to_array<TestCase>({ |
| // Horizontal arrow tests. |
| {BubbleBorder::TOP_LEFT, kAnchor.x() + kStrokeLeftInset, |
| kTopHorizArrowY}, |
| {BubbleBorder::TOP_CENTER, |
| kAnchor.CenterPoint().x() - (kTotalSize.width() / 2), kTopHorizArrowY}, |
| {BubbleBorder::BOTTOM_RIGHT, |
| kAnchor.x() + kAnchor.width() - kTotalSize.width() - kStrokeRightInset, |
| kBottomHorizArrowY}, |
| |
| // Vertical arrow tests. |
| {BubbleBorder::LEFT_TOP, kLeftVertArrowX, |
| kAnchor.y() + kStrokeTopInset}, |
| {BubbleBorder::LEFT_CENTER, kLeftVertArrowX, |
| kAnchor.CenterPoint().y() - (kBorderedContentHeight / 2) + |
| kStrokeTopInset}, |
| {BubbleBorder::RIGHT_BOTTOM, kRightVertArrowX, |
| kAnchor.y() + kAnchor.height() - kTotalSize.height() - |
| kStrokeBottomInset}, |
| |
| // No arrow tests. |
| {BubbleBorder::NONE, |
| kAnchor.x() + (kAnchor.width() - kTotalSize.width()) / 2, |
| kAnchor.y() + kAnchor.height()}, |
| {BubbleBorder::FLOAT, |
| kAnchor.x() + (kAnchor.width() - kTotalSize.width()) / 2, |
| kAnchor.y() + (kAnchor.height() - kTotalSize.height()) / 2}, |
| }); |
| |
| for (size_t j = 0; j < std::size(cases); ++j) { |
| SCOPED_TRACE(base::StringPrintf("shadow=%d j=%d arrow=%d", |
| static_cast<int>(shadow), |
| static_cast<int>(j), cases[j].arrow)); |
| const BubbleBorder::Arrow arrow = cases[j].arrow; |
| border.set_arrow(arrow); |
| gfx::Point origin = border.GetBounds(kAnchor, kContentSize).origin(); |
| EXPECT_EQ(cases[j].expected_x, origin.x()); |
| EXPECT_EQ(cases[j].expected_y, origin.y()); |
| } |
| } |
| } |
| |
| TEST_F(BubbleBorderTest, BubblePositionedCorrectlyWithVisibleArrow) { |
| views::BubbleBorder border(BubbleBorder::TOP_LEFT, |
| BubbleBorder::STANDARD_SHADOW); |
| const gfx::Insets kInsets = border.GetInsets(); |
| border.set_visible_arrow(true); |
| |
| constexpr gfx::Size kContentSize(200, 150); |
| |
| // Anchor position. |
| constexpr gfx::Point kAnchorOrigin(100, 100); |
| |
| // Anchor smaller than contents. |
| constexpr gfx::Rect kAnchor1(kAnchorOrigin, gfx::Size(40, 50)); |
| |
| // Anchor larger than contents. |
| constexpr gfx::Rect kAnchor2(kAnchorOrigin, gfx::Size(400, 300)); |
| |
| // Anchor extremely small. |
| constexpr gfx::Rect kAnchor3(kAnchorOrigin, gfx::Size(10, 12)); |
| |
| // TODO(dfried): in all of these tests, the border is factored into the height |
| // of the bubble an extra time, because of the fact that the arrow doesn't |
| // properly overlap the border in the calculation (though it does visually). |
| // Please fix at some point. |
| |
| // TOP_LEFT: |
| |
| border.set_arrow(BubbleBorder::TOP_LEFT); |
| gfx::Rect bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor1.x() - kInsets.left(), bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor2.x() - kInsets.left() + BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_GT(kAnchor3.x() - kInsets.left() + BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| |
| // TOP_CENTER: |
| |
| border.set_arrow(BubbleBorder::TOP_CENTER); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor1.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor2.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor3.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| // TOP_RIGHT: |
| |
| border.set_arrow(BubbleBorder::TOP_RIGHT); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ(kAnchor1.right() + kInsets.right(), bounds.right()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_EQ( |
| kAnchor2.right() + kInsets.right() - BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.bottom() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.bottom() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| EXPECT_LT( |
| kAnchor3.right() + kInsets.right() - BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| |
| // BOTTOM_LEFT: |
| |
| border.set_arrow(BubbleBorder::BOTTOM_LEFT); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor1.x() - kInsets.left(), bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor2.x() - kInsets.left() + BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_GT(kAnchor3.x() - kInsets.left() + BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| |
| // BOTTOM_CENTER: |
| |
| border.set_arrow(BubbleBorder::BOTTOM_CENTER); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor1.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor2.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor3.bottom_center().x() - bounds.width() / 2, bounds.x()); |
| |
| // BOTTOM_RIGHT: |
| |
| border.set_arrow(BubbleBorder::BOTTOM_RIGHT); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor1.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ(kAnchor1.right() + kInsets.right(), bounds.right()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor2.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_EQ( |
| kAnchor2.right() + kInsets.right() - BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.height() + kInsets.top() + |
| BubbleBorder::kVisibleArrowLength + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.height()); |
| EXPECT_EQ(kContentSize.width() + kInsets.width(), bounds.width()); |
| EXPECT_EQ(kAnchor3.y() - BubbleBorder::kVisibleArrowGap, bounds.bottom()); |
| EXPECT_LT( |
| kAnchor3.right() + kInsets.right() - BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| |
| // LEFT_TOP: |
| |
| border.set_arrow(BubbleBorder::LEFT_TOP); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_EQ(kAnchor1.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_EQ(kAnchor2.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_GT(kAnchor3.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| // LEFT_CENTER: |
| |
| // Because the shadow counts as part of the bounds, the shadow offset (which |
| // is applied vertically) will affect the vertical positioning of a bubble |
| // which is placed next to the anchor by a similar amount. |
| border.set_arrow(BubbleBorder::LEFT_CENTER); |
| const auto insets = border.GetInsets(); |
| const int shadow_offset = (insets.bottom() - insets.top()) / 2; |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_NEAR(kAnchor1.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_NEAR(kAnchor2.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_NEAR(kAnchor3.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| // LEFT_BOTTOM: |
| |
| border.set_arrow(BubbleBorder::LEFT_BOTTOM); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_EQ( |
| kAnchor1.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_EQ( |
| kAnchor2.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.right() + BubbleBorder::kVisibleArrowGap + |
| BubbleBorder::kBorderThicknessDip, |
| bounds.x()); |
| EXPECT_LT( |
| kAnchor3.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| |
| // RIGHT_TOP: |
| |
| border.set_arrow(BubbleBorder::RIGHT_TOP); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_EQ(kAnchor1.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_EQ(kAnchor2.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_GT(kAnchor3.y() - kInsets.top() + BubbleBorder::kBorderThicknessDip, |
| bounds.y()); |
| |
| // // RIGHT_CENTER: |
| |
| // Because the shadow counts as part of the bounds, the shadow offset (which |
| // is applied vertically) will affect the vertical positioning of a bubble |
| // which is placed next to the anchor by a similar amount. |
| border.set_arrow(BubbleBorder::RIGHT_CENTER); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_NEAR(kAnchor1.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_NEAR(kAnchor2.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_NEAR(kAnchor3.right_center().y() - bounds.height() / 2, bounds.y(), |
| shadow_offset); |
| |
| // RIGHT_BOTTOM: |
| |
| border.set_arrow(BubbleBorder::RIGHT_BOTTOM); |
| bounds = border.GetBounds(kAnchor1, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor1.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_EQ( |
| kAnchor1.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| |
| bounds = border.GetBounds(kAnchor2, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor2.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_EQ( |
| kAnchor2.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| |
| // Too small of an anchor view will shift the bubble to make sure the arrow |
| // is not too close to the edge of the bubble. |
| bounds = border.GetBounds(kAnchor3, kContentSize); |
| EXPECT_EQ(kContentSize.width() + kInsets.right() + |
| BubbleBorder::kVisibleArrowLength, |
| bounds.width()); |
| EXPECT_EQ(kContentSize.height() + kInsets.height(), bounds.height()); |
| EXPECT_EQ(kAnchor3.x() - BubbleBorder::kVisibleArrowGap - |
| BubbleBorder::kBorderThicknessDip, |
| bounds.right()); |
| EXPECT_LT( |
| kAnchor3.bottom() + kInsets.bottom() - BubbleBorder::kBorderThicknessDip, |
| bounds.bottom()); |
| } |
| |
| TEST_F(BubbleBorderTest, AddArrowToBubbleCornerAndPointTowardsAnchor) { |
| // Create bubble bounds located at pixel x=400,y=600 with a dimension of |
| // 300x200 pixels. |
| const gfx::Rect bubble_bounds(400, 600, 300, 200); |
| // The element will have a fixed size as well. |
| const gfx::Size element_size(350, 100); |
| |
| int most_left_x_position = |
| bubble_bounds.x() + BubbleBorder::kVisibleArrowBuffer; |
| int most_right_x_position = bubble_bounds.right() - |
| BubbleBorder::kVisibleArrowBuffer - |
| BubbleBorder::kVisibleArrowRadius * 2; |
| // The y position of an arrow at the upper edge of the bubble. |
| int upper_arrow_y_position = bubble_bounds.y(); |
| // The y position of an arrow at the lower edge of the bubble. |
| int lower_arrow_y_position = |
| bubble_bounds.bottom() - BubbleBorder::kVisibleArrowLength; |
| |
| struct TestCase { |
| gfx::Point element_origin; |
| BubbleBorder::Arrow supplied_arrow; |
| gfx::Point expected_arrow_position; |
| bool expected_arrow_visibility_and_return_value; |
| gfx::Rect expected_bubble_bounds; |
| int popup_min_y = 0; |
| } test_cases[]{ |
| // First are using the following scenario: |
| // |
| // y=200 ----------------- |
| // | x | element |
| // ----------------- |
| // |
| // y=600 ----------- |
| // | | |
| // | | bubble |
| // | | |
| // y=800 ----------- |
| // |
| // | x=380 |
| // | x=400 |
| {{380, 200}, |
| BubbleBorder::Arrow::TOP_LEFT, |
| // The arrow sits close to the right edge of the bubble. |
| // The bubble is located above the upper edge. Note that |
| // insets need to be taken into account. |
| {most_left_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{380, 200}, |
| BubbleBorder::Arrow::TOP_CENTER, |
| // The arrow points to the horizontal center of the element. |
| // Note that the spatial extension of the arrow has to be |
| // taken into account. The bubble is located above the upper |
| // edge. Note that insets need to be taken into account. |
| {380 + element_size.width() / 2 - BubbleBorder::kVisibleArrowRadius, |
| upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{380, 200}, |
| BubbleBorder::Arrow::TOP_RIGHT, |
| // The arrow points to the horizontal center of the element. |
| // Note that the spatial extension of the arrow has to be |
| // taken into account. The bubble is located above the upper |
| // edge. Note that insets need to be taken into account. |
| {most_right_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| // The following tests are using a bubble that is highly displaced from |
| // the |
| // element: |
| // |
| // y=200 ----------------- |
| // | x | element |
| // ----------------- |
| // |
| // y=600 ----------- |
| // | | |
| // | | bubble |
| // | | |
| // y=800 ----------- |
| // |
| // | x=750 |
| // | x=400 |
| // The arrow should always be located on the most right position. |
| {{750, 200}, |
| BubbleBorder::Arrow::TOP_LEFT, |
| {most_right_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{750, 200}, |
| BubbleBorder::Arrow::TOP_CENTER, |
| {most_right_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{750, 200}, |
| BubbleBorder::Arrow::TOP_RIGHT, |
| {most_right_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| // And the reverse scenario: |
| // |
| // y=200 ----------------- |
| // | x | element |
| // ----------------- |
| // |
| // y=600 ----------- |
| // | | |
| // | | bubble |
| // | | |
| // y=800 ----------- |
| // |
| // | x=0 |
| // | x=400 |
| // The arrow should always be located on the most right position. |
| {{0, 200}, |
| BubbleBorder::Arrow::TOP_LEFT, |
| {most_left_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{0, 200}, |
| BubbleBorder::Arrow::TOP_CENTER, |
| {most_left_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{0, 200}, |
| BubbleBorder::Arrow::TOP_RIGHT, |
| {most_left_x_position, upper_arrow_y_position}, |
| true, |
| bubble_bounds + gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| // The following tests use a BOTTOM arrow. This should only replace the |
| // upper_arrow_y_position with the lower_arrow_y_position in all tests. |
| {{380, 200}, |
| BubbleBorder::Arrow::BOTTOM_LEFT, |
| {most_left_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{380, 200}, |
| BubbleBorder::Arrow::BOTTOM_CENTER, |
| {380 + element_size.width() / 2 - BubbleBorder::kVisibleArrowRadius, |
| lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{380, 200}, |
| BubbleBorder::Arrow::BOTTOM_RIGHT, |
| {most_right_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{750, 200}, |
| BubbleBorder::Arrow::BOTTOM_LEFT, |
| {most_right_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{750, 200}, |
| BubbleBorder::Arrow::BOTTOM_CENTER, |
| {most_right_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{750, 200}, |
| BubbleBorder::Arrow::BOTTOM_RIGHT, |
| {most_right_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{0, 200}, |
| BubbleBorder::Arrow::BOTTOM_LEFT, |
| {most_left_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{0, 200}, |
| BubbleBorder::Arrow::BOTTOM_CENTER, |
| {most_left_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| {{0, 200}, |
| BubbleBorder::Arrow::BOTTOM_RIGHT, |
| {most_left_x_position, lower_arrow_y_position}, |
| true, |
| bubble_bounds - gfx::Vector2d(0, BubbleBorder::kVisibleArrowLength)}, |
| // Now, the horizontal arrow scenario is tested |
| // y=600 ----------- |
| // y=650 ----------------- | | |
| // | x | | | |
| // y=750 ----------------- | | |
| // y=800 ----------- |
| // | x=0 |
| // | x=400 |
| // The arrow is always located on the right side to point towards the |
| // vertical center of the element. |
| {{0, 650}, |
| BubbleBorder::Arrow::LEFT_TOP, |
| {bubble_bounds.x(), |
| 650 + element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| bubble_bounds + gfx::Vector2d(BubbleBorder::kVisibleArrowLength, 0)}, |
| {{0, 650}, |
| BubbleBorder::Arrow::LEFT_CENTER, |
| {bubble_bounds.x(), |
| 650 + element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| bubble_bounds + gfx::Vector2d(BubbleBorder::kVisibleArrowLength, 0)}, |
| {{0, 650}, |
| BubbleBorder::Arrow::LEFT_BOTTOM, |
| {bubble_bounds.x(), |
| 650 + element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| bubble_bounds + gfx::Vector2d(BubbleBorder::kVisibleArrowLength, 0)}, |
| // With the element moved to the top of the screen, the arrow should |
| // always be placed at the most top position on the bubble, the bubble |
| // position is adjusted as well |
| {{0, 0}, |
| BubbleBorder::Arrow::LEFT_TOP, |
| {bubble_bounds.x(), |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| {bubble_bounds.x() + BubbleBorder::kVisibleArrowLength, |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius - |
| BubbleBorder::kVisibleArrowBuffer, |
| bubble_bounds.width(), bubble_bounds.height()}}, |
| {{0, 0}, |
| BubbleBorder::Arrow::LEFT_CENTER, |
| {bubble_bounds.x(), |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| {bubble_bounds.x() + BubbleBorder::kVisibleArrowLength, |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius - |
| BubbleBorder::kVisibleArrowBuffer, |
| bubble_bounds.width(), bubble_bounds.height()}}, |
| {{0, 0}, |
| BubbleBorder::Arrow::LEFT_BOTTOM, |
| {bubble_bounds.x(), |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius}, |
| true, |
| {bubble_bounds.x() + BubbleBorder::kVisibleArrowLength, |
| element_size.height() / 2 - BubbleBorder::kVisibleArrowRadius - |
| BubbleBorder::kVisibleArrowBuffer, |
| bubble_bounds.width(), bubble_bounds.height()}}, |
| {{0, 0}, |
| BubbleBorder::Arrow::LEFT_TOP, |
| {bubble_bounds.x(), |
| element_size.height() / 2 - 10 + BubbleBorder::kVisibleArrowBuffer}, |
| true, |
| {bubble_bounds.x() + BubbleBorder::kVisibleArrowLength, |
| element_size.height() / 2 - 10, bubble_bounds.width(), |
| bubble_bounds.height()}, |
| element_size.height() / 2 - 10}, |
| }; |
| |
| for (auto test_case : test_cases) { |
| gfx::Rect bubble_bounds_copy = bubble_bounds; |
| views::BubbleBorder border(BubbleBorder::Arrow::NONE, |
| BubbleBorder::STANDARD_SHADOW); |
| border.set_arrow(test_case.supplied_arrow); |
| EXPECT_EQ(border.AddArrowToBubbleCornerAndPointTowardsAnchor( |
| {test_case.element_origin, element_size}, bubble_bounds_copy, |
| test_case.popup_min_y), |
| test_case.expected_arrow_visibility_and_return_value); |
| EXPECT_EQ(border.visible_arrow(), |
| test_case.expected_arrow_visibility_and_return_value); |
| EXPECT_EQ(border.GetVisibibleArrowRectForTesting().origin(), |
| test_case.expected_arrow_position); |
| EXPECT_EQ(GetVisibleArrowSize(test_case.supplied_arrow), |
| border.GetVisibibleArrowRectForTesting().size()); |
| EXPECT_EQ(test_case.expected_bubble_bounds, bubble_bounds_copy); |
| } |
| } |
| |
| TEST_F(BubbleBorderTest, |
| AddArrowToBubbleCornerAndPointTowardsAnchorWithInsufficientSpace) { |
| // This bubble bound has uinsufficient width to place an arrow on the top or |
| // the bottom. |
| const gfx::Rect insufficient_width_bubble_bounds(0, 0, 10, 200); |
| |
| // This bound has insufficient height to place an arrow on the left or right. |
| const gfx::Rect insufficient_height_bubble_bounds(0, 0, 100, 10); |
| |
| // Create bounds for the element, the specifics do no matter. |
| const gfx::Rect element_bounds(0, 0, 350, 100); |
| |
| struct TestCase { |
| gfx::Rect bubble_bounds; |
| BubbleBorder::Arrow supplied_arrow; |
| bool expected_arrow_visibility_and_return_value; |
| } test_cases[]{ |
| // Bubble is placeable on top because there is sufficient width. |
| {insufficient_height_bubble_bounds, BubbleBorder::Arrow::TOP_CENTER, |
| true}, |
| // Bubble is not placeable on top because the width is insufficient. |
| {insufficient_width_bubble_bounds, BubbleBorder::Arrow::TOP_CENTER, |
| false}, |
| // Bubble is not placeable on the side because the height is insufficient. |
| {insufficient_height_bubble_bounds, BubbleBorder::Arrow::LEFT_CENTER, |
| false}, |
| // Bubble is placeable on the side because the height is sufficient. |
| {insufficient_width_bubble_bounds, BubbleBorder::Arrow::LEFT_CENTER, |
| true}, |
| }; |
| |
| for (auto test_case : test_cases) { |
| views::BubbleBorder border(BubbleBorder::Arrow::NONE, |
| BubbleBorder::STANDARD_SHADOW); |
| border.set_arrow(test_case.supplied_arrow); |
| EXPECT_EQ(border.AddArrowToBubbleCornerAndPointTowardsAnchor( |
| element_bounds, test_case.bubble_bounds, 0), |
| test_case.expected_arrow_visibility_and_return_value); |
| } |
| } |
| |
| TEST_F(BubbleBorderTest, IsVerticalArrow) { |
| struct TestCase { |
| BubbleBorder::Arrow arrow; |
| bool is_vertical_expected; |
| }; |
| |
| TestCase test_cases[] = { |
| // BOTTOM and TOP arrows are vertical. |
| {BubbleBorder::Arrow::BOTTOM_CENTER, true}, |
| {BubbleBorder::Arrow::BOTTOM_LEFT, true}, |
| {BubbleBorder::Arrow::BOTTOM_RIGHT, true}, |
| {BubbleBorder::Arrow::TOP_CENTER, true}, |
| {BubbleBorder::Arrow::TOP_LEFT, true}, |
| {BubbleBorder::Arrow::TOP_RIGHT, true}, |
| // The rest is horizontal. |
| {BubbleBorder::Arrow::LEFT_BOTTOM, false}, |
| {BubbleBorder::Arrow::LEFT_CENTER, false}, |
| {BubbleBorder::Arrow::LEFT_TOP, false}, |
| {BubbleBorder::Arrow::RIGHT_BOTTOM, false}, |
| {BubbleBorder::Arrow::RIGHT_CENTER, false}, |
| {BubbleBorder::Arrow::RIGHT_TOP, false}, |
| }; |
| |
| for (const auto& test_case : test_cases) { |
| EXPECT_EQ(IsVerticalArrow(test_case.arrow), test_case.is_vertical_expected); |
| } |
| } |
| |
| // Test that the correct arrow size is returned for a given arrow position. |
| TEST_F(BubbleBorderTest, GetVisibleArrowSize) { |
| const gfx::Size vertical_size(2 * BubbleBorder::kVisibleArrowRadius, |
| BubbleBorder::kVisibleArrowLength); |
| const gfx::Size horizontal_size(BubbleBorder::kVisibleArrowLength, |
| 2 * BubbleBorder::kVisibleArrowRadius); |
| |
| struct TestCase { |
| BubbleBorder::Arrow arrow; |
| gfx::Size expected_size; |
| }; |
| |
| TestCase test_cases[] = { |
| // BOTTOM and TOP arrows have a vertical size. |
| {BubbleBorder::Arrow::BOTTOM_CENTER, vertical_size}, |
| {BubbleBorder::Arrow::BOTTOM_LEFT, vertical_size}, |
| {BubbleBorder::Arrow::BOTTOM_RIGHT, vertical_size}, |
| {BubbleBorder::Arrow::TOP_CENTER, vertical_size}, |
| {BubbleBorder::Arrow::TOP_LEFT, vertical_size}, |
| {BubbleBorder::Arrow::TOP_RIGHT, vertical_size}, |
| // The rest has a horizontal size. |
| {BubbleBorder::Arrow::LEFT_BOTTOM, horizontal_size}, |
| {BubbleBorder::Arrow::LEFT_CENTER, horizontal_size}, |
| {BubbleBorder::Arrow::LEFT_TOP, horizontal_size}, |
| {BubbleBorder::Arrow::RIGHT_BOTTOM, horizontal_size}, |
| {BubbleBorder::Arrow::RIGHT_CENTER, horizontal_size}, |
| {BubbleBorder::Arrow::RIGHT_TOP, horizontal_size}, |
| }; |
| |
| for (const auto& test_case : test_cases) { |
| EXPECT_EQ(GetVisibleArrowSize(test_case.arrow), test_case.expected_size); |
| } |
| } |
| |
| // Test that the contents bounds are moved correctly to place the visible arrow |
| // at the appropriate position. |
| TEST_F(BubbleBorderTest, MoveContentsBoundsToPlaceVisibleArrow) { |
| const int arrow_length = |
| BubbleBorder::kVisibleArrowLength + BubbleBorder::kVisibleArrowGap; |
| |
| struct TestCase { |
| BubbleBorder::Arrow arrow; |
| gfx::Vector2d expected_contents_bounds_move; |
| gfx::Point initial_bubble_origin = gfx::Point(0, 0); |
| }; |
| |
| TestCase test_cases[] = { |
| // BOTTOM cases: The contents is moved to the top of the screen. |
| {BubbleBorder::Arrow::BOTTOM_LEFT, gfx::Vector2d(0, -arrow_length)}, |
| {BubbleBorder::Arrow::BOTTOM_CENTER, gfx::Vector2d(0, -arrow_length)}, |
| {BubbleBorder::Arrow::BOTTOM_RIGHT, gfx::Vector2d(0, -arrow_length)}, |
| // TOP cases: The contents is moved to the bottom of the screen. |
| {BubbleBorder::Arrow::TOP_LEFT, gfx::Vector2d(0, arrow_length)}, |
| {BubbleBorder::Arrow::TOP_CENTER, gfx::Vector2d(0, arrow_length)}, |
| {BubbleBorder::Arrow::TOP_RIGHT, gfx::Vector2d(0, arrow_length)}, |
| // LEFT cases: The contents is moved to the right. |
| {BubbleBorder::Arrow::LEFT_BOTTOM, gfx::Vector2d(arrow_length, 0)}, |
| {BubbleBorder::Arrow::LEFT_CENTER, gfx::Vector2d(arrow_length, 0)}, |
| {BubbleBorder::Arrow::LEFT_TOP, gfx::Vector2d(arrow_length, 0)}, |
| // RIGHT cases: The contents is moved to the left. |
| {BubbleBorder::Arrow::RIGHT_BOTTOM, gfx::Vector2d(-arrow_length, 0)}, |
| {BubbleBorder::Arrow::RIGHT_CENTER, gfx::Vector2d(-arrow_length, 0)}, |
| {BubbleBorder::Arrow::RIGHT_TOP, gfx::Vector2d(-arrow_length, 0)}, |
| }; |
| |
| for (const auto& test_case : test_cases) { |
| // Create a bubble border with a visible arrow. |
| views::BubbleBorder border(test_case.arrow, BubbleBorder::STANDARD_SHADOW); |
| border.set_visible_arrow(true); |
| |
| // Create, move and verify the contents bounds. |
| EXPECT_EQ(border.GetContentsBoundsOffsetToPlaceVisibleArrow( |
| test_case.arrow, /*include_gap=*/true), |
| test_case.expected_contents_bounds_move); |
| } |
| } |
| |
| } // namespace views |
