1388 lines
46 KiB
C++
1388 lines
46 KiB
C++
// Copyright (c) 2016 The Chromium Embedded Framework 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 "include/views/cef_box_layout.h"
|
|
#include "include/views/cef_fill_layout.h"
|
|
#include "include/views/cef_layout.h"
|
|
#include "include/views/cef_panel.h"
|
|
#include "include/views/cef_panel_delegate.h"
|
|
#include "include/views/cef_window.h"
|
|
#include "tests/ceftests/thread_helper.h"
|
|
#include "tests/gtest/include/gtest/gtest.h"
|
|
|
|
#define PANEL_TEST(name) UI_THREAD_TEST(ViewsPanelTest, name)
|
|
|
|
namespace {
|
|
|
|
class EmptyPanelDelegate : public CefPanelDelegate {
|
|
public:
|
|
EmptyPanelDelegate() {}
|
|
|
|
private:
|
|
IMPLEMENT_REFCOUNTING(EmptyPanelDelegate);
|
|
DISALLOW_COPY_AND_ASSIGN(EmptyPanelDelegate);
|
|
};
|
|
|
|
void CreatePanel(CefRefPtr<CefPanelDelegate> delegate) {
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);
|
|
EXPECT_TRUE(panel.get());
|
|
|
|
// Verify the derived View relationship.
|
|
EXPECT_TRUE(panel->AsPanel().get());
|
|
EXPECT_FALSE(panel->AsWindow().get());
|
|
EXPECT_TRUE(panel->IsSame(panel));
|
|
|
|
// Verify default View state.
|
|
EXPECT_STREQ("Panel", panel->GetTypeString().ToString().c_str());
|
|
EXPECT_TRUE(panel->IsValid());
|
|
EXPECT_FALSE(panel->IsAttached());
|
|
if (delegate)
|
|
EXPECT_EQ(delegate.get(), panel->GetDelegate().get());
|
|
else
|
|
EXPECT_FALSE(panel->GetDelegate().get());
|
|
EXPECT_EQ(0, panel->GetID());
|
|
EXPECT_FALSE(panel->GetParentView().get());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBoundsInScreen());
|
|
EXPECT_EQ(CefSize(0, 0), panel->GetPreferredSize());
|
|
EXPECT_EQ(CefSize(0, 0), panel->GetMinimumSize());
|
|
EXPECT_EQ(CefSize(0, 0), panel->GetMaximumSize());
|
|
EXPECT_EQ(CefSize(0, 0), panel->GetMaximumSize());
|
|
EXPECT_EQ(0, panel->GetHeightForWidth(100));
|
|
EXPECT_TRUE(panel->IsVisible());
|
|
EXPECT_FALSE(panel->IsDrawn());
|
|
EXPECT_TRUE(panel->IsEnabled());
|
|
EXPECT_FALSE(panel->IsFocusable());
|
|
EXPECT_FALSE(panel->IsAccessibilityFocusable());
|
|
EXPECT_EQ(CefColorSetARGB(255, 255, 255, 255), panel->GetBackgroundColor());
|
|
|
|
// Verify default Panel state.
|
|
EXPECT_TRUE(panel->GetLayout().get());
|
|
EXPECT_EQ(0U, panel->GetChildViewCount());
|
|
|
|
// Destroy the Panel.
|
|
panel = nullptr;
|
|
|
|
if (delegate) {
|
|
// Verify that nothing is keeping a reference to the delegate.
|
|
EXPECT_TRUE(delegate->HasOneRef());
|
|
}
|
|
}
|
|
|
|
void CreatePanelNoDelegateImpl() {
|
|
CreatePanel(nullptr);
|
|
}
|
|
|
|
void CreatePanelWithDelegateImpl() {
|
|
CreatePanel(new EmptyPanelDelegate);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Test creation.
|
|
PANEL_TEST(CreatePanelNoDelegate)
|
|
PANEL_TEST(CreatePanelWithDelegate)
|
|
|
|
namespace {
|
|
|
|
class ParentPanelDelegate : public CefPanelDelegate {
|
|
public:
|
|
ParentPanelDelegate() {}
|
|
|
|
void OnParentViewChanged(CefRefPtr<CefView> view,
|
|
bool added,
|
|
CefRefPtr<CefView> parent) override {
|
|
EXPECT_FALSE(true); // Not reached.
|
|
}
|
|
|
|
void OnChildViewChanged(CefRefPtr<CefView> view,
|
|
bool added,
|
|
CefRefPtr<CefView> child) override {
|
|
Changed changed;
|
|
changed.view_ = view;
|
|
changed.added_ = added;
|
|
changed.child_ = child;
|
|
changed_.push_back(changed);
|
|
}
|
|
|
|
void Verify(int callback_index,
|
|
CefRefPtr<CefView> view,
|
|
bool added,
|
|
CefRefPtr<CefView> child) {
|
|
EXPECT_LT(callback_index, static_cast<int>(changed_.size()));
|
|
EXPECT_TRUE(view->IsSame(changed_[callback_index].view_))
|
|
<< "callback_index " << callback_index;
|
|
EXPECT_EQ(added, changed_[callback_index].added_)
|
|
<< "callback_index " << callback_index;
|
|
EXPECT_TRUE(child->IsSame(changed_[callback_index].child_))
|
|
<< "callback_index " << callback_index;
|
|
}
|
|
|
|
void Reset() { changed_.clear(); }
|
|
|
|
bool IsReset() const { return changed_.empty(); }
|
|
|
|
struct Changed {
|
|
CefRefPtr<CefView> view_;
|
|
bool added_ = false;
|
|
CefRefPtr<CefView> child_;
|
|
};
|
|
std::vector<Changed> changed_;
|
|
|
|
private:
|
|
IMPLEMENT_REFCOUNTING(ParentPanelDelegate);
|
|
DISALLOW_COPY_AND_ASSIGN(ParentPanelDelegate);
|
|
};
|
|
|
|
class ChildPanelDelegate : public CefPanelDelegate {
|
|
public:
|
|
ChildPanelDelegate() {}
|
|
|
|
void OnParentViewChanged(CefRefPtr<CefView> view,
|
|
bool added,
|
|
CefRefPtr<CefView> parent) override {
|
|
EXPECT_FALSE(on_parent_view_changed_);
|
|
on_parent_view_changed_ = true;
|
|
view_ = view;
|
|
added_ = added;
|
|
parent_ = parent;
|
|
}
|
|
|
|
void OnChildViewChanged(CefRefPtr<CefView> view,
|
|
bool added,
|
|
CefRefPtr<CefView> child) override {
|
|
EXPECT_FALSE(true); // Not reached.
|
|
}
|
|
|
|
void Verify(CefRefPtr<CefView> view, bool added, CefRefPtr<CefView> parent) {
|
|
EXPECT_TRUE(on_parent_view_changed_);
|
|
EXPECT_TRUE(view->IsSame(view_));
|
|
EXPECT_EQ(added, added_);
|
|
EXPECT_TRUE(parent->IsSame(parent_));
|
|
}
|
|
|
|
void Reset() {
|
|
on_parent_view_changed_ = false;
|
|
view_ = nullptr;
|
|
added_ = false;
|
|
parent_ = nullptr;
|
|
}
|
|
|
|
bool IsReset() const { return !on_parent_view_changed_; }
|
|
|
|
bool on_parent_view_changed_ = false;
|
|
CefRefPtr<CefView> view_;
|
|
bool added_ = false;
|
|
CefRefPtr<CefView> parent_;
|
|
|
|
private:
|
|
IMPLEMENT_REFCOUNTING(ChildPanelDelegate);
|
|
DISALLOW_COPY_AND_ASSIGN(ChildPanelDelegate);
|
|
};
|
|
|
|
void ChildVerifyRemovedState(CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel) {
|
|
EXPECT_FALSE(parent_panel->IsSame(child_panel));
|
|
EXPECT_FALSE(child_panel->IsSame(parent_panel));
|
|
EXPECT_FALSE(parent_panel->IsAttached());
|
|
EXPECT_FALSE(child_panel->IsAttached());
|
|
EXPECT_FALSE(parent_panel->GetParentView().get());
|
|
EXPECT_FALSE(child_panel->GetParentView().get());
|
|
}
|
|
|
|
void ChildVerifyAddedState(CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel,
|
|
int expected_child_index) {
|
|
EXPECT_FALSE(parent_panel->IsSame(child_panel));
|
|
EXPECT_FALSE(child_panel->IsSame(parent_panel));
|
|
EXPECT_FALSE(parent_panel->IsAttached());
|
|
EXPECT_TRUE(child_panel->IsAttached());
|
|
EXPECT_TRUE(
|
|
child_panel->IsSame(parent_panel->GetChildViewAt(expected_child_index)));
|
|
EXPECT_TRUE(child_panel->GetParentView()->IsSame(parent_panel));
|
|
}
|
|
|
|
void ChildVerifyFinalCallbackState(
|
|
CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel,
|
|
int expected_parent_callback_index,
|
|
bool added) {
|
|
parent_delegate->Verify(expected_parent_callback_index, parent_panel, added,
|
|
child_panel);
|
|
child_delegate->Verify(child_panel, added, parent_panel);
|
|
}
|
|
|
|
void ChildAdd(CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel,
|
|
int expected_child_index = 0,
|
|
int expected_parent_callback_index = 0) {
|
|
// Verify initial parent/child state.
|
|
ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel);
|
|
|
|
// Verify initial child callback state.
|
|
EXPECT_TRUE(child_delegate->IsReset());
|
|
|
|
// Add the child view.
|
|
parent_panel->AddChildView(child_panel);
|
|
|
|
// Verify final callback state.
|
|
ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, expected_parent_callback_index,
|
|
true);
|
|
|
|
// Reset child callback state.
|
|
child_delegate->Reset();
|
|
|
|
// Verify final parent/child state.
|
|
ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, expected_child_index);
|
|
}
|
|
|
|
void ChildAddAt(CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel,
|
|
int child_index,
|
|
int expected_parent_callback_index) {
|
|
// Verify initial parent/child state.
|
|
ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel);
|
|
|
|
// Verify initial child callback state.
|
|
EXPECT_TRUE(child_delegate->IsReset());
|
|
|
|
// Add the child view.
|
|
parent_panel->AddChildViewAt(child_panel, child_index);
|
|
|
|
// Verify final callback state.
|
|
ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, expected_parent_callback_index,
|
|
true);
|
|
|
|
// Reset child callback state.
|
|
child_delegate->Reset();
|
|
|
|
// Verify final parent/child state.
|
|
ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, child_index);
|
|
}
|
|
|
|
void ChildRemove(CefRefPtr<ParentPanelDelegate> parent_delegate,
|
|
CefRefPtr<CefPanel> parent_panel,
|
|
CefRefPtr<ChildPanelDelegate> child_delegate,
|
|
CefRefPtr<CefPanel> child_panel,
|
|
bool remove_all,
|
|
int expected_child_index = 0,
|
|
int expected_parent_callback_index = 0) {
|
|
// Verify initial parent/child state.
|
|
ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, expected_child_index);
|
|
|
|
// Verify initial child callback state.
|
|
EXPECT_TRUE(child_delegate->IsReset());
|
|
|
|
// Remove the child view.
|
|
if (remove_all)
|
|
parent_panel->RemoveAllChildViews();
|
|
else
|
|
parent_panel->RemoveChildView(child_panel);
|
|
|
|
// Verify final callback state.
|
|
ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel, expected_parent_callback_index,
|
|
false);
|
|
|
|
// Reset child callback state.
|
|
child_delegate->Reset();
|
|
|
|
// Verify final parent/child state.
|
|
ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
|
|
child_panel);
|
|
}
|
|
|
|
void ChildAddRemoveSingleImpl() {
|
|
CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
|
|
CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel = CefPanel::CreatePanel(child_delegate);
|
|
|
|
// Add and explicitly remove the child view.
|
|
EXPECT_TRUE(parent_delegate->IsReset());
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate, child_panel);
|
|
parent_delegate->Reset();
|
|
|
|
ChildRemove(parent_delegate, parent_panel, child_delegate, child_panel,
|
|
false);
|
|
parent_delegate->Reset();
|
|
|
|
// Add and implicitly remove the child view.
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate, child_panel);
|
|
parent_delegate->Reset();
|
|
|
|
ChildRemove(parent_delegate, parent_panel, child_delegate, child_panel,
|
|
false);
|
|
parent_delegate->Reset();
|
|
}
|
|
|
|
void ChildAddRemoveMultipleImpl() {
|
|
CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
|
|
CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate1 = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(child_delegate1);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate2 = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(child_delegate2);
|
|
|
|
// Add multiple child views.
|
|
EXPECT_TRUE(parent_delegate->IsReset());
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate1, child_panel1, 0, 0);
|
|
EXPECT_TRUE(child_delegate2->IsReset()); // child2 not called.
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate2, child_panel2, 1, 1);
|
|
EXPECT_TRUE(child_delegate1->IsReset()); // child1 not called.
|
|
parent_delegate->Reset();
|
|
|
|
EXPECT_EQ(2U, parent_panel->GetChildViewCount());
|
|
|
|
// Explicitly remove specific child views.
|
|
ChildRemove(parent_delegate, parent_panel, child_delegate1, child_panel1,
|
|
false, 0, 0);
|
|
EXPECT_TRUE(child_delegate2->IsReset()); // child2 not called.
|
|
ChildRemove(parent_delegate, parent_panel, child_delegate2, child_panel2,
|
|
false, 0, 1);
|
|
EXPECT_TRUE(child_delegate1->IsReset()); // child1 not called.
|
|
parent_delegate->Reset();
|
|
|
|
EXPECT_EQ(0U, parent_panel->GetChildViewCount());
|
|
|
|
// Add multiple child views.
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate1, child_panel1, 0, 0);
|
|
EXPECT_TRUE(child_delegate2->IsReset()); // child2 not called.
|
|
ChildAdd(parent_delegate, parent_panel, child_delegate2, child_panel2, 1, 1);
|
|
EXPECT_TRUE(child_delegate1->IsReset()); // child1 not called.
|
|
parent_delegate->Reset();
|
|
|
|
EXPECT_EQ(2U, parent_panel->GetChildViewCount());
|
|
|
|
EXPECT_TRUE(child_delegate1->IsReset());
|
|
EXPECT_TRUE(child_delegate2->IsReset());
|
|
|
|
// Implicitly remove all child views.
|
|
parent_panel->RemoveAllChildViews();
|
|
|
|
// Verify final callback state.
|
|
ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate1,
|
|
child_panel1, 0, false);
|
|
ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate2,
|
|
child_panel2, 1, false);
|
|
|
|
EXPECT_EQ(0U, parent_panel->GetChildViewCount());
|
|
|
|
// Reset callback state.
|
|
parent_delegate->Reset();
|
|
child_delegate1->Reset();
|
|
child_delegate2->Reset();
|
|
|
|
// Verify final parent/child state.
|
|
ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate1,
|
|
child_panel1);
|
|
ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate2,
|
|
child_panel2);
|
|
}
|
|
|
|
void ChildOrderImpl() {
|
|
CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
|
|
CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate1 = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(child_delegate1);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate2 = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(child_delegate2);
|
|
|
|
CefRefPtr<ChildPanelDelegate> child_delegate3 = new ChildPanelDelegate();
|
|
CefRefPtr<CefPanel> child_panel3 = CefPanel::CreatePanel(child_delegate3);
|
|
|
|
// Add child views at specific indexes.
|
|
ChildAddAt(parent_delegate, parent_panel, child_delegate2, child_panel2, 0,
|
|
0);
|
|
ChildAddAt(parent_delegate, parent_panel, child_delegate3, child_panel3, 0,
|
|
1);
|
|
ChildAddAt(parent_delegate, parent_panel, child_delegate1, child_panel1, 1,
|
|
2);
|
|
parent_delegate->Reset();
|
|
|
|
EXPECT_EQ(3U, parent_panel->GetChildViewCount());
|
|
|
|
// ChildAddAt() will verify these results but let's check again just to make
|
|
// sure.
|
|
EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(0)));
|
|
EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(1)));
|
|
EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(2)));
|
|
|
|
// Move panel2 to the front.
|
|
parent_panel->ReorderChildView(child_panel2, 0);
|
|
|
|
EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(0)));
|
|
EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(1)));
|
|
EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(2)));
|
|
|
|
// Move panel3 to the end.
|
|
parent_panel->ReorderChildView(child_panel3, -1);
|
|
|
|
EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(0)));
|
|
EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(1)));
|
|
EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(2)));
|
|
}
|
|
|
|
void ChildVisibleImpl() {
|
|
CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(nullptr);
|
|
CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(nullptr);
|
|
CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(nullptr);
|
|
|
|
// Nothing drawn by default.
|
|
EXPECT_FALSE(parent_panel->IsDrawn());
|
|
EXPECT_FALSE(child_panel1->IsDrawn());
|
|
EXPECT_FALSE(child_panel2->IsDrawn());
|
|
|
|
// Everything visible by default.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
parent_panel->AddChildView(child_panel1);
|
|
parent_panel->AddChildView(child_panel2);
|
|
|
|
// Still the same.
|
|
EXPECT_FALSE(parent_panel->IsDrawn());
|
|
EXPECT_FALSE(child_panel1->IsDrawn());
|
|
EXPECT_FALSE(child_panel2->IsDrawn());
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
child_panel1->SetVisible(false);
|
|
|
|
// Child1 not visible.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_FALSE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
child_panel1->SetVisible(true);
|
|
|
|
// Everything visible.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
parent_panel->SetVisible(false);
|
|
|
|
// Children visible.
|
|
EXPECT_FALSE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
parent_panel->SetVisible(true);
|
|
|
|
// Everything visible.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
}
|
|
|
|
void ChildDrawnImpl() {
|
|
CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(nullptr);
|
|
CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(nullptr);
|
|
CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(nullptr);
|
|
|
|
// Nothing drawn by default.
|
|
EXPECT_FALSE(parent_panel->IsDrawn());
|
|
EXPECT_FALSE(child_panel1->IsDrawn());
|
|
EXPECT_FALSE(child_panel2->IsDrawn());
|
|
|
|
// Everything visible by default.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
|
|
parent_panel->AddChildView(child_panel1);
|
|
parent_panel->AddChildView(child_panel2);
|
|
|
|
// Create and show a Window.
|
|
CefRefPtr<CefWindow> window = CefWindow::CreateTopLevelWindow(nullptr);
|
|
window->AddChildView(parent_panel);
|
|
window->CenterWindow(CefSize(400, 400));
|
|
window->Show();
|
|
|
|
// Everything visible and drawn now.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(parent_panel->IsDrawn());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsDrawn());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsDrawn());
|
|
|
|
child_panel1->SetVisible(false);
|
|
|
|
// Child1 not visible or drawn.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(parent_panel->IsDrawn());
|
|
EXPECT_FALSE(child_panel1->IsVisible());
|
|
EXPECT_FALSE(child_panel1->IsDrawn());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsDrawn());
|
|
|
|
child_panel1->SetVisible(true);
|
|
|
|
// Everything visible and drawn.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(parent_panel->IsDrawn());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsDrawn());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsDrawn());
|
|
|
|
parent_panel->SetVisible(false);
|
|
|
|
// Children visible, but nothing drawn.
|
|
EXPECT_FALSE(parent_panel->IsVisible());
|
|
EXPECT_FALSE(parent_panel->IsDrawn());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_FALSE(child_panel1->IsDrawn());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
EXPECT_FALSE(child_panel2->IsDrawn());
|
|
|
|
parent_panel->SetVisible(true);
|
|
|
|
// Everything visible and drawn.
|
|
EXPECT_TRUE(parent_panel->IsVisible());
|
|
EXPECT_TRUE(parent_panel->IsDrawn());
|
|
EXPECT_TRUE(child_panel1->IsVisible());
|
|
EXPECT_TRUE(child_panel1->IsDrawn());
|
|
EXPECT_TRUE(child_panel2->IsVisible());
|
|
EXPECT_TRUE(child_panel2->IsDrawn());
|
|
|
|
// Close the window.
|
|
window->Close();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Test child behaviors.
|
|
PANEL_TEST(ChildAddRemoveSingle)
|
|
PANEL_TEST(ChildAddRemoveMultiple)
|
|
PANEL_TEST(ChildOrder)
|
|
PANEL_TEST(ChildVisible)
|
|
PANEL_TEST(ChildDrawn)
|
|
|
|
namespace {
|
|
|
|
class SizingPanelDelegate : public CefPanelDelegate {
|
|
public:
|
|
SizingPanelDelegate() {}
|
|
|
|
CefSize GetPreferredSize(CefRefPtr<CefView> view) override {
|
|
got_get_preferred_size_ = true;
|
|
view_ = view;
|
|
return preferred_size_;
|
|
}
|
|
|
|
CefSize GetMinimumSize(CefRefPtr<CefView> view) override {
|
|
got_get_minimum_size_ = true;
|
|
view_ = view;
|
|
return minimum_size_;
|
|
}
|
|
|
|
CefSize GetMaximumSize(CefRefPtr<CefView> view) override {
|
|
got_get_maximum_size_ = true;
|
|
view_ = view;
|
|
return maximum_size_;
|
|
}
|
|
|
|
int GetHeightForWidth(CefRefPtr<CefView> view, int width) override {
|
|
got_get_height_for_width_ = true;
|
|
view_ = view;
|
|
width_ = width;
|
|
return height_for_width_;
|
|
}
|
|
|
|
void Reset() {
|
|
preferred_size_ = CefSize(0, 0);
|
|
minimum_size_ = CefSize(0, 0);
|
|
maximum_size_ = CefSize(0, 0);
|
|
height_for_width_ = 0;
|
|
got_get_preferred_size_ = false;
|
|
got_get_minimum_size_ = false;
|
|
got_get_maximum_size_ = false;
|
|
got_get_height_for_width_ = false;
|
|
view_ = nullptr;
|
|
width_ = 0;
|
|
}
|
|
|
|
bool IsReset() const {
|
|
return !got_get_preferred_size_ && !got_get_minimum_size_ &&
|
|
!got_get_maximum_size_ && !got_get_height_for_width_;
|
|
}
|
|
|
|
CefSize preferred_size_;
|
|
CefSize minimum_size_;
|
|
CefSize maximum_size_;
|
|
int height_for_width_ = 0;
|
|
|
|
bool got_get_preferred_size_ = false;
|
|
bool got_get_minimum_size_ = false;
|
|
bool got_get_maximum_size_ = false;
|
|
bool got_get_height_for_width_ = false;
|
|
|
|
CefRefPtr<CefView> view_;
|
|
int width_ = 0;
|
|
|
|
private:
|
|
IMPLEMENT_REFCOUNTING(SizingPanelDelegate);
|
|
DISALLOW_COPY_AND_ASSIGN(SizingPanelDelegate);
|
|
};
|
|
|
|
void SizeNoDelegateImpl() {
|
|
CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
|
|
|
|
// Set and get the bounds.
|
|
panel->SetBounds(CefRect(100, 100, 200, 200));
|
|
EXPECT_EQ(CefRect(100, 100, 200, 200), panel->GetBounds());
|
|
EXPECT_EQ(CefSize(200, 200), panel->GetSize());
|
|
EXPECT_EQ(CefPoint(100, 100), panel->GetPosition());
|
|
|
|
// GetBoundsInScreen() drops the position because there is no Window.
|
|
EXPECT_EQ(CefRect(0, 0, 200, 200), panel->GetBoundsInScreen());
|
|
|
|
// Adjust the position but keep the size the same.
|
|
panel->SetPosition(CefPoint(50, 50));
|
|
EXPECT_EQ(CefRect(50, 50, 200, 200), panel->GetBounds());
|
|
EXPECT_EQ(CefSize(200, 200), panel->GetSize());
|
|
EXPECT_EQ(CefPoint(50, 50), panel->GetPosition());
|
|
|
|
// Adjust the size but keep the position the same.
|
|
panel->SetSize(CefSize(400, 400));
|
|
EXPECT_EQ(CefRect(50, 50, 400, 400), panel->GetBounds());
|
|
EXPECT_EQ(CefSize(400, 400), panel->GetSize());
|
|
EXPECT_EQ(CefPoint(50, 50), panel->GetPosition());
|
|
|
|
// No delegate methods were called during this test.
|
|
EXPECT_TRUE(delegate->IsReset());
|
|
}
|
|
|
|
void SizeWithDelegateImpl() {
|
|
CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
|
|
|
|
CefSize expected_size(100, 100);
|
|
|
|
// Test GetPreferredSize().
|
|
delegate->preferred_size_ = expected_size;
|
|
EXPECT_EQ(expected_size, panel->GetPreferredSize());
|
|
EXPECT_TRUE(delegate->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel->IsSame(delegate->view_));
|
|
delegate->Reset();
|
|
|
|
// Test GetMinimumSize().
|
|
delegate->minimum_size_ = expected_size;
|
|
EXPECT_EQ(expected_size, panel->GetMinimumSize());
|
|
EXPECT_FALSE(delegate->got_get_preferred_size_);
|
|
EXPECT_TRUE(delegate->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel->IsSame(delegate->view_));
|
|
delegate->Reset();
|
|
|
|
// Test GetMaximumSize().
|
|
delegate->maximum_size_ = expected_size;
|
|
EXPECT_EQ(expected_size, panel->GetMaximumSize());
|
|
EXPECT_FALSE(delegate->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate->got_get_minimum_size_);
|
|
EXPECT_TRUE(delegate->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel->IsSame(delegate->view_));
|
|
delegate->Reset();
|
|
|
|
int expected_width = 200;
|
|
int expected_height = 100;
|
|
|
|
// Test GetHeightForWidth().
|
|
delegate->height_for_width_ = expected_height;
|
|
EXPECT_EQ(expected_height, panel->GetHeightForWidth(expected_width));
|
|
EXPECT_FALSE(delegate->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate->got_get_maximum_size_);
|
|
EXPECT_TRUE(delegate->got_get_height_for_width_);
|
|
EXPECT_EQ(expected_width, delegate->width_);
|
|
EXPECT_TRUE(panel->IsSame(delegate->view_));
|
|
delegate->Reset();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Test sizing.
|
|
PANEL_TEST(SizeNoDelegate)
|
|
PANEL_TEST(SizeWithDelegate)
|
|
|
|
namespace {
|
|
|
|
void FillLayoutCreateImpl() {
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(nullptr);
|
|
|
|
// Explicitly set to FillLayout.
|
|
panel->SetToFillLayout();
|
|
|
|
CefRefPtr<CefLayout> layout = panel->GetLayout();
|
|
EXPECT_TRUE(layout.get());
|
|
EXPECT_TRUE(layout->AsFillLayout().get());
|
|
}
|
|
|
|
void FillLayoutSizeToPreferredSizeImpl() {
|
|
CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);
|
|
|
|
// Default Layout is FillLayout.
|
|
CefRefPtr<CefLayout> layout = panel->GetLayout();
|
|
EXPECT_TRUE(layout.get());
|
|
EXPECT_TRUE(layout->AsFillLayout().get());
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
|
|
|
|
CefSize expected_size(100, 100);
|
|
|
|
delegate->preferred_size_ = expected_size;
|
|
|
|
// Trigger use of the preferred size.
|
|
panel->Layout();
|
|
|
|
EXPECT_TRUE(delegate->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel->IsSame(delegate->view_));
|
|
delegate->Reset();
|
|
|
|
// Size is now the preferred size.
|
|
EXPECT_EQ(expected_size, panel->GetSize());
|
|
|
|
// No additional delegate methods were called.
|
|
EXPECT_TRUE(delegate->IsReset());
|
|
}
|
|
|
|
void FillLayoutSizeHierarchyImpl() {
|
|
CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(nullptr);
|
|
CefRefPtr<CefPanel> panel_child = CefPanel::CreatePanel(nullptr);
|
|
|
|
CefSize expected_size(100, 100);
|
|
|
|
// Default Layout is FillLayout.
|
|
CefRefPtr<CefLayout> layout1 = panel_parent->GetLayout();
|
|
EXPECT_TRUE(layout1.get());
|
|
EXPECT_TRUE(layout1->AsFillLayout().get());
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child->GetBounds());
|
|
|
|
// Without delegates the size must be set on the parent.
|
|
panel_parent->SetSize(expected_size);
|
|
|
|
// FillLayout is the default Layout. Both panels should end up with the same
|
|
// size.
|
|
panel_parent->AddChildView(panel_child);
|
|
|
|
// Force layout.
|
|
panel_parent->Layout();
|
|
|
|
// Panels are now the same size.
|
|
EXPECT_EQ(expected_size, panel_parent->GetSize());
|
|
EXPECT_EQ(expected_size, panel_child->GetSize());
|
|
|
|
// Resize the parent panel to a larger size.
|
|
CefSize expected_size2(200, 200);
|
|
panel_parent->SetSize(expected_size2);
|
|
|
|
// Force layout.
|
|
panel_parent->Layout();
|
|
|
|
// Panels are now the larger size.
|
|
EXPECT_EQ(expected_size2, panel_parent->GetSize());
|
|
EXPECT_EQ(expected_size2, panel_child->GetSize());
|
|
}
|
|
|
|
void FillLayoutSizeHierarchyWithDelegate(bool size_from_parent) {
|
|
CefRefPtr<SizingPanelDelegate> delegate_parent = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(delegate_parent);
|
|
CefRefPtr<SizingPanelDelegate> delegate_child = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel_child = CefPanel::CreatePanel(delegate_child);
|
|
|
|
CefSize expected_size(100, 100);
|
|
|
|
// The default layout is FillLayout, but explicitly set it anyways just for
|
|
// some testing variety.
|
|
panel_parent->SetToFillLayout();
|
|
panel_child->SetToFillLayout();
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child->GetBounds());
|
|
|
|
// With delegates the size can come from either the parent or child.
|
|
if (size_from_parent)
|
|
delegate_parent->preferred_size_ = expected_size;
|
|
else
|
|
delegate_child->preferred_size_ = expected_size;
|
|
|
|
// FillLayout is the default Layout. Both panels should end up with the same
|
|
// size.
|
|
panel_parent->AddChildView(panel_child);
|
|
|
|
// No delegate methods were called yet.
|
|
EXPECT_TRUE(delegate_parent->IsReset());
|
|
EXPECT_TRUE(delegate_child->IsReset());
|
|
|
|
// Force layout.
|
|
panel_parent->Layout();
|
|
|
|
// delegate_parent will be called to get the preferred size for panel_parent.
|
|
EXPECT_TRUE(delegate_parent->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel_parent->IsSame(delegate_parent->view_));
|
|
delegate_parent->Reset();
|
|
|
|
// delegate_child will be called to get the preferred size for panel_child.
|
|
EXPECT_TRUE(delegate_child->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate_child->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate_child->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate_child->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel_child->IsSame(delegate_child->view_));
|
|
delegate_child->Reset();
|
|
|
|
// Panels are now the same size.
|
|
EXPECT_EQ(expected_size, panel_parent->GetSize());
|
|
EXPECT_EQ(expected_size, panel_child->GetSize());
|
|
|
|
// Resize the parent panel to a larger size.
|
|
CefSize expected_size2(200, 200);
|
|
panel_parent->SetSize(expected_size2);
|
|
|
|
// Force layout.
|
|
panel_parent->Layout();
|
|
|
|
// Panels are now the larger size.
|
|
EXPECT_EQ(expected_size2, panel_parent->GetSize());
|
|
EXPECT_EQ(expected_size2, panel_child->GetSize());
|
|
|
|
// No additional delegate methods were called.
|
|
EXPECT_TRUE(delegate_parent->IsReset());
|
|
EXPECT_TRUE(delegate_child->IsReset());
|
|
}
|
|
|
|
void FillLayoutSizeHierarchyFromParentWithDelegateImpl() {
|
|
FillLayoutSizeHierarchyWithDelegate(true);
|
|
}
|
|
|
|
void FillLayoutSizeHierarchyFromChildWithDelegateImpl() {
|
|
FillLayoutSizeHierarchyWithDelegate(false);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Test FillLayout.
|
|
PANEL_TEST(FillLayoutCreate)
|
|
PANEL_TEST(FillLayoutSizeToPreferredSize)
|
|
PANEL_TEST(FillLayoutSizeHierarchy)
|
|
PANEL_TEST(FillLayoutSizeHierarchyFromParentWithDelegate)
|
|
PANEL_TEST(FillLayoutSizeHierarchyFromChildWithDelegate)
|
|
|
|
namespace {
|
|
|
|
void BoxLayoutCreateImpl() {
|
|
CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(nullptr);
|
|
|
|
CefBoxLayoutSettings settings;
|
|
|
|
// Explicitly set to BoxLayout.
|
|
panel->SetToBoxLayout(settings);
|
|
|
|
CefRefPtr<CefLayout> layout = panel->GetLayout();
|
|
EXPECT_TRUE(layout.get());
|
|
EXPECT_TRUE(layout->AsBoxLayout().get());
|
|
}
|
|
|
|
const int kBLParentSize = 100;
|
|
const int kBLChildSize = 10;
|
|
|
|
void BoxLayoutSizeHierarchy(bool with_delegate,
|
|
const CefBoxLayoutSettings& settings,
|
|
const CefRect& expected_child1_bounds,
|
|
const CefRect& expected_child2_bounds,
|
|
int child1_flex = 0,
|
|
int child2_flex = 0) {
|
|
CefRefPtr<SizingPanelDelegate> delegate_parent;
|
|
if (with_delegate)
|
|
delegate_parent = new SizingPanelDelegate();
|
|
CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(delegate_parent);
|
|
|
|
CefRefPtr<SizingPanelDelegate> delegate_child1, delegate_child2;
|
|
if (with_delegate) {
|
|
delegate_child1 = new SizingPanelDelegate();
|
|
delegate_child2 = new SizingPanelDelegate();
|
|
}
|
|
CefRefPtr<CefPanel> panel_child1 = CefPanel::CreatePanel(delegate_child1);
|
|
CefRefPtr<CefPanel> panel_child2 = CefPanel::CreatePanel(delegate_child2);
|
|
|
|
// Default bounds are empty.
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child1->GetBounds());
|
|
EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child2->GetBounds());
|
|
|
|
// Give the parent a size.
|
|
CefSize initial_parent_size(kBLParentSize, kBLParentSize);
|
|
if (with_delegate)
|
|
delegate_parent->preferred_size_ = initial_parent_size;
|
|
else
|
|
panel_parent->SetSize(initial_parent_size);
|
|
|
|
// Give the children a size smaller than the parent.
|
|
CefSize initial_child_size(kBLChildSize, kBLChildSize);
|
|
if (with_delegate) {
|
|
delegate_child1->preferred_size_ = initial_child_size;
|
|
delegate_child2->preferred_size_ = initial_child_size;
|
|
} else {
|
|
panel_child1->SetSize(initial_child_size);
|
|
panel_child2->SetSize(initial_child_size);
|
|
}
|
|
|
|
// Set to BoxLayout with |settings|.
|
|
panel_parent->SetToBoxLayout(settings);
|
|
|
|
panel_parent->AddChildView(panel_child1);
|
|
panel_parent->AddChildView(panel_child2);
|
|
|
|
if (child1_flex > 0 || child2_flex > 0) {
|
|
// Flex will apply relative stretch in the main axis direction.
|
|
CefRefPtr<CefBoxLayout> layout = panel_parent->GetLayout()->AsBoxLayout();
|
|
if (child1_flex > 0)
|
|
layout->SetFlexForView(panel_child1, child1_flex);
|
|
if (child2_flex > 0)
|
|
layout->SetFlexForView(panel_child2, child2_flex);
|
|
}
|
|
|
|
if (with_delegate) {
|
|
// No delegate methods were called yet.
|
|
EXPECT_TRUE(delegate_parent->IsReset());
|
|
EXPECT_TRUE(delegate_child1->IsReset());
|
|
EXPECT_TRUE(delegate_child2->IsReset());
|
|
}
|
|
|
|
// Force layout.
|
|
panel_parent->Layout();
|
|
|
|
if (with_delegate) {
|
|
// delegate_parent will be called to get the preferred size for
|
|
// panel_parent.
|
|
EXPECT_TRUE(delegate_parent->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_maximum_size_);
|
|
EXPECT_FALSE(delegate_parent->got_get_height_for_width_);
|
|
EXPECT_TRUE(panel_parent->IsSame(delegate_parent->view_));
|
|
delegate_parent->Reset();
|
|
|
|
// delegate_child1 will be called to get the preferred size for
|
|
// panel_child1.
|
|
// GetHeightForWidth may also be called depending on the settings.
|
|
EXPECT_TRUE(delegate_child1->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate_child1->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate_child1->got_get_maximum_size_);
|
|
EXPECT_TRUE(panel_child1->IsSame(delegate_child1->view_));
|
|
delegate_child1->Reset();
|
|
|
|
// delegate_child2 will be called to get the preferred size for
|
|
// panel_child2.
|
|
// GetHeightForWidth may also be called depending on the settings.
|
|
EXPECT_TRUE(delegate_child2->got_get_preferred_size_);
|
|
EXPECT_FALSE(delegate_child2->got_get_minimum_size_);
|
|
EXPECT_FALSE(delegate_child2->got_get_maximum_size_);
|
|
EXPECT_TRUE(panel_child2->IsSame(delegate_child2->view_));
|
|
delegate_child2->Reset();
|
|
}
|
|
|
|
// The parent should be the same size.
|
|
EXPECT_EQ(initial_parent_size, panel_parent->GetSize());
|
|
|
|
// Children should have the expected bounds.
|
|
EXPECT_EQ(expected_child1_bounds, panel_child1->GetBounds());
|
|
EXPECT_EQ(expected_child2_bounds, panel_child2->GetBounds());
|
|
|
|
if (with_delegate) {
|
|
// No additional delegate methods were called.
|
|
EXPECT_TRUE(delegate_parent->IsReset());
|
|
EXPECT_TRUE(delegate_child1->IsReset());
|
|
EXPECT_TRUE(delegate_child2->IsReset());
|
|
}
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretch(bool with_delegate) {
|
|
// Vertical layout with children stretched along the horizontal axis.
|
|
//
|
|
// -----------
|
|
// |111111111|
|
|
// |222222222|
|
|
// | |
|
|
// | |
|
|
// | |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLParentSize, kBLChildSize);
|
|
CefRect expected_child2_bounds(0, kBLChildSize, kBLParentSize, kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretch(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretch(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretch(bool with_delegate) {
|
|
// Horizontal layout with children stretched along the vertical axis.
|
|
//
|
|
// -----------
|
|
// |12 |
|
|
// |12 |
|
|
// |12 |
|
|
// |12 |
|
|
// |12 |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.horizontal = true;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLChildSize, kBLParentSize);
|
|
CefRect expected_child2_bounds(kBLChildSize, 0, kBLChildSize, kBLParentSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretch(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretch(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenter(bool with_delegate) {
|
|
// Vertical layout with children centered along the horizontal axis.
|
|
//
|
|
// -----------
|
|
// | 1 |
|
|
// | 2 |
|
|
// | |
|
|
// | |
|
|
// | |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;
|
|
|
|
int xoffset = (kBLParentSize - kBLChildSize) / 2;
|
|
CefRect expected_child1_bounds(xoffset, 0, kBLChildSize, kBLChildSize);
|
|
CefRect expected_child2_bounds(xoffset, kBLChildSize, kBLChildSize,
|
|
kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenterImpl() {
|
|
BoxLayoutSizeHierarchyVerticalCenter(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenterWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyVerticalCenter(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenter(bool with_delegate) {
|
|
// Horizontal layout with children centered along the vertical axis.
|
|
//
|
|
// -----------
|
|
// | |
|
|
// | |
|
|
// |12 |
|
|
// | |
|
|
// | |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.horizontal = true;
|
|
settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;
|
|
|
|
int yoffset = (kBLParentSize - kBLChildSize) / 2;
|
|
CefRect expected_child1_bounds(0, yoffset, kBLChildSize, kBLChildSize);
|
|
CefRect expected_child2_bounds(kBLChildSize, yoffset, kBLChildSize,
|
|
kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenterImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalCenter(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenterWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalCenter(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenterCenter(bool with_delegate) {
|
|
// Vertical layout with children centered along the horizontal and vertical
|
|
// axis.
|
|
//
|
|
// -----------
|
|
// | |
|
|
// | 1 |
|
|
// | 2 |
|
|
// | |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.main_axis_alignment = CEF_MAIN_AXIS_ALIGNMENT_CENTER;
|
|
settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;
|
|
|
|
int xoffset = (kBLParentSize - kBLChildSize) / 2;
|
|
int yoffset = (kBLParentSize - (kBLChildSize * 2)) / 2;
|
|
CefRect expected_child1_bounds(xoffset, yoffset, kBLChildSize, kBLChildSize);
|
|
CefRect expected_child2_bounds(xoffset, yoffset + kBLChildSize, kBLChildSize,
|
|
kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenterCenterImpl() {
|
|
BoxLayoutSizeHierarchyVerticalCenterCenter(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalCenterCenterWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyVerticalCenterCenter(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenterCenter(bool with_delegate) {
|
|
// Horizontal layout with children centered along the vertical and horizontal
|
|
// axis.
|
|
//
|
|
// -----------
|
|
// | |
|
|
// | |
|
|
// | 12 |
|
|
// | |
|
|
// | |
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.horizontal = true;
|
|
settings.main_axis_alignment = CEF_MAIN_AXIS_ALIGNMENT_CENTER;
|
|
settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;
|
|
|
|
int xoffset = (kBLParentSize - (kBLChildSize * 2)) / 2;
|
|
int yoffset = (kBLParentSize - kBLChildSize) / 2;
|
|
CefRect expected_child1_bounds(xoffset, yoffset, kBLChildSize, kBLChildSize);
|
|
CefRect expected_child2_bounds(xoffset + kBLChildSize, yoffset, kBLChildSize,
|
|
kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenterCenterImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalCenterCenter(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalCenterCenterWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalCenterCenter(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexOne(bool with_delegate) {
|
|
// Vertical layout with child1 stretched along the horizontal and vertical
|
|
// axis and child2 stretched along the horizontal axis only (unequal flex).
|
|
//
|
|
// -----------
|
|
// |111111111|
|
|
// |111111111|
|
|
// |111111111|
|
|
// |111111111|
|
|
// |222222222|
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLParentSize,
|
|
kBLParentSize - kBLChildSize);
|
|
CefRect expected_child2_bounds(0, kBLParentSize - kBLChildSize, kBLParentSize,
|
|
kBLChildSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds, 1, 0);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexOneImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretchFlexOne(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexOneWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretchFlexOne(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexOne(bool with_delegate) {
|
|
// Horizontal layout with child1 stretched along the vertical and horizontal
|
|
// axis and child2 stretched along the vertical axis only (unequal flex).
|
|
//
|
|
// -----------
|
|
// |111111112|
|
|
// |111111112|
|
|
// |111111112|
|
|
// |111111112|
|
|
// |111111112|
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.horizontal = true;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLParentSize - kBLChildSize,
|
|
kBLParentSize);
|
|
CefRect expected_child2_bounds(kBLParentSize - kBLChildSize, 0, kBLChildSize,
|
|
kBLParentSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds, 1, 0);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexOneImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretchFlexOne(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexOneWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretchFlexOne(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexBoth(bool with_delegate) {
|
|
// Vertical layout with children stretched along the horizontal and vertical
|
|
// axis (equal flex).
|
|
//
|
|
// -----------
|
|
// |111111111|
|
|
// |111111111|
|
|
// |111111111|
|
|
// |222222222|
|
|
// |222222222|
|
|
// |222222222|
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLParentSize, kBLParentSize / 2);
|
|
CefRect expected_child2_bounds(0, kBLParentSize / 2, kBLParentSize,
|
|
kBLParentSize / 2);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds, 1, 1);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexBothImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretchFlexBoth(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyVerticalStretchFlexBothWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyVerticalStretchFlexBoth(true);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(bool with_delegate) {
|
|
// Horizontal layout with children stretched along the vertical and horizontal
|
|
// axis (equal flex).
|
|
//
|
|
// -----------
|
|
// |111122222|
|
|
// |111122222|
|
|
// |111122222|
|
|
// |111122222|
|
|
// |111122222|
|
|
// -----------
|
|
//
|
|
CefBoxLayoutSettings settings;
|
|
settings.horizontal = true;
|
|
|
|
CefRect expected_child1_bounds(0, 0, kBLParentSize / 2, kBLParentSize);
|
|
CefRect expected_child2_bounds(kBLParentSize / 2, 0, kBLParentSize / 2,
|
|
kBLParentSize);
|
|
|
|
BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
|
|
expected_child2_bounds, 1, 1);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexBothImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(false);
|
|
}
|
|
|
|
void BoxLayoutSizeHierarchyHorizontalStretchFlexBothWithDelegateImpl() {
|
|
BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(true);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Test BoxLayout. The BoxLayoutSizeHierarchy* tests are representative but not
|
|
// comprehensive (e.g. not all possible configurations are tested).
|
|
PANEL_TEST(BoxLayoutCreate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretch)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretch)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenter)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenter)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterCenter)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterCenterWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterCenter)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterCenterWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexOne)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexOneWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexOne)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexOneWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexBoth)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexBothWithDelegate)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexBoth)
|
|
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexBothWithDelegate)
|