From 4cbef60ff7265de13a3e9a5f1231a116b86b4807 Mon Sep 17 00:00:00 2001 From: l00574490 Date: Mon, 17 Jan 2022 21:31:01 +0800 Subject: [PATCH] add for split st Signed-off-by: l00574490 Change-Id: Id0d6277dcf753289b6d8ef95780cb5e1ca5af55a --- interfaces/innerkits/wm/wm_common.h | 1 + wm/test/systemtest/window_layout_test.cpp | 22 +-- wm/test/systemtest/window_split_test.cpp | 189 +++++++++++++++------- wm/test/systemtest/window_test_utils.cpp | 176 ++++++++++++++++++-- wm/test/systemtest/window_test_utils.h | 24 ++- wmserver/include/window_node_container.h | 1 - wmserver/src/window_node_container.cpp | 12 +- 7 files changed, 338 insertions(+), 87 deletions(-) diff --git a/interfaces/innerkits/wm/wm_common.h b/interfaces/innerkits/wm/wm_common.h index 34f5ca6768..8d69a0b9cb 100644 --- a/interfaces/innerkits/wm/wm_common.h +++ b/interfaces/innerkits/wm/wm_common.h @@ -104,6 +104,7 @@ struct Rect { namespace { constexpr uint32_t SYSTEM_COLOR_WHITE = 0xFFFFFFE5; constexpr uint32_t SYSTEM_COLOR_BLACK = 0x00000066; + constexpr float DEFAULT_SPLIT_RATIO = 0.5; } struct SystemBarProperty { diff --git a/wm/test/systemtest/window_layout_test.cpp b/wm/test/systemtest/window_layout_test.cpp index d495bf054d..41cf65f8c6 100644 --- a/wm/test/systemtest/window_layout_test.cpp +++ b/wm/test/systemtest/window_layout_test.cpp @@ -44,28 +44,28 @@ void WindowLayoutTest::SetUpTestCase() printf("GetDefaultDisplay: id %llu, w %d, h %d, fps %u\n", display->GetId(), display->GetWidth(), display->GetHeight(), display->GetFreshRate()); } - Rect screenRect = {0, 0, display->GetWidth(), display->GetHeight()}; - utils::InitByScreenRect(screenRect); + Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()}; + utils::InitByDisplayRect(displayRect); // calc expected rects Rect expected = { // 0. only statusBar 0, utils::statusBarRect_.height_, - utils::screenRect_.width_, - utils::screenRect_.height_ - utils::statusBarRect_.height_, + utils::displayRect_.width_, + utils::displayRect_.height_ - utils::statusBarRect_.height_, }; fullScreenExpecteds_.push_back(expected); expected = { // 1. both statusBar and naviBar 0, utils::statusBarRect_.height_, - utils::screenRect_.width_, - utils::screenRect_.height_ - utils::statusBarRect_.height_ - utils::naviBarRect_.height_, + utils::displayRect_.width_, + utils::displayRect_.height_ - utils::statusBarRect_.height_ - utils::naviBarRect_.height_, }; fullScreenExpecteds_.push_back(expected); expected = { // 2. only naviBar 0, 0, - utils::screenRect_.width_, - utils::screenRect_.height_ - utils::naviBarRect_.height_, + utils::displayRect_.width_, + utils::displayRect_.height_ - utils::naviBarRect_.height_, }; fullScreenExpecteds_.push_back(expected); } @@ -179,11 +179,11 @@ HWTEST_F(WindowLayoutTest, LayoutWindow06, Function | MediumTest | Level3) ASSERT_EQ(WMError::WM_OK, statBar->Show()); ASSERT_TRUE(utils::RectEqualTo(statBar, utils::statusBarRect_)); ASSERT_EQ(WMError::WM_OK, sysWin->Show()); - ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::screenRect_)); + ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::displayRect_)); ASSERT_EQ(WMError::WM_OK, naviBar->Show()); - ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::screenRect_)); + ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::displayRect_)); ASSERT_EQ(WMError::WM_OK, statBar->Hide()); - ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::screenRect_)); + ASSERT_TRUE(utils::RectEqualTo(sysWin, utils::displayRect_)); } /** diff --git a/wm/test/systemtest/window_split_test.cpp b/wm/test/systemtest/window_split_test.cpp index 4f13551ebf..d1d6e2901b 100644 --- a/wm/test/systemtest/window_split_test.cpp +++ b/wm/test/systemtest/window_split_test.cpp @@ -29,6 +29,8 @@ public: virtual void SetUp() override; virtual void TearDown() override; std::vector> activeWindows_; + utils::TestWindowInfo fullInfo_; + utils::TestWindowInfo splitInfo_; private: static constexpr uint32_t SPLIT_TEST_SPEEP_S = 1; // split test spleep time @@ -44,6 +46,26 @@ void WindowSplitTest::TearDownTestCase() void WindowSplitTest::SetUp() { + fullInfo_ = { + .name = "", + .rect = utils::defaultAppRect_, + .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, + .mode = WindowMode::WINDOW_MODE_FULLSCREEN, + .needAvoid = true, + .parentLimit = false, + .parentName = "", + }; + + splitInfo_ = { + .name = "", + .rect = utils::defaultAppRect_, + .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, + .mode = WindowMode::WINDOW_MODE_FULLSCREEN, + .needAvoid = true, + .parentLimit = false, + .parentName = "", + }; + activeWindows_.clear(); } @@ -58,89 +80,132 @@ void WindowSplitTest::TearDown() namespace { /** * @tc.name: SplitWindow01 - * @tc.desc: one primary window and one fullscreen window + * @tc.desc: one primary window and one fullscreen window, test mode change * @tc.type: FUNC * @tc.require: AR000GGTV7 */ HWTEST_F(WindowSplitTest, SplitWindow01, Function | MediumTest | Level3) { - utils::TestWindowInfo infoFullScreen = { - .name = "fullscreen.1", - .rect = utils::defaultAppRect_, - .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, - .mode = WindowMode::WINDOW_MODE_FULLSCREEN, - .needAvoid = true, - .parentLimit = false, - .parentName = "", - }; - utils::TestWindowInfo infoPrimary = { - .name = "primary.1", - .rect = utils::defaultAppRect_, - .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, - .mode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY, - .needAvoid = true, - .parentLimit = false, - .parentName = "", - }; - const sptr& windowFullScreen = utils::CreateTestWindow(infoFullScreen); - ASSERT_EQ(WMError::WM_OK, windowFullScreen->Show()); + fullInfo_.name = "fullscreen.1"; + splitInfo_.name = "primary.1"; + splitInfo_.mode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY; + + const sptr& fullWindow = utils::CreateTestWindow(fullInfo_); + activeWindows_.push_back(fullWindow); + ASSERT_EQ(WMError::WM_OK, fullWindow->Show()); sleep(SPLIT_TEST_SPEEP_S); - activeWindows_.push_back(windowFullScreen); - const sptr& windowPrimary = utils::CreateTestWindow(infoPrimary); - ASSERT_EQ(WMError::WM_OK, windowPrimary->Show()); + + const sptr& priWindow = utils::CreateTestWindow(splitInfo_); + activeWindows_.push_back(priWindow); + ASSERT_EQ(WMError::WM_OK, priWindow->Show()); sleep(SPLIT_TEST_SPEEP_S); - ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowPrimary->GetMode()); - activeWindows_.push_back(windowPrimary); - // show one split primary window - ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowFullScreen->GetMode()); - ASSERT_EQ(WMError::WM_OK, windowPrimary->Hide()); + + ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, priWindow->GetMode()); + ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, fullWindow->GetMode()); + + ASSERT_EQ(WMError::WM_OK, priWindow->Hide()); sleep(SPLIT_TEST_SPEEP_S); - ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, windowFullScreen->GetMode()); - ASSERT_EQ(WMError::WM_OK, windowFullScreen->Hide()); + ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, fullWindow->GetMode()); + ASSERT_EQ(WMError::WM_OK, fullWindow->Hide()); sleep(SPLIT_TEST_SPEEP_S); } /** * @tc.name: SplitWindow02 - * @tc.desc: one secondary window and one fullscreen window + * @tc.desc: one secondary window and one fullscreen window, test mode change * @tc.type: FUNC * @tc.require: AR000GGTV7 */ HWTEST_F(WindowSplitTest, SplitWindow02, Function | MediumTest | Level3) { - utils::TestWindowInfo infoFullScreen = { - .name = "fullscreen.2", - .rect = utils::defaultAppRect_, - .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, - .mode = WindowMode::WINDOW_MODE_FULLSCREEN, - .needAvoid = true, - .parentLimit = false, - .parentName = "", - }; - utils::TestWindowInfo infoSecondary = { - .name = "secondary.2", - .rect = utils::defaultAppRect_, - .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, - .mode = WindowMode::WINDOW_MODE_SPLIT_SECONDARY, - .needAvoid = true, - .parentLimit = false, - .parentName = "", - }; - const sptr& windowFullScreen = utils::CreateTestWindow(infoFullScreen); - ASSERT_EQ(WMError::WM_OK, windowFullScreen->Show()); + fullInfo_.name = "fullscreen.2"; + splitInfo_.name = "secondary.2"; + splitInfo_.mode = WindowMode::WINDOW_MODE_SPLIT_SECONDARY; + + const sptr& fullWindow = utils::CreateTestWindow(fullInfo_); + activeWindows_.push_back(fullWindow); + ASSERT_EQ(WMError::WM_OK, fullWindow->Show()); + sleep(SPLIT_TEST_SPEEP_S); + const sptr& secWindow = utils::CreateTestWindow(splitInfo_); + activeWindows_.push_back(secWindow); + ASSERT_EQ(WMError::WM_OK, secWindow->Show()); + sleep(SPLIT_TEST_SPEEP_S); + + ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, secWindow->GetMode()); + ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, fullWindow->GetMode()); + + ASSERT_EQ(WMError::WM_OK, fullWindow->Hide()); + sleep(SPLIT_TEST_SPEEP_S); + ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, secWindow->GetMode()); + ASSERT_EQ(WMError::WM_OK, secWindow->Hide()); + sleep(SPLIT_TEST_SPEEP_S); +} + +/** + * @tc.name: SplitCreen03 + * @tc.desc: one primary window and one fullscreen window, test rects + * @tc.type: FUNC + * @tc.require: AR000GGTV7 + */ +HWTEST_F(WindowSplitTest, SplitCreen03, Function | MediumTest | Level3) +{ + fullInfo_.name = "fullscreen.3"; + splitInfo_.name = "primary.3"; + splitInfo_.mode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY; + + utils::InitSplitRects(); + + const sptr& fullWindow = utils::CreateTestWindow(fullInfo_); + activeWindows_.push_back(fullWindow); + ASSERT_EQ(WMError::WM_OK, fullWindow->Show()); + sleep(SPLIT_TEST_SPEEP_S); + const sptr& priWindow = utils::CreateTestWindow(splitInfo_); + activeWindows_.push_back(priWindow); + ASSERT_EQ(WMError::WM_OK, priWindow->Show()); + sleep(SPLIT_TEST_SPEEP_S); + + utils::UpdateSplitRects(fullWindow); + + ASSERT_TRUE(utils::RectEqualTo(fullWindow, utils::splitRects_.secondaryRect)); + ASSERT_TRUE(utils::RectEqualTo(priWindow, utils::splitRects_.primaryRect)); + + ASSERT_EQ(WMError::WM_OK, fullWindow->Hide()); + sleep(SPLIT_TEST_SPEEP_S); + ASSERT_EQ(WMError::WM_OK, priWindow->Hide()); + sleep(SPLIT_TEST_SPEEP_S); +} + +/** + * @tc.name: SplitCreen04 + * @tc.desc: one secondary window and one fullscreen window, test rects + * @tc.type: FUNC + * @tc.require: AR000GGTV7 + */ +HWTEST_F(WindowSplitTest, SplitCreen04, Function | MediumTest | Level3) +{ + fullInfo_.name = "fullscreen.4"; + splitInfo_.name = "secondary.4"; + splitInfo_.mode = WindowMode::WINDOW_MODE_SPLIT_SECONDARY; + + utils::InitSplitRects(); + + const sptr& fullWindow = utils::CreateTestWindow(fullInfo_); + activeWindows_.push_back(fullWindow); + ASSERT_EQ(WMError::WM_OK, fullWindow->Show()); sleep(SPLIT_TEST_SPEEP_S); - activeWindows_.push_back(windowFullScreen); - const sptr& windowSecondary = utils::CreateTestWindow(infoSecondary); - ASSERT_EQ(WMError::WM_OK, windowSecondary->Show()); + const sptr& secWindow = utils::CreateTestWindow(splitInfo_); + activeWindows_.push_back(secWindow); + ASSERT_EQ(WMError::WM_OK, secWindow->Show()); sleep(SPLIT_TEST_SPEEP_S); - ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowSecondary->GetMode()); - activeWindows_.push_back(windowSecondary); - // show one split secondary window - ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowFullScreen->GetMode()); - ASSERT_EQ(WMError::WM_OK, windowFullScreen->Hide()); + + utils::UpdateSplitRects(fullWindow); + + ASSERT_TRUE(utils::RectEqualTo(fullWindow, utils::splitRects_.primaryRect)); + ASSERT_TRUE(utils::RectEqualTo(secWindow, utils::splitRects_.secondaryRect)); + + ASSERT_EQ(WMError::WM_OK, fullWindow->Hide()); sleep(SPLIT_TEST_SPEEP_S); - ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, windowSecondary->GetMode()); - ASSERT_EQ(WMError::WM_OK, windowSecondary->Hide()); + ASSERT_EQ(WMError::WM_OK, secWindow->Hide()); sleep(SPLIT_TEST_SPEEP_S); } } diff --git a/wm/test/systemtest/window_test_utils.cpp b/wm/test/systemtest/window_test_utils.cpp index 2a252e384a..111bd2c055 100644 --- a/wm/test/systemtest/window_test_utils.cpp +++ b/wm/test/systemtest/window_test_utils.cpp @@ -17,10 +17,17 @@ #include namespace OHOS { namespace Rosen { -Rect WindowTestUtils::screenRect_ = {0, 0, 0, 0}; -Rect WindowTestUtils::statusBarRect_ = {0, 0, 0, 0}; -Rect WindowTestUtils::naviBarRect_ = {0, 0, 0, 0}; -Rect WindowTestUtils::defaultAppRect_ = {0, 0, 0, 0}; +Rect WindowTestUtils::displayRect_ = {0, 0, 0, 0}; +Rect WindowTestUtils::statusBarRect_ = {0, 0, 0, 0}; +Rect WindowTestUtils::naviBarRect_ = {0, 0, 0, 0}; +Rect WindowTestUtils::defaultAppRect_ = {0, 0, 0, 0}; +Rect WindowTestUtils::limitDisplayRect_ = {0, 0, 0, 0}; +SplitRects WindowTestUtils::splitRects_ = { + .primaryRect = {0, 0, 0, 0}, + .secondaryRect = {0, 0, 0, 0}, + .dividerRect = {0, 0, 0, 0}, +}; +bool WindowTestUtils::isVerticalDisplay_ = false; sptr WindowTestUtils::CreateTestWindow(const TestWindowInfo& info) { @@ -83,14 +90,14 @@ sptr WindowTestUtils::CreateWindowScene() return scene; } -void WindowTestUtils::InitByScreenRect(const Rect& screenRect) +void WindowTestUtils::InitByDisplayRect(const Rect& displayRect) { const float barRatio = 0.07; const float appRation = 0.4; - screenRect_ = screenRect; - statusBarRect_ = {0, 0, screenRect_.width_, screenRect_.height_ * barRatio}; - naviBarRect_ = {0, screenRect_.height_ * (1 - barRatio), screenRect_.width_, screenRect_.height_ * barRatio}; - defaultAppRect_ = {0, 0, screenRect_.width_ * appRation, screenRect_.height_ * appRation}; + displayRect_ = displayRect; + statusBarRect_ = {0, 0, displayRect_.width_, displayRect_.height_ * barRatio}; + naviBarRect_ = {0, displayRect_.height_ * (1 - barRatio), displayRect_.width_, displayRect_.height_ * barRatio}; + defaultAppRect_ = {0, 0, displayRect_.width_ * appRation, displayRect_.height_ * appRation}; } bool WindowTestUtils::RectEqualTo(const sptr& window, const Rect& r) @@ -103,5 +110,156 @@ bool WindowTestUtils::RectEqualTo(const sptr& window, const Rect& r) } return res; } + +AvoidPosType WindowTestUtils::GetAvoidPosType(const Rect& rect) +{ + if (rect.width_ >= rect.height_) { + if (rect.posY_ == 0) { + return AvoidPosType::AVOID_POS_TOP; + } else { + return AvoidPosType::AVOID_POS_BOTTOM; + } + } else { + if (rect.posX_ == 0) { + return AvoidPosType::AVOID_POS_LEFT; + } else { + return AvoidPosType::AVOID_POS_RIGHT; + } + } + return AvoidPosType::AVOID_POS_UNKNOWN; +} + +void WindowTestUtils::InitSplitRects() +{ + auto display = DisplayManager::GetInstance().GetDisplayById(0); + if (display == nullptr) { + printf("GetDefaultDisplay: failed!\n"); + } else { + printf("GetDefaultDisplay: id %llu, w %d, h %d, fps %u\n", display->GetId(), display->GetWidth(), + display->GetHeight(), display->GetFreshRate()); + } + + Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()}; + displayRect_ = displayRect; + limitDisplayRect_ = displayRect; + + if (displayRect_.width_ < displayRect_.height_) { + isVerticalDisplay_ = true; + } + const uint32_t dividerWidth = 50; + if (isVerticalDisplay_) { + splitRects_.dividerRect = { 0, + static_cast((displayRect_.height_ - dividerWidth) * DEFAULT_SPLIT_RATIO), + displayRect_.width_, + dividerWidth, }; + } else { + splitRects_.dividerRect = { static_cast((displayRect_.width_ - dividerWidth) * DEFAULT_SPLIT_RATIO), + 0, + dividerWidth, + displayRect_.height_ }; + } +} + +void WindowTestUtils::UpdateSplitRects(const sptr& window) +{ + std::unique_ptr testUtils = std::make_unique(); + auto res = window->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM, testUtils->avoidArea_); + if (res != WMError::WM_OK) { + printf("Get avoid type failed\n"); + } + testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.leftRect); + testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.topRect); + testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.rightRect); + testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.bottomRect); + + if (isVerticalDisplay_) { + splitRects_.dividerRect.posY_ = limitDisplayRect_.posY_ + + static_cast((limitDisplayRect_.height_ - splitRects_.dividerRect.height_) * DEFAULT_SPLIT_RATIO); + testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posY_); + } else { + splitRects_.dividerRect.posX_ = limitDisplayRect_.posX_ + + static_cast((limitDisplayRect_.width_ - splitRects_.dividerRect.width_) * DEFAULT_SPLIT_RATIO); + testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posX_); + } +} + +void WindowTestUtils::UpdateLimitDisplayRect(Rect& avoidRect) +{ + if (((avoidRect.posX_ == 0) && (avoidRect.posY_ == 0) && + (avoidRect.width_ == 0) && (avoidRect.height_ == 0))) { + return; + } + auto avoidPosType = GetAvoidPosType(avoidRect); + int32_t offsetH = 0; + int32_t offsetW = 0; + switch (avoidPosType) { + case AvoidPosType::AVOID_POS_TOP: + offsetH = avoidRect.posY_ + avoidRect.height_ - limitDisplayRect_.posY_; + limitDisplayRect_.posY_ += offsetH; + limitDisplayRect_.height_ -= offsetH; + break; + case AvoidPosType::AVOID_POS_BOTTOM: + offsetH = limitDisplayRect_.posY_ + limitDisplayRect_.height_ - avoidRect.posY_; + limitDisplayRect_.height_ -= offsetH; + break; + case AvoidPosType::AVOID_POS_LEFT: + offsetW = avoidRect.posX_ + avoidRect.width_ - limitDisplayRect_.posX_; + limitDisplayRect_.posX_ += offsetW; + limitDisplayRect_.width_ -= offsetW; + break; + case AvoidPosType::AVOID_POS_RIGHT: + offsetW = limitDisplayRect_.posX_ + limitDisplayRect_.width_ - avoidRect.posX_; + limitDisplayRect_.width_ -= offsetW; + break; + default: + printf("invaild avoidPosType: %d\n", avoidPosType); + } +} + +void WindowTestUtils::UpdateLimitSplitRects(int32_t divPos) +{ + std::unique_ptr testUtils = std::make_unique(); + if (isVerticalDisplay_) { + splitRects_.dividerRect.posY_ = divPos; + + splitRects_.primaryRect.posX_ = displayRect_.posX_; + splitRects_.primaryRect.posY_ = displayRect_.posY_; + splitRects_.primaryRect.height_ = divPos; + splitRects_.primaryRect.width_ = displayRect_.width_; + + splitRects_.secondaryRect.posX_ = displayRect_.posX_; + splitRects_.secondaryRect.posY_ = splitRects_.dividerRect.posY_ + splitRects_.dividerRect.height_; + splitRects_.secondaryRect.height_ = displayRect_.height_ - splitRects_.secondaryRect.posY_; + splitRects_.secondaryRect.width_ = displayRect_.width_; + } else { + splitRects_.dividerRect.posX_ = divPos; + + splitRects_.primaryRect.posX_ = displayRect_.posX_; + splitRects_.primaryRect.posY_ = displayRect_.posY_; + splitRects_.primaryRect.width_ = divPos; + splitRects_.primaryRect.height_ = displayRect_.height_; + + splitRects_.secondaryRect.posX_ = splitRects_.dividerRect.posX_ + splitRects_.dividerRect.width_; + splitRects_.secondaryRect.posY_ = displayRect_.posY_; + splitRects_.secondaryRect.width_ = displayRect_.width_ - splitRects_.secondaryRect.posX_; + splitRects_.secondaryRect.height_ = displayRect_.height_; + } + + testUtils->UpdateLimitSplitRect(splitRects_.primaryRect); + testUtils->UpdateLimitSplitRect(splitRects_.secondaryRect); +} + +void WindowTestUtils::UpdateLimitSplitRect(Rect& limitSplitRect) +{ + Rect curLimitRect = limitSplitRect; + limitSplitRect.posX_ = std::max(limitDisplayRect_.posX_, curLimitRect.posX_); + limitSplitRect.posY_ = std::max(limitDisplayRect_.posY_, curLimitRect.posY_); + limitSplitRect.width_ = std::min(limitDisplayRect_.posX_ + limitDisplayRect_.width_, + curLimitRect.posX_ + curLimitRect.width_) - + limitSplitRect.posX_; + limitSplitRect.height_ = std::min(limitDisplayRect_.posY_ + limitDisplayRect_.height_, + curLimitRect.posY_ + curLimitRect.height_) - + limitSplitRect.posY_; +} } // namespace ROSEN } // namespace OHOS diff --git a/wm/test/systemtest/window_test_utils.h b/wm/test/systemtest/window_test_utils.h index a8998c6b37..f647b6c636 100644 --- a/wm/test/systemtest/window_test_utils.h +++ b/wm/test/systemtest/window_test_utils.h @@ -18,6 +18,7 @@ #include "display_manager.h" #include "window.h" +#include "window_layout_policy.h" #include "window_life_cycle_interface.h" #include "window_option.h" #include "window_scene.h" @@ -25,6 +26,12 @@ namespace OHOS { namespace Rosen { +struct SplitRects { + Rect primaryRect; + Rect secondaryRect; + Rect dividerRect; +}; + class WindowTestUtils { public: struct TestWindowInfo { @@ -36,16 +43,29 @@ public: bool parentLimit; std::string parentName; }; - static Rect screenRect_; + static Rect displayRect_; + static Rect limitDisplayRect_; static Rect statusBarRect_; static Rect naviBarRect_; static Rect defaultAppRect_; - static void InitByScreenRect(const Rect& screenRect); + static SplitRects splitRects_; + static bool isVerticalDisplay_; + + static void InitByDisplayRect(const Rect& screenRect); static sptr CreateTestWindow(const TestWindowInfo& info); static sptr CreateStatusBarWindow(); static sptr CreateNavigationBarWindow(); static sptr CreateWindowScene(); static bool RectEqualTo(const sptr& window, const Rect& r); + static void InitSplitRects(); + static void UpdateSplitRects(const sptr& window); + +private: + void UpdateLimitDisplayRect(Rect& avoidRect); + void UpdateLimitSplitRects(int32_t divPos); + void UpdateLimitSplitRect(Rect& limitSplitRect); + AvoidPosType GetAvoidPosType(const Rect& rect); + AvoidArea avoidArea_; }; } // namespace ROSEN } // namespace OHOS diff --git a/wmserver/include/window_node_container.h b/wmserver/include/window_node_container.h index cbaf17dbb3..a2354aa6a5 100644 --- a/wmserver/include/window_node_container.h +++ b/wmserver/include/window_node_container.h @@ -72,7 +72,6 @@ public: Rect displayRect_ = {0, 0, 0, 0}; Rect dividerRect_ = {0, 0, 0, 0}; }; - static constexpr float DEFAULT_SPLIT_RATIO = 0.5; private: void AssignZOrder(sptr& node); diff --git a/wmserver/src/window_node_container.cpp b/wmserver/src/window_node_container.cpp index 43e86ba5ec..ce6f3454ff 100644 --- a/wmserver/src/window_node_container.cpp +++ b/wmserver/src/window_node_container.cpp @@ -514,9 +514,11 @@ void WindowNodeContainer::DisplayRects::InitRect(Rect& oriDisplayRect) void WindowNodeContainer::DisplayRects::SetSplitRect(float ratio) { if (!isVertical_) { - dividerRect_.posX_ = displayDependRect_.posX_ + static_cast(displayDependRect_.width_ * ratio); + dividerRect_.posX_ = displayDependRect_.posX_ + + static_cast((displayDependRect_.width_ - dividerRect_.width_) * ratio); } else { - dividerRect_.posY_ = displayDependRect_.posY_ + static_cast(displayDependRect_.height_ * ratio); + dividerRect_.posY_ = displayDependRect_.posY_ + + static_cast((displayDependRect_.height_ - dividerRect_.height_) * ratio); } WLOGFI("set dividerRect :[%{public}d, %{public}d, %{public}d, %{public}d]", dividerRect_.posX_, dividerRect_.posY_, dividerRect_.width_, dividerRect_.height_); @@ -528,16 +530,22 @@ void WindowNodeContainer::DisplayRects::SetSplitRect(const Rect& divRect) dividerRect_.width_ = divRect.width_; dividerRect_.height_ = divRect.height_; if (!isVertical_) { + primaryRect_.posX_ = displayRect_.posX_; + primaryRect_.posY_ = displayRect_.posY_; primaryRect_.width_ = divRect.posX_; primaryRect_.height_ = displayRect_.height_; secondaryRect_.posX_ = divRect.posX_ + dividerRect_.width_; + secondaryRect_.posY_ = displayRect_.posY_; secondaryRect_.width_ = displayRect_.width_ - secondaryRect_.posX_; secondaryRect_.height_ = displayRect_.height_; } else { + primaryRect_.posX_ = displayRect_.posX_; + primaryRect_.posY_ = displayRect_.posY_; primaryRect_.height_ = divRect.posY_; primaryRect_.width_ = displayRect_.width_; + secondaryRect_.posX_ = displayRect_.posX_; secondaryRect_.posY_ = divRect.posY_ + dividerRect_.height_; secondaryRect_.height_ = displayRect_.height_ - secondaryRect_.posY_; secondaryRect_.width_ = displayRect_.width_; -- Gitee