openharmony/window_window_manager
1
0
Fork 0
mirror of https://gitee.com/openharmony/window_window_manager synced 2024-12-13 01:49:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

窗口沉浸式模式改为组件自动避让实现

Browse Source 
Change-Id: I74fe00472999704f1bc9476924bbd8d53572a66c
Signed-off-by: z00514981 <zhengjiangliang@huawei.com>
This commit is contained in:
z00514981 2023-03-03 11:37:16 +08:00
parent 86c7e60758
commit 6ec5663000
14 changed files with 12 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
test/systemtest/wms/window_test_utils.cpp
View File

@ -55,11 +55,6 @@ sptr<Window> WindowTestUtils::CreateTestWindow(const TestWindowInfo& info)
if (info.parentId != INVALID_WINDOW_ID) {
option->SetParentId(info.parentId);
}
if (info.needAvoid) {
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
} else {
option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
}
if (info.parentLimit) {
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
} else {

12
wm/src/window_impl.cpp
View File

@ -705,12 +705,7 @@ WMError WindowImpl::SetLayoutFullScreen(bool status)
WLOGFE("invalid window or fullscreen mode is not be supported, winId:%{public}u", property_->GetWindowId());
return WMError::WM_ERROR_INVALID_WINDOW;
}
WMError ret = SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
if (ret != WMError::WM_OK) {
WLOGFE("SetWindowMode errCode:%{public}d winId:%{public}u",
static_cast<int32_t>(ret), property_->GetWindowId());
return ret;
}
WMError ret = WMError::WM_OK;
if (status) {
ret = RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
if (ret != WMError::WM_OK) {
@ -3072,7 +3067,6 @@ void WindowImpl::SetDefaultOption()
break;
}
case WindowType::WINDOW_TYPE_KEYGUARD: {
RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
break;
}
@ -3122,10 +3116,8 @@ bool WindowImpl::IsWindowValid() const
bool WindowImpl::IsLayoutFullScreen() const
{
uint32_t flags = GetWindowFlags();
auto mode = GetMode();
bool needAvoid = (flags & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
return (mode == WindowMode::WINDOW_MODE_FULLSCREEN && !needAvoid);
return (mode == WindowMode::WINDOW_MODE_FULLSCREEN);
}
bool WindowImpl::IsFullScreen() const

1
wm/src/window_option.cpp
View File

@ -21,7 +21,6 @@ namespace OHOS {
namespace Rosen {
WindowOption::WindowOption(): windowTag_(WindowTag::SYSTEM_WINDOW)
{
AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
}
void WindowOption::SetWindowRect(const struct Rect& rect)

16
wm/test/unittest/window_impl_test.cpp
View File

@ -2173,29 +2173,21 @@ HWTEST_F(WindowImplTest, SetLayoutFullScreen, Function | SmallTest | Level3)
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
.WillOnce(Return(WMError::WM_OK))
.WillOnce(Return(WMError::WM_OK));
ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
.WillOnce(Return(WMError::WM_OK))
.WillOnce(Return(WMError::WM_DO_NOTHING));
ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
(~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
.WillOnce(Return(WMError::WM_OK))
.WillOnce(Return(WMError::WM_OK));
ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
(~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
.WillOnce(Return(WMError::WM_OK))
.WillOnce(Return(WMError::WM_DO_NOTHING));
@ -2230,23 +2222,17 @@ HWTEST_F(WindowImplTest, SetFullScreen, Function | SmallTest | Level3)
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3).WillRepeatedly(Return(WMError::WM_OK));
ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
(~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
.WillRepeatedly(Return(WMError::WM_OK));
ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
.WillOnce(Return(WMError::WM_OK))
.WillOnce(Return(WMError::WM_DO_NOTHING));
@ -2254,8 +2240,6 @@ HWTEST_F(WindowImplTest, SetFullScreen, Function | SmallTest | Level3)
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
.WillOnce(Return(WMError::WM_DO_NOTHING))
.WillOnce(Return(WMError::WM_OK))

8
wm/test/unittest/window_option_test.cpp
View File

@ -239,8 +239,8 @@ HWTEST_F(WindowOptionTest, WindowFlag01, Function | SmallTest | Level2)
HWTEST_F(WindowOptionTest, WindowFlag02, Function | SmallTest | Level2)
{
sptr<WindowOption> option = new WindowOption();
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
ASSERT_EQ(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID), option->GetWindowFlags());
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
ASSERT_EQ(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED), option->GetWindowFlags());
}
/**
@ -251,9 +251,9 @@ HWTEST_F(WindowOptionTest, WindowFlag02, Function | SmallTest | Level2)
HWTEST_F(WindowOptionTest, WindowFlag03, Function | SmallTest | Level2)
{
sptr<WindowOption> option = new WindowOption();
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
option->AddWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
ASSERT_EQ(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_PARENT_LIMIT), option->GetWindowFlags());
}

1
wmserver/include/remote_animation.h
View File

@ -89,7 +89,6 @@ private:
static sptr<RSWindowAnimationFinishedCallback> CreateHideAnimationFinishedCallback(
const sptr<WindowNode>& srcNode, TransitionEvent event);
static void ProcessNodeStateTask(sptr<WindowNode>& node);
static void GetExpectRect(const sptr<WindowNode>& dstNode, const sptr<RSWindowAnimationTarget>& dstTarget);
static void PostProcessShowCallback(const sptr<WindowNode>& node);
static void ExecuteFinalStateTask(sptr<WindowNode>& node);
static void GetAnimationTargetsForHome(std::vector<sptr<RSWindowAnimationTarget>>& animationTargets,

1
wmserver/src/freeze_controller.cpp
View File

@ -76,7 +76,6 @@ sptr<Window> FreezeController::CreateCoverWindow(DisplayId displayId)
option->SetWindowType(WindowType::WINDOW_TYPE_FREEZE_DISPLAY);
option->SetFocusable(false);
option->SetMainHandlerAvailable(false);
option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
option->SetDisplayId(displayId);
sptr<Window> window = Window::Create("freeze" + std::to_string(displayId), option);
if (window == nullptr) {

32
wmserver/src/remote_animation.cpp
View File

@ -305,36 +305,6 @@ WMError RemoteAnimation::NotifyAnimationStartApp(sptr<WindowTransitionInfo> srcI
return WMError::WM_OK;
}
void RemoteAnimation::GetExpectRect(const sptr<WindowNode>& dstNode, const sptr<RSWindowAnimationTarget>& dstTarget)
{
// when exit immersive, startingWindow (0,0,w,h), but app need avoid
bool needAvoid = (dstNode->GetWindowFlags() & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
auto winRoot = windowRoot_.promote();
if (needAvoid && winRoot) {
auto avoidRect = winRoot->GetDisplayRectWithoutSystemBarAreas(dstNode);
if (WindowHelper::IsEmptyRect(avoidRect)) {
return;
}
WLOGFI("name:%{public}s id:%{public}u avoidRect:[x:%{public}d, y:%{public}d, w:%{public}d, h:%{public}d]",
dstNode->GetWindowName().c_str(), dstNode->GetWindowId(),
avoidRect.posX_, avoidRect.posY_, avoidRect.width_, avoidRect.height_);
if (WindowHelper::IsMainFullScreenWindow(dstNode->GetWindowType(), dstNode->GetWindowMode())) {
auto boundsRect = RectF(avoidRect.posX_, avoidRect.posY_, avoidRect.width_, avoidRect.height_);
auto displayInfo = DisplayGroupInfo::GetInstance().GetDisplayInfo(dstNode->GetDisplayId());
if (displayInfo && WmsUtils::IsExpectedRotatableWindow(dstNode->GetRequestedOrientation(),
displayInfo->GetDisplayOrientation(), dstNode->GetWindowFlags())) {
WLOGFD("[FixOrientation] window %{public}u expected rotatable, pre-cal bounds", dstNode->GetWindowId());
boundsRect = RectF(avoidRect.posX_, avoidRect.posY_, avoidRect.height_, avoidRect.width_);
}
dstTarget->windowBounds_.rect_ = boundsRect;
if (dstNode->leashWinSurfaceNode_) {
dstNode->leashWinSurfaceNode_->SetBounds(avoidRect.posX_, avoidRect.posY_,
avoidRect.width_, avoidRect.height_);
}
}
}
}
WMError RemoteAnimation::NotifyAnimationTransition(sptr<WindowTransitionInfo> srcInfo,
sptr<WindowTransitionInfo> dstInfo, const sptr<WindowNode>& srcNode,
const sptr<WindowNode>& dstNode)
@ -361,8 +331,6 @@ WMError RemoteAnimation::NotifyAnimationTransition(sptr<WindowTransitionInfo> sr
}
ResSchedReport::GetInstance().ResSchedDataReport(
Rosen::RES_TYPE_SHOW_REMOTE_ANIMATION, Rosen::REMOTE_ANIMATION_BEGIN, payload);
// when exit immersive, startingWindow (0,0,w,h), but app need avoid
GetExpectRect(dstNode, dstTarget);
dstNode->isPlayAnimationShow_ = true;
// Transition to next state and update task count will success when enable animationFirst_
dstNode->stateMachine_.TransitionTo(WindowNodeState::SHOW_ANIMATION_PLAYING);

5
wmserver/src/starting_window.cpp
View File

@ -87,11 +87,6 @@ sptr<WindowNode> StartingWindow::CreateWindowNode(const sptr<WindowTransitionInf
property->SetDisplayId(info->GetDisplayId());
property->SetWindowType(info->GetWindowType());
auto displayInfo = DisplayGroupInfo::GetInstance().GetDisplayInfo(info->GetDisplayId());
if (!(displayInfo && WmsUtils::IsExpectedRotatableWindow(orientation,
displayInfo->GetDisplayOrientation(), property->GetWindowMode(), property->GetWindowFlags(), false))) {
property->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
}
if (info->GetShowFlagWhenLocked()) {
property->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
}

3
wmserver/src/window_layout_policy_cascade.cpp
View File

@ -437,8 +437,7 @@ void WindowLayoutPolicyCascade::UpdateLayoutRect(const sptr<WindowNode>& node)
winRect = cascadeRectsMap_[displayId].secondaryRect_;
break;
case WindowMode::WINDOW_MODE_FULLSCREEN: {
bool needAvoid = (node->GetWindowFlags() & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
winRect = needAvoid ? limitRectMap_[displayId] : DisplayGroupInfo::GetInstance().GetDisplayRect(displayId);
winRect = DisplayGroupInfo::GetInstance().GetDisplayRect(displayId);
auto displayInfo = DisplayGroupInfo::GetInstance().GetDisplayInfo(displayId);
if (displayInfo && WmsUtils::IsExpectedRotatableWindow(node->GetRequestedOrientation(),
displayInfo->GetDisplayOrientation(), node->GetWindowFlags())) {

5
wmserver/src/window_layout_policy_tile.cpp
View File

@ -347,7 +347,6 @@ void WindowLayoutPolicyTile::UpdateLayoutRect(const sptr<WindowNode>& node)
{
UpdateWindowSizeLimits(node);
bool floatingWindow = (node->GetWindowMode() == WindowMode::WINDOW_MODE_FLOATING);
bool needAvoid = (node->GetWindowFlags() & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
Rect lastRect = node->GetWindowRect();
Rect winRect = node->GetRequestRect();
WLOGI("[Before TileLayout] windowId: %{public}u, mode: %{public}u, type: %{public}u requestRect: [%{public}d, "
@ -355,9 +354,7 @@ void WindowLayoutPolicyTile::UpdateLayoutRect(const sptr<WindowNode>& node)
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
if (!floatingWindow) { // fullscreen window
const auto& displayRect = DisplayGroupInfo::GetInstance().GetDisplayRect(node->GetDisplayId());
const auto& limitDisplayRect = limitRectMap_[node->GetDisplayId()];
winRect = needAvoid ? limitDisplayRect : displayRect;
winRect = DisplayGroupInfo::GetInstance().GetDisplayRect(node->GetDisplayId());
}
WLOGI("[After TileLayout] windowId: %{public}u, isDecor: %{public}u, winRect: [%{public}d, %{public}d, "

4
wmserver/src/window_node_container.cpp
View File

@ -207,8 +207,6 @@ void WindowNodeContainer::LayoutWhenAddWindowNode(sptr<WindowNode>& node, bool a
{
if (afterAnimation) {
layoutPolicy_->PerformWindowLayout(node, WindowUpdateType::WINDOW_UPDATE_ADDED);
// tile layout will change window mode from fullscreen to float
// notify systembar window to change color
NotifyIfAvoidAreaChanged(node, AvoidControlType::AVOID_NODE_ADD);
DumpScreenWindowTreeByWinId(node->GetWindowId());
return;
@ -232,8 +230,6 @@ void WindowNodeContainer::LayoutWhenAddWindowNode(sptr<WindowNode>& node, bool a
node->SetWindowSizeChangeReason(WindowSizeChangeReason::CUSTOM_ANIMATION_SHOW);
}
layoutPolicy_->PerformWindowLayout(node, WindowUpdateType::WINDOW_UPDATE_ADDED);
// tile layout will change window mode from fullscreen to float
// notify systembar window to change color
NotifyIfAvoidAreaChanged(node, AvoidControlType::AVOID_NODE_ADD);
DumpScreenWindowTreeByWinId(node->GetWindowId());
}

41
wmserver/test/unittest/remote_animation_test.cpp
View File

@ -608,47 +608,6 @@ HWTEST_F(RemoteAnimationTest, GetTransitionEvent02, Function | SmallTest | Level
EXPECT_EQ(TransitionEvent::UNKNOWN, event);
}
/**
* @tc.name: GetExpectRect01
* @tc.desc: GetExpectRect
* @tc.type: FUNC
*/
HWTEST_F(RemoteAnimationTest, GetExpectRect01, Function | SmallTest | Level2)
{
auto target = RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, node_);
RemoteAnimation::GetExpectRect(node_, target);
Rect actualRect = GetSurfaceBoundsRect(node_);
EXPECT_EQ(node_->GetWindowRect(), actualRect); // avoidRect is empty thus return
sptr<WindowNode> statusBar = new WindowNode(CreateWindowProperty(0));
ASSERT_NE(nullptr, statusBar);
statusBar->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
statusBar->SetWindowRect({0, 0, 100, 100});
windowRoot_->windowNodeMap_[0] = statusBar;
Rect avoidRect = windowRoot_->GetDisplayRectWithoutSystemBarAreas(node_);
EXPECT_FALSE(WindowHelper::IsEmptyRect(avoidRect));
RemoteAnimation::GetExpectRect(node_, target);
actualRect = GetSurfaceBoundsRect(node_);
EXPECT_EQ(avoidRect, actualRect); // get expect rect
node_->leashWinSurfaceNode_ = nullptr;
RemoteAnimation::GetExpectRect(node_, target);
node_->GetWindowProperty()->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
RemoteAnimation::GetExpectRect(node_, target);
EXPECT_FALSE(WindowHelper::IsMainFullScreenWindow(node_->GetWindowType(), node_->GetWindowMode()));
RemoteAnimation::windowRoot_ = nullptr;
RemoteAnimation::GetExpectRect(node_, target);
node_->GetWindowProperty()->SetWindowFlags(0);
RemoteAnimation::GetExpectRect(node_, target);
bool needAvoid = (node_->GetWindowFlags() & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
EXPECT_EQ(false, needAvoid);
}
/**
* @tc.name: NotifyAnimationTransition01
* @tc.desc: NotifyAnimationTransition failed

8
wmserver/test/unittest/window_pair_test.cpp
View File

@ -254,7 +254,7 @@ HWTEST_F(WindowPairTest, IsForbidDockSliceMove02, Function | SmallTest | Level2)
sptr<WindowPair> windowPair = new WindowPair(0);
windowPair->status_ = WindowPairStatus::PAIRED_DONE;
sptr<WindowProperty> property1 = new WindowProperty();
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
windowPair->primary_ = new WindowNode(property1);
windowPair->secondary_ = new WindowNode(property1);
ASSERT_EQ(false, windowPair->IsForbidDockSliceMove());
@ -270,7 +270,7 @@ HWTEST_F(WindowPairTest, IsForbidDockSliceMove03, Function | SmallTest | Level2)
sptr<WindowPair> windowPair = new WindowPair(0);
windowPair->status_ = WindowPairStatus::PAIRED_DONE;
sptr<WindowProperty> property1 = new WindowProperty();
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
windowPair->primary_ = nullptr;
windowPair->secondary_ = new WindowNode(property1);
ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
@ -302,7 +302,7 @@ HWTEST_F(WindowPairTest, IsForbidDockSliceMove05, Function | SmallTest | Level2)
sptr<WindowPair> windowPair = new WindowPair(0);
windowPair->status_ = WindowPairStatus::PAIRED_DONE;
sptr<WindowProperty> property1 = new WindowProperty();
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
windowPair->primary_ = new WindowNode(property1);
windowPair->secondary_ = nullptr;
ASSERT_EQ(true, windowPair->IsForbidDockSliceMove());
@ -318,7 +318,7 @@ HWTEST_F(WindowPairTest, IsForbidDockSliceMove06, Function | SmallTest | Level2)
sptr<WindowPair> windowPair = new WindowPair(0);
windowPair->status_ = WindowPairStatus::PAIRED_DONE;
sptr<WindowProperty> property1 = new WindowProperty();
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
property1->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
sptr<WindowProperty> property2 = new WindowProperty();
property2->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE));
windowPair->primary_ = new WindowNode(property1);