openharmony/windowmanager
1
0
Fork 0
mirror of https://github.com/openharmony/windowmanager.git synced 2026-07-20 01:13:32 -04:00
Code Issues Packages Projects Releases Wiki Activity

支持自由窗口自定义大小和比例限制

Browse Source 
:
Signed-off-by: l00574490 <liuqi149@huawei.com>

Change-Id: I175e1b6990ec68c18ea6dd0e7b08966216ac8011
This commit is contained in:
l00574490
2022-05-24 17:56:37 +08:00
parent 1c04f1a162
commit a8e251aa35
21 changed files with 592 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dmserver/include/display_manager_config.h
+3 -3
View File
@@ -31,14 +31,14 @@ public:
~DisplayManagerConfig() = default;
static bool LoadConfigXml(const std::string& configFilePath);
static const std::map<std::string, std::vector<int>>& GetNumbersConfig();
static const std::map<std::string, std::vector<int>>& GetIntNumbersConfig();
static void DumpConfig();
private:
static std::map<std::string, std::vector<int>> numbersConfig_;
static std::map<std::string, std::vector<int>> intNumbersConfig_;
static bool IsValidNode(const xmlNode& currNode);
static void ReadNumbersConfigInfo(const xmlNodePtr& currNode);
static void ReadIntNumbersConfigInfo(const xmlNodePtr& currNode);
static std::vector<std::string> Split(std::string str, std::string pattern);
static inline bool IsNumber(std::string str);
dmserver/src/display_manager_config.cpp
+7 -7
View File
@@ -22,7 +22,7 @@ namespace {
constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "DisplayManagerConfig"};
}
std::map<std::string, std::vector<int>> DisplayManagerConfig::numbersConfig_;
std::map<std::string, std::vector<int>> DisplayManagerConfig::intNumbersConfig_;
std::vector<std::string> DisplayManagerConfig::Split(std::string str, std::string pattern)
{
@@ -76,7 +76,7 @@ bool DisplayManagerConfig::LoadConfigXml(const std::string& configFilePath)
auto nodeName = curNodePtr->name;
if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("dpi"))) {
ReadNumbersConfigInfo(curNodePtr);
ReadIntNumbersConfigInfo(curNodePtr);
continue;
}
}
@@ -92,7 +92,7 @@ bool DisplayManagerConfig::IsValidNode(const xmlNode& currNode)
return true;
}
void DisplayManagerConfig::ReadNumbersConfigInfo(const xmlNodePtr& currNode)
void DisplayManagerConfig::ReadIntNumbersConfigInfo(const xmlNodePtr& currNode)
{
xmlChar* context = xmlNodeGetContent(currNode);
if (context == nullptr) {
@@ -113,18 +113,18 @@ void DisplayManagerConfig::ReadNumbersConfigInfo(const xmlNodePtr& currNode)
}
std::string nodeName = reinterpret_cast<const char *>(currNode->name);
numbersConfig_[nodeName] = numbersVec;
intNumbersConfig_[nodeName] = numbersVec;
xmlFree(context);
}
const std::map<std::string, std::vector<int>>& DisplayManagerConfig::GetNumbersConfig()
const std::map<std::string, std::vector<int>>& DisplayManagerConfig::GetIntNumbersConfig()
{
return numbersConfig_;
return intNumbersConfig_;
}
void DisplayManagerConfig::DumpConfig()
{
for (auto& numbers : numbersConfig_) {
for (auto& numbers : intNumbersConfig_) {
WLOGFI("[DmConfig] Numbers: %{public}s %{public}zu", numbers.first.c_str(), numbers.second.size());
for (auto& num : numbers.second) {
WLOGFI("[DmConfig] Num: %{public}d", num);
dmserver/src/display_manager_service.cpp
+1 -1
View File
@@ -80,7 +80,7 @@ bool DisplayManagerService::Init()
void DisplayManagerService::ConfigureDisplayManagerService()
{
auto numbersConfig = DisplayManagerConfig::GetNumbersConfig();
auto numbersConfig = DisplayManagerConfig::GetIntNumbersConfig();
if (numbersConfig.count("dpi") != 0) {
uint32_t densityDpi = static_cast<uint32_t>(numbersConfig["dpi"][0]);
if (densityDpi == 0) {
utils/include/window_helper.h
+11 -37
View File
@@ -171,43 +171,6 @@ public:
return dstRect;
}
static Rect GetFixedWindowRectByLimitPosition(const Rect& oriDstRect, const Rect& lastRect,
float virtualPixelRatio, const Rect& displayLimitRect)
{
Rect dstRect = oriDstRect;
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
// minimum (x + width)
if (dstRect.posX_ < (displayLimitRect.posX_ + static_cast<int32_t>(windowTitleBarH - oriDstRect.width_))) {
if (oriDstRect.width_ != lastRect.width_) {
dstRect.width_ = static_cast<uint32_t>(displayLimitRect.posX_ - oriDstRect.posX_) + windowTitleBarH;
}
}
// maximum position x
if (dstRect.posX_ > (displayLimitRect.posX_ +
static_cast<int32_t>(displayLimitRect.width_ - windowTitleBarH))) {
dstRect.posX_ = displayLimitRect.posX_ + static_cast<int32_t>(displayLimitRect.width_ - windowTitleBarH);
if (oriDstRect.width_ != lastRect.width_) {
dstRect.width_ = lastRect.width_;
}
}
// minimum position y
if (oriDstRect.posY_ < displayLimitRect.posY_) {
dstRect.posY_ = displayLimitRect.posY_;
if (oriDstRect.height_ != lastRect.height_) {
dstRect.height_ = lastRect.height_;
}
}
// maximum position y
if (dstRect.posY_ > (displayLimitRect.posY_ +
static_cast<int32_t>(displayLimitRect.height_ - windowTitleBarH))) {
dstRect.posY_ = displayLimitRect.posY_ + static_cast<int32_t>(displayLimitRect.height_ - windowTitleBarH);
if (oriDstRect.height_ != lastRect.height_) {
dstRect.height_ = lastRect.height_;
}
}
return dstRect;
}
static bool IsPointInTargetRect(int32_t pointPosX, int32_t pointPosY, const Rect& targetRect)
{
if ((pointPosX > targetRect.posX_) &&
@@ -265,6 +228,17 @@ public:
return true;
}
static inline bool IsFloatingNumber(std::string str)
{
for (int32_t i = 0; i < static_cast<int32_t>(str.size()); i++) {
if ((str.at(i) < '0' || str.at(i) > '9') &&
(str.at(i) != '.' || std::count(str.begin(), str.end(), '.') > 1)) {
return false;
}
}
return true;
}
static std::vector<std::string> Split(std::string str, std::string pattern)
{
int32_t position;
utils/include/window_property.h
+4
View File
@@ -24,6 +24,7 @@
#include "class_var_definition.h"
#include "dm_common.h"
#include "wm_common.h"
#include "wm_common_inner.h"
namespace OHOS {
namespace Rosen {
@@ -67,6 +68,7 @@ public:
void SetWindowSizeChangeReason(WindowSizeChangeReason reason);
void SetTokenState(bool hasToken);
void SetModeSupportInfo(uint32_t modeSupportInfo);
void SetDragType(DragType dragType);
WindowSizeChangeReason GetWindowSizeChangeReason() const;
const std::string& GetWindowName() const;
@@ -98,6 +100,7 @@ public:
const PointInfo& GetHitOffset() const;
uint32_t GetAnimationFlag() const;
uint32_t GetModeSupportInfo() const;
DragType GetDragType() const;
virtual bool Marshalling(Parcel& parcel) const override;
static WindowProperty* Unmarshalling(Parcel& parcel);
@@ -137,6 +140,7 @@ private:
{ WindowType::WINDOW_TYPE_NAVIGATION_BAR, SystemBarProperty() },
};
bool isDecorEnable_ { false };
DragType dragType_ = DragType::DRAG_UNDEFINED;
DEFINE_VAR_DEFAULT_FUNC_GET_SET(Orientation, RequestedOrientation, requestedOrientation, Orientation::UNSPECIFIED);
};
}
utils/include/wm_common_inner.h
+19
View File
@@ -85,12 +85,31 @@ struct ModeChangeHotZonesConfig {
uint32_t secondaryRange_;
};
struct FloatingWindowLimitsConfig {
bool isFloatingWindowLimitsConfigured_;
uint32_t maxWidth_;
uint32_t maxHeight_;
uint32_t minWidth_;
uint32_t minHeight_;
float maxRatio_;
float minRatio_;
FloatingWindowLimitsConfig() : isFloatingWindowLimitsConfigured_(false), maxWidth_(0), maxHeight_(0), minWidth_(0),
minHeight_(0), maxRatio_(0.0f), minRatio_(0.0f) {}
};
struct ModeChangeHotZones {
Rect fullscreen_;
Rect primary_;
Rect secondary_;
};
enum class DragType : uint32_t {
DRAG_UNDEFINED,
DRAG_WIDTH,
DRAG_HEIGHT,
DRAG_CORNER,
};
namespace {
constexpr float DEFAULT_SPLIT_RATIO = 0.5;
constexpr float DEFAULT_ASPECT_RATIO = 0.66;
utils/src/window_property.cpp
+13 -1
View File
@@ -165,6 +165,11 @@ void WindowProperty::SetWindowSizeChangeReason(WindowSizeChangeReason reason)
windowSizeChangeReason_ = reason;
}
void WindowProperty::SetDragType(DragType dragType)
{
dragType_ = dragType;
}
WindowSizeChangeReason WindowProperty::GetWindowSizeChangeReason() const
{
return windowSizeChangeReason_;
@@ -335,6 +340,11 @@ bool WindowProperty::GetTokenState() const
return tokenState_;
}
DragType WindowProperty::GetDragType() const
{
return dragType_;
}
bool WindowProperty::MapMarshalling(Parcel& parcel) const
{
auto size = sysBarPropMap_.size();
@@ -384,7 +394,7 @@ bool WindowProperty::Marshalling(Parcel& parcel) const
parcel.WriteUint32(static_cast<uint32_t>(windowSizeChangeReason_)) && parcel.WriteBool(tokenState_) &&
parcel.WriteUint32(callingWindow_) && parcel.WriteUint32(static_cast<uint32_t>(requestedOrientation_)) &&
parcel.WriteBool(turnScreenOn_) && parcel.WriteBool(keepScreenOn_) &&
parcel.WriteUint32(modeSupportInfo_);
parcel.WriteUint32(modeSupportInfo_) && parcel.WriteUint32(static_cast<uint32_t>(dragType_));
}
WindowProperty* WindowProperty::Unmarshalling(Parcel& parcel)
@@ -426,6 +436,7 @@ WindowProperty* WindowProperty::Unmarshalling(Parcel& parcel)
property->SetTurnScreenOn(parcel.ReadBool());
property->SetKeepScreenOn(parcel.ReadBool());
property->SetModeSupportInfo(parcel.ReadUint32());
property->SetDragType(static_cast<DragType>(parcel.ReadUint32()));
return property;
}
@@ -461,6 +472,7 @@ void WindowProperty::CopyFrom(const sptr<WindowProperty>& property)
turnScreenOn_ = property->turnScreenOn_;
keepScreenOn_ = property->keepScreenOn_;
modeSupportInfo_ = property->modeSupportInfo_;
dragType_ = property->dragType_;
}
}
}
wm/include/window_impl.h
+2
View File
@@ -276,6 +276,7 @@ private:
void HandleModeChangeHotZones(int32_t posX, int32_t posY);
WMError NotifyWindowTransition(TransitionReason reason);
void UpdatePointerEventForStretchableWindow(std::shared_ptr<MMI::PointerEvent>& pointerEvent);
void UpdateDragType();
// colorspace, gamut
using ColorSpaceConvertMap = struct {
@@ -321,6 +322,7 @@ private:
Rect startPointRect_ = { 0, 0, 0, 0 };
Rect startRectExceptFrame_ = { 0, 0, 0, 0 };
Rect startRectExceptCorner_ = { 0, 0, 0, 0 };
DragType dragType_ = DragType::DRAG_UNDEFINED;
Rect originRect_ = {0, 0, 0, 0};
bool isAppDecorEnbale_ = true;
SystemConfig windowSystemConfig_ ;
wm/src/window_impl.cpp
+21
View File
@@ -1059,6 +1059,7 @@ WMError WindowImpl::Drag(const Rect& rect)
Rect requestRect = rect;
property_->SetRequestRect(requestRect);
property_->SetWindowSizeChangeReason(WindowSizeChangeReason::DRAG);
property_->SetDragType(dragType_);
return UpdateProperty(PropertyChangeAction::ACTION_UPDATE_RECT);
}
@@ -1636,6 +1637,23 @@ void WindowImpl::EndMoveOrDragWindow(int32_t posX, int32_t posY, int32_t pointId
pointEventStarted_ = false;
}
void WindowImpl::UpdateDragType()
{
if (!startDragFlag_) {
dragType_ = DragType::DRAG_UNDEFINED;
return;
}
if (startPointPosX_ > startRectExceptCorner_.posX_ &&
(startPointPosX_ < startRectExceptCorner_.posX_ + static_cast<int32_t>(startRectExceptCorner_.width_))) {
dragType_ = DragType::DRAG_HEIGHT;
} else if (startPointPosY_ > startRectExceptCorner_.posY_ &&
(startPointPosY_ < startRectExceptCorner_.posY_ + static_cast<int32_t>(startRectExceptCorner_.height_))) {
dragType_ = DragType::DRAG_WIDTH;
} else {
dragType_ = DragType::DRAG_CORNER;
}
}
void WindowImpl::ReadyToMoveOrDragWindow(int32_t globalX, int32_t globalY, int32_t pointId, const Rect& rect)
{
if (pointEventStarted_) {
@@ -1683,6 +1701,9 @@ void WindowImpl::ReadyToMoveOrDragWindow(int32_t globalX, int32_t globalY, int32
startDragFlag_ = true;
SingletonContainer::Get<WindowAdapter>().ProcessPointDown(property_->GetWindowId(), true);
}
UpdateDragType();
return;
}
wm/test/systemtest/window_layout_test.cpp
+16 -4
View File
@@ -33,6 +33,8 @@ public:
std::vector<sptr<Window>> activeWindows_;
static vector<Rect> fullScreenExpecteds_;
static inline float virtualPixelRatio_ = 0.0;
private:
static constexpr uint32_t WAIT_SYANC_US = 100000;
};
vector<Rect> WindowLayoutTest::fullScreenExpecteds_;
@@ -371,31 +373,34 @@ HWTEST_F(WindowLayoutTest, LayoutTile01, Function | MediumTest | Level3)
utils::InitTileWindowRects(window);
ASSERT_TRUE(utils::RectEqualTo(window, expect));
WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, utils::singleTileRect_));
info.name = "test1";
const sptr<Window>& test1 = utils::CreateTestWindow(info);
activeWindows_.push_back(test1);
ASSERT_EQ(WMError::WM_OK, test1->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, utils::doubleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test1, utils::doubleTileRects_[1]));
info.name = "test2";
const sptr<Window>& test2 = utils::CreateTestWindow(info);
activeWindows_.push_back(test2);
ASSERT_EQ(WMError::WM_OK, test2->Show());
usleep(WAIT_SYANC_US);
if (utils::isVerticalDisplay_) {
ASSERT_TRUE(utils::RectEqualTo(test1, utils::doubleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::doubleTileRects_[1]));
WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
return;
} else {
ASSERT_TRUE(utils::RectEqualTo(window, utils::tripleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test1, utils::tripleTileRects_[1]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::tripleTileRects_[2])); // 2 is second rect idx
}
ASSERT_TRUE(utils::RectEqualTo(window, utils::tripleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test1, utils::tripleTileRects_[1]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::tripleTileRects_[2])); // 2 is second rect idx
info.name = "test3";
const sptr<Window>& test3 = utils::CreateTestWindow(info);
activeWindows_.push_back(test3);
ASSERT_EQ(WMError::WM_OK, test3->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(test1, utils::tripleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::tripleTileRects_[1]));
ASSERT_TRUE(utils::RectEqualTo(test3, utils::tripleTileRects_[2])); // 2 is second rect idx
@@ -423,17 +428,20 @@ HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3)
ASSERT_EQ(WMError::WM_OK, window->Show());
utils::InitTileWindowRects(window);
WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, utils::singleTileRect_));
info.name = "test1";
const sptr<Window>& test1 = utils::CreateTestWindow(info);
activeWindows_.push_back(test1);
ASSERT_EQ(WMError::WM_OK, test1->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, utils::doubleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test1, utils::doubleTileRects_[1]));
info.name = "test2";
const sptr<Window>& test2 = utils::CreateTestWindow(info);
activeWindows_.push_back(test2);
ASSERT_EQ(WMError::WM_OK, test2->Show());
usleep(WAIT_SYANC_US);
if (utils::isVerticalDisplay_) {
ASSERT_TRUE(utils::RectEqualTo(test1, utils::doubleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::doubleTileRects_[1]));
@@ -448,6 +456,7 @@ HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3)
const sptr<Window>& test3 = utils::CreateTestWindow(info);
activeWindows_.push_back(test3);
ASSERT_EQ(WMError::WM_OK, test3->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(test1, utils::tripleTileRects_[0]));
ASSERT_TRUE(utils::RectEqualTo(test2, utils::tripleTileRects_[1]));
ASSERT_TRUE(utils::RectEqualTo(test3, utils::tripleTileRects_[2])); // 2 is second rect idx
@@ -474,6 +483,7 @@ HWTEST_F(WindowLayoutTest, LayoutNegative01, Function | MediumTest | Level3)
activeWindows_.push_back(window);
Rect expect = utils::GetDefaultFloatingRect(window);
ASSERT_EQ(WMError::WM_OK, window->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, expect));
}
@@ -499,8 +509,10 @@ HWTEST_F(WindowLayoutTest, LayoutNegative02, Function | MediumTest | Level3)
activeWindows_.push_back(window);
Rect expect = utils::GetDefaultFloatingRect(window);
ASSERT_EQ(WMError::WM_OK, window->Show());
usleep(WAIT_SYANC_US);
ASSERT_TRUE(utils::RectEqualTo(window, expect));
window->Resize(negativeW, negativeH);
usleep(WAIT_SYANC_US);
Rect expect2 = {expect.posX_, expect.posY_, negativeW, negativeH};
expect2 = utils::CalcLimitedRect(expect2, virtualPixelRatio_);
ASSERT_TRUE(utils::RectEqualTo(window, expect2));
wmserver/include/window_layout_policy.h
+18 -8
View File
@@ -59,27 +59,23 @@ public:
void ProcessDisplayCreate(DisplayId displayId, const std::map<DisplayId, Rect>& displayRectMap);
void ProcessDisplayDestroy(DisplayId displayId, const std::map<DisplayId, Rect>& displayRectMap);
void ProcessDisplaySizeChangeOrRotation(DisplayId displayId, const std::map<DisplayId, Rect>& displayRectMap);
void SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig);
protected:
void UpdateFloatingLayoutRect(Rect& limitRect, Rect& winRect);
void UpdateLimitRect(const sptr<WindowNode>& node, Rect& limitRect);
virtual void LayoutWindowNode(const sptr<WindowNode>& node);
AvoidPosType GetAvoidPosType(const Rect& rect, DisplayId displayId) const;
void CalcAndSetNodeHotZone(Rect layoutOutRect, const sptr<WindowNode>& node) const;
void LimitFloatingWindowSize(const sptr<WindowNode>& node, const Rect& displayRect, Rect& winRect) const;
void LimitMainFloatingWindowPositionWithDrag(const sptr<WindowNode>& node, Rect& winRect) const;
void LimitMainFloatingWindowPosition(const sptr<WindowNode>& node, Rect& winRect) const;
void CalcAndSetNodeHotZone(const Rect& winRect, const sptr<WindowNode>& node) const;
void ComputeDecoratedRequestRect(const sptr<WindowNode>& node) const;
bool IsVerticalDisplay(DisplayId displayId) const;
bool IsFullScreenRecentWindowExist(const std::vector<sptr<WindowNode>>& nodeVec) const;
void LayoutWindowNodesByRootType(const std::vector<sptr<WindowNode>>& nodeVec);
void UpdateSurfaceBounds(const sptr<WindowNode>& node, const Rect& winRect);
void UpdateRectInDisplayGroupForAllNodes(DisplayId displayId,
const Rect& oriDisplayRect,
const Rect& newDisplayRect);
const Rect& oriDisplayRect, const Rect& newDisplayRect);
void UpdateRectInDisplayGroup(const sptr<WindowNode>& node,
const Rect& oriDisplayRect,
const Rect& newDisplayRect);
const Rect& oriDisplayRect, const Rect& newDisplayRect);
void LimitWindowToBottomRightCorner(const sptr<WindowNode>& node);
void UpdateDisplayGroupRect();
void UpdateDisplayGroupLimitRect_();
@@ -87,6 +83,19 @@ protected:
void PostProcessWhenDisplayChange();
void UpdateDisplayRectAndDisplayGroupInfo(const std::map<DisplayId, Rect>& displayRectMap);
DockWindowShowState GetDockWindowShowState(DisplayId displayId, Rect& dockWinRect) const;
void LimitFloatingWindowSize(const sptr<WindowNode>& node, const Rect& displayRect, Rect& winRect) const;
void LimitMainFloatingWindowPosition(const sptr<WindowNode>& node, Rect& winRect) const;
void UpdateFloatingWindowSizeByCustomizedLimits(const sptr<WindowNode>& node,
const Rect& displayRect, Rect& winRect) const;
void UpdateFloatingWindowSizeBySystemLimits(const sptr<WindowNode>& node,
const Rect& displayRect, Rect& winRect) const;
void LimitWindowPositionWhenInitRectOrMove(const sptr<WindowNode>& node, Rect& winRect) const;
void LimitWindowPositionWhenDrag(const sptr<WindowNode>& node, Rect& winRect) const;
void FixWindowSizeByRatioIfDragBeyondLimitRegion(const sptr<WindowNode>& node, Rect& winRect,
const FloatingWindowLimitsConfig& limitConfig);
FloatingWindowLimitsConfig GetCustomizedLimitsConfig(const Rect& displayRect, float virtualPixelRatio);
FloatingWindowLimitsConfig GetSystemLimitsConfig(const Rect& displayRect, float virtualPixelRatio);
const std::set<WindowType> avoidTypes_ {
WindowType::WINDOW_TYPE_STATUS_BAR,
@@ -98,6 +107,7 @@ protected:
Rect displayGroupRect_;
Rect displayGroupLimitRect_;
bool isMultiDisplay_ = false;
FloatingWindowLimitsConfig floatingWindowLimitsConfig_;
};
}
}
wmserver/include/window_manager_config.h
+6 -3
View File
@@ -33,16 +33,19 @@ public:
static bool LoadConfigXml(const std::string& configFilePath);
static const std::map<std::string, bool>& GetEnableConfig();
static const std::map<std::string, std::vector<int>>& GetNumbersConfig();
static const std::map<std::string, std::vector<int>>& GetIntNumbersConfig();
static const std::map<std::string, std::vector<float>>& GetFloatNumbersConfig();
static void DumpConfig();
private:
static std::map<std::string, bool> enableConfig_;
static std::map<std::string, std::vector<int>> numbersConfig_;
static std::map<std::string, std::vector<int>> intNumbersConfig_;
static std::map<std::string, std::vector<float>> floatNumbersConfig_;
static bool IsValidNode(const xmlNode& currNode);
static void ReadEnableConfigInfo(const xmlNodePtr& currNode);
static void ReadNumbersConfigInfo(const xmlNodePtr& currNode);
static void ReadIntNumbersConfigInfo(const xmlNodePtr& currNode);
static void ReadFloatNumbersConfigInfo(const xmlNodePtr& currNode);
};
} // namespace Rosen
} // namespace OHOS
wmserver/include/window_node.h
+3
View File
@@ -69,6 +69,8 @@ public:
void SetRequestedOrientation(Orientation orientation);
void SetShowingDisplays(const std::vector<DisplayId>& displayIdVec);
void SetModeSupportInfo(uint32_t modeSupportInfo);
void SetDragType(DragType dragType);
const sptr<IWindow>& GetWindowToken() const;
uint32_t GetWindowId() const;
uint32_t GetParentId() const;
@@ -95,6 +97,7 @@ public:
Orientation GetRequestedOrientation() const;
std::vector<DisplayId> GetShowingDisplays() const;
uint32_t GetModeSupportInfo() const;
DragType GetDragType() const;
void ResetWindowSizeChangeReason();
sptr<WindowNode> parent_;
wmserver/include/window_root.h
+3 -1
View File
@@ -85,6 +85,7 @@ public:
uint32_t GetWindowIdByObject(const sptr<IRemoteObject>& remoteObject);
sptr<WindowNode> GetWindowForDumpAceHelpInfo() const;
void DestroyLeakStartingWindow();
void SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig);
private:
void OnRemoteDied(const sptr<IRemoteObject>& remoteObject);
WMError DestroyWindowInner(sptr<WindowNode>& node);
@@ -98,7 +99,7 @@ private:
void NotifyKeyboardSizeChangeInfo(const sptr<WindowNode>& node,
const sptr<WindowNodeContainer>& container, Rect rect);
ScreenId GetScreenGroupId(DisplayId displayId, bool& isRecordedDisplay);
void ProcessExpandDisplayCreate(DisplayId displayId, ScreenId screenGroupId);
void ProcessExpandDisplayCreate(DisplayId displayId, ScreenId displayGroupId);
std::map<DisplayId, sptr<DisplayInfo>> GetAllDisplayInfos(const std::vector<DisplayId>& displayIdVec);
std::map<DisplayId, Rect> GetAllDisplayRects(const std::vector<DisplayId>& displayIdVec);
void MoveNotShowingWindowToDefaultDisplay(DisplayId displayId);
@@ -117,6 +118,7 @@ private:
this, std::placeholders::_1));
Callback callback_;
int maxAppWindowNumber_ = 100;
FloatingWindowLimitsConfig floatingWindowLimitsConfig_;
};
}
}
wmserver/src/window_controller.cpp
+1
View File
@@ -723,6 +723,7 @@ WMError WindowController::UpdateProperty(sptr<WindowProperty>& property, Propert
switch (action) {
case PropertyChangeAction::ACTION_UPDATE_RECT: {
node->SetDecoStatus(property->GetDecoStatus());
node->SetDragType(property->GetDragType());
return ResizeRect(windowId, property->GetRequestRect(), property->GetWindowSizeChangeReason());
}
case PropertyChangeAction::ACTION_UPDATE_MODE: {
wmserver/src/window_layout_policy.cpp
+357 -102
View File
@@ -415,9 +415,9 @@ void WindowLayoutPolicy::ComputeDecoratedRequestRect(const sptr<WindowNode>& nod
property->SetDecoStatus(true);
}
void WindowLayoutPolicy::CalcAndSetNodeHotZone(Rect layoutOutRect, const sptr<WindowNode>& node) const
void WindowLayoutPolicy::CalcAndSetNodeHotZone(const Rect& winRect, const sptr<WindowNode>& node) const
{
Rect rect = layoutOutRect;
Rect rect = winRect;
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t hotZone = static_cast<uint32_t>(HOTZONE * virtualPixelRatio);
@@ -440,33 +440,361 @@ void WindowLayoutPolicy::CalcAndSetNodeHotZone(Rect layoutOutRect, const sptr<Wi
node->SetHotZoneRect(rect);
}
void WindowLayoutPolicy::FixWindowSizeByRatioIfDragBeyondLimitRegion(const sptr<WindowNode>& node, Rect& winRect,
const FloatingWindowLimitsConfig& limitConfig)
{
if (limitConfig.maxWidth_ == limitConfig.minWidth_ &&
limitConfig.maxHeight_ == limitConfig.minHeight_) {
WLOGFI("window rect can not be changed");
return;
}
float curRatio = static_cast<float>(winRect.width_) / static_cast<float>(winRect.height_);
if (limitConfig.minRatio_ <= curRatio && curRatio <= limitConfig.maxRatio_) {
WLOGFI("window ratio is satisfied with limit ratio, curRatio: %{public}f", curRatio);
return;
}
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
Rect limitRect = isMultiDisplay_ ? displayGroupLimitRect_ : limitRectMap_[node->GetDisplayId()];
int32_t limitMinPosX = limitRect.posX_ + static_cast<int32_t>(windowTitleBarH);
int32_t limitMaxPosX = limitRect.posX_ + static_cast<int32_t>(limitRect.width_ - windowTitleBarH);
int32_t limitMinPosY = limitRect.posY_;
int32_t limitMaxPosY = limitRect.posY_ + static_cast<int32_t>(limitRect.height_ - windowTitleBarH);
Rect dockWinRect;
DockWindowShowState dockShownState = GetDockWindowShowState(node->GetDisplayId(), dockWinRect);
if (dockShownState == DockWindowShowState::SHOWN_IN_BOTTOM) {
WLOGFD("dock window show in bottom");
limitMaxPosY = dockWinRect.posY_ - static_cast<int32_t>(windowTitleBarH);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_LEFT) {
WLOGFD("dock window show in left");
limitMinPosX = dockWinRect.posX_ + static_cast<int32_t>(dockWinRect.width_ + windowTitleBarH);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_RIGHT) {
WLOGFD("dock window show in right");
limitMaxPosX = dockWinRect.posX_ - static_cast<int32_t>(windowTitleBarH);
}
float newRatio = curRatio < limitConfig.minRatio_ ? limitConfig.minRatio_ : limitConfig.maxRatio_;
if ((winRect.posX_ + static_cast<int32_t>(winRect.width_) == limitMinPosX) || (winRect.posX_ == limitMaxPosX)) {
// height can not be changed
if (limitConfig.maxHeight_ == limitConfig.minHeight_) {
return;
}
winRect.height_ = static_cast<uint32_t>(static_cast<float>(winRect.width_) / newRatio);
}
if ((winRect.posY_ == limitMinPosY) || (winRect.posX_ == limitMaxPosY)) {
// width can not be changed
if (limitConfig.maxWidth_ == limitConfig.minWidth_) {
return;
}
winRect.width_ = static_cast<uint32_t>(static_cast<float>(winRect.height_) * newRatio);
}
WLOGFI("After limit by ratio if beyond limit region, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
}
FloatingWindowLimitsConfig WindowLayoutPolicy::GetSystemLimitsConfig(const Rect& displayRect, float virtualPixelRatio)
{
FloatingWindowLimitsConfig limitConfig;
limitConfig.maxWidth_ = static_cast<uint32_t>(MAX_FLOATING_SIZE * virtualPixelRatio);
limitConfig.maxHeight_ = static_cast<uint32_t>(MAX_FLOATING_SIZE * virtualPixelRatio);
limitConfig.minWidth_ = static_cast<uint32_t>(MIN_VERTICAL_FLOATING_WIDTH * virtualPixelRatio);
limitConfig.minHeight_ = static_cast<uint32_t>(MIN_VERTICAL_FLOATING_HEIGHT * virtualPixelRatio);
if (displayRect.width_ > displayRect.height_) {
std::swap(limitConfig.minWidth_, limitConfig.minHeight_);
}
WLOGFI("maxWidth: %{public}u, maxHeight: %{public}u, minWidth: %{public}u, minHeight: %{public}u "
"maxRatio: %{public}f, minRatio: %{public}f", limitConfig.maxWidth_, limitConfig.maxHeight_,
limitConfig.minWidth_, limitConfig.minHeight_, limitConfig.maxRatio_, limitConfig.minRatio_);
return limitConfig;
}
FloatingWindowLimitsConfig WindowLayoutPolicy::GetCustomizedLimitsConfig(const Rect& displayRect,
float virtualPixelRatio)
{
const auto& systemLimits = GetSystemLimitsConfig(displayRect, virtualPixelRatio);
FloatingWindowLimitsConfig newLimitConfig = systemLimits;
// configured limits of floating window
uint32_t configuredMaxWidth = static_cast<uint32_t>(floatingWindowLimitsConfig_.maxWidth_ * virtualPixelRatio);
uint32_t configuredMaxHeight = static_cast<uint32_t>(floatingWindowLimitsConfig_.maxHeight_ * virtualPixelRatio);
uint32_t configuredMinWidth = static_cast<uint32_t>(floatingWindowLimitsConfig_.minWidth_ * virtualPixelRatio);
uint32_t configuredMinHeight = static_cast<uint32_t>(floatingWindowLimitsConfig_.minHeight_ * virtualPixelRatio);
float configuerdMaxRatio = floatingWindowLimitsConfig_.maxRatio_;
float configuerdMinRatio = floatingWindowLimitsConfig_.minRatio_;
// calculate new limit size
if (systemLimits.minWidth_ <= configuredMaxWidth && configuredMaxWidth <= systemLimits.maxWidth_) {
newLimitConfig.maxWidth_ = configuredMaxWidth;
}
if (systemLimits.minHeight_ <= configuredMaxHeight && configuredMaxHeight <= systemLimits.maxHeight_) {
newLimitConfig.maxHeight_ = configuredMaxHeight;
}
if (systemLimits.minWidth_ <= configuredMinWidth && configuredMinWidth <= newLimitConfig.maxWidth_) {
newLimitConfig.minWidth_ = configuredMinWidth;
}
if (systemLimits.minHeight_ <= configuredMinHeight && configuredMinHeight <= newLimitConfig.maxHeight_) {
newLimitConfig.minHeight_ = configuredMinHeight;
}
// calculate new limit ratio
newLimitConfig.maxRatio_ = static_cast<float>(newLimitConfig.maxWidth_) /
static_cast<float>(newLimitConfig.minHeight_);
newLimitConfig.minRatio_ = static_cast<float>(newLimitConfig.minWidth_) /
static_cast<float>(newLimitConfig.maxHeight_);
if (newLimitConfig.minRatio_ <= configuerdMaxRatio && configuerdMaxRatio <= newLimitConfig.maxRatio_) {
newLimitConfig.maxRatio_ = configuerdMaxRatio;
}
if (newLimitConfig.minRatio_ <= configuerdMinRatio && configuerdMinRatio <= newLimitConfig.maxRatio_) {
newLimitConfig.minRatio_ = configuerdMinRatio;
}
// recalculate limit size by new ratio
uint32_t newMaxWidth = static_cast<uint32_t>(static_cast<float>(newLimitConfig.maxHeight_) *
newLimitConfig.maxRatio_);
newLimitConfig.maxWidth_ = std::min(newMaxWidth, newLimitConfig.maxWidth_);
uint32_t newMinWidth = static_cast<uint32_t>(static_cast<float>(newLimitConfig.minHeight_) *
newLimitConfig.minRatio_);
newLimitConfig.minWidth_ = std::max(newMinWidth, newLimitConfig.minWidth_);
uint32_t newMaxHeight = static_cast<uint32_t>(static_cast<float>(newLimitConfig.maxWidth_) /
newLimitConfig.minRatio_);
newLimitConfig.maxHeight_ = std::min(newMaxHeight, newLimitConfig.maxHeight_);
uint32_t newMinHeight = static_cast<uint32_t>(static_cast<float>(newLimitConfig.minWidth_) /
newLimitConfig.maxRatio_);
newLimitConfig.minHeight_ = std::max(newMinHeight, newLimitConfig.minHeight_);
WLOGFI("maxWidth: %{public}u, maxHeight: %{public}u, minWidth: %{public}u, minHeight: %{public}u, "
"maxRatio: %{public}f, minRatio: %{public}f", newLimitConfig.maxWidth_, newLimitConfig.maxHeight_,
newLimitConfig.minWidth_, newLimitConfig.minHeight_, newLimitConfig.maxRatio_, newLimitConfig.minRatio_);
return newLimitConfig;
}
void WindowLayoutPolicy::UpdateFloatingWindowSizeByCustomizedLimits(const sptr<WindowNode>& node,
const Rect& displayRect, Rect& winRect) const
{
// get new limit config with the settings of system and app
const auto& customizedLimits = const_cast<WindowLayoutPolicy*>(this)->
GetCustomizedLimitsConfig(displayRect, GetVirtualPixelRatio(node->GetDisplayId()));
// limit minimum and maximum size of floating (not system type) window
winRect.width_ = std::max(customizedLimits.minWidth_, winRect.width_);
winRect.height_ = std::max(customizedLimits.minHeight_, winRect.height_);
winRect.width_ = std::min(customizedLimits.maxWidth_, winRect.width_);
winRect.height_ = std::min(customizedLimits.maxHeight_, winRect.height_);
WLOGFD("After limit by size, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
// width and height can not be changed
if (customizedLimits.maxWidth_ == customizedLimits.minWidth_ &&
customizedLimits.maxHeight_ == customizedLimits.minHeight_) {
winRect.width_ = customizedLimits.maxWidth_;
winRect.height_ = customizedLimits.maxHeight_;
WLOGFD("window rect can not be changed");
return;
}
float curRatio = static_cast<float>(winRect.width_) / static_cast<float>(winRect.height_);
if ((customizedLimits.minWidth_ <= winRect.width_ && winRect.width_ <= customizedLimits.maxWidth_) &&
(customizedLimits.minHeight_ <= winRect.height_ && winRect.height_ <= customizedLimits.maxHeight_) &&
(customizedLimits.minRatio_ <= curRatio && curRatio <= customizedLimits.maxRatio_)) {
WLOGFD("window size and ratio is satisfied with limit ratio, curSize: [%{public}d, %{public}d], "
"curRatio: %{public}f", winRect.width_, winRect.height_, curRatio);
return;
}
float newRatio = curRatio < customizedLimits.minRatio_ ? customizedLimits.minRatio_ : customizedLimits.maxRatio_;
if (customizedLimits.maxWidth_ == customizedLimits.minWidth_) {
winRect.height_ = static_cast<uint32_t>(static_cast<float>(winRect.width_) / newRatio);
return;
}
if (customizedLimits.maxHeight_ == customizedLimits.minHeight_) {
winRect.width_ = static_cast<uint32_t>(static_cast<float>(winRect.height_) * newRatio);
return;
}
auto dragType = node->GetDragType();
if (dragType == DragType::DRAG_HEIGHT) {
// if drag height, use height to fix size.
winRect.width_ = static_cast<uint32_t>(static_cast<float>(winRect.height_) * newRatio);
} else {
// if drag width or corner, use width to fix size.
winRect.height_ = static_cast<uint32_t>(static_cast<float>(winRect.width_) / newRatio);
}
WLOGFI("After limit by customize config, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
}
void WindowLayoutPolicy::UpdateFloatingWindowSizeBySystemLimits(const sptr<WindowNode>& node,
const Rect& displayRect, Rect& winRect) const
{
const auto& systemLimits = const_cast<WindowLayoutPolicy*>(this)->
GetSystemLimitsConfig(displayRect, GetVirtualPixelRatio(node->GetDisplayId()));
// limit minimum size of floating (not system type) window
if (!WindowHelper::IsSystemWindow(node->GetWindowType())) {
winRect.width_ = std::max(systemLimits.minWidth_, winRect.width_);
winRect.height_ = std::max(systemLimits.minHeight_, winRect.height_);
}
// limit maximum size of all floating window
winRect.width_ = std::min(systemLimits.maxWidth_, winRect.width_);
winRect.height_ = std::min(systemLimits.maxHeight_, winRect.height_);
WLOGFI("After limit by system config, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
}
void WindowLayoutPolicy::LimitFloatingWindowSize(const sptr<WindowNode>& node,
const Rect& displayRect,
Rect& winRect) const
{
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t minVerticalFloatingW = static_cast<uint32_t>(MIN_VERTICAL_FLOATING_WIDTH * virtualPixelRatio);
uint32_t minVerticalFloatingH = static_cast<uint32_t>(MIN_VERTICAL_FLOATING_HEIGHT * virtualPixelRatio);
WindowType windowType = node->GetWindowType();
WindowMode windowMode = node->GetWindowMode();
bool isVertical = (displayRect.height_ > displayRect.width_) ? true : false;
if (windowMode == WindowMode::WINDOW_MODE_FLOATING) {
// limit minimum size of floating (not system type) window
if (!WindowHelper::IsSystemWindow(windowType)) {
if (isVertical) {
winRect.width_ = std::max(minVerticalFloatingW, winRect.width_);
winRect.height_ = std::max(minVerticalFloatingH, winRect.height_);
} else {
winRect.width_ = std::max(minVerticalFloatingH, winRect.width_);
winRect.height_ = std::max(minVerticalFloatingW, winRect.height_);
}
}
// limit maximum size of all floating window
winRect.width_ = std::min(static_cast<uint32_t>(MAX_FLOATING_SIZE * virtualPixelRatio), winRect.width_);
winRect.height_ = std::min(static_cast<uint32_t>(MAX_FLOATING_SIZE * virtualPixelRatio), winRect.height_);
if (node->GetWindowMode() != WindowMode::WINDOW_MODE_FLOATING) {
return;
}
Rect oriWinRect = winRect;
if (floatingWindowLimitsConfig_.isFloatingWindowLimitsConfigured_ &&
(WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode()))) {
UpdateFloatingWindowSizeByCustomizedLimits(node, displayRect, winRect);
} else {
UpdateFloatingWindowSizeBySystemLimits(node, displayRect, winRect);
}
// fix size in case of moving window when dragging
const auto& lastWinRect = node->GetWindowRect();
if (node->GetWindowSizeChangeReason() == WindowSizeChangeReason::DRAG) {
if (oriWinRect.posX_ != lastWinRect.posX_) {
winRect.posX_ = oriWinRect.posX_ + static_cast<int32_t>(oriWinRect.width_) -
static_cast<int32_t>(winRect.width_);
}
if (oriWinRect.posY_ != lastWinRect.posY_) {
winRect.posY_ = oriWinRect.posY_ + static_cast<int32_t>(oriWinRect.height_) -
static_cast<int32_t>(winRect.height_);
}
}
}
void WindowLayoutPolicy::LimitMainFloatingWindowPosition(const sptr<WindowNode>& node, Rect& winRect) const
{
if (!WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode())) {
return;
}
auto reason = node->GetWindowSizeChangeReason();
// if drag or move window, limit size and position
if (reason == WindowSizeChangeReason::DRAG) {
LimitWindowPositionWhenDrag(node, winRect);
if (floatingWindowLimitsConfig_.isFloatingWindowLimitsConfigured_ &&
(WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode()))) {
const auto& limitConfig = const_cast<WindowLayoutPolicy*>(this)-> GetCustomizedLimitsConfig(
displayGroupInfo_->GetDisplayRect(node->GetDisplayId()), GetVirtualPixelRatio(node->GetDisplayId()));
const_cast<WindowLayoutPolicy*>(this)->
FixWindowSizeByRatioIfDragBeyondLimitRegion(node, winRect, limitConfig);
}
} else {
// Limit window position, such as init window rect when show
LimitWindowPositionWhenInitRectOrMove(node, winRect);
}
}
void WindowLayoutPolicy::LimitWindowPositionWhenDrag(const sptr<WindowNode>& node,
Rect& winRect) const
{
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
const Rect& lastRect = node->GetWindowRect();
Rect oriWinRect = winRect;
Rect limitRect = isMultiDisplay_ ? displayGroupLimitRect_ : limitRectMap_[node->GetDisplayId()];
int32_t limitMinPosX = limitRect.posX_ + static_cast<int32_t>(windowTitleBarH);
int32_t limitMaxPosX = limitRect.posX_ + static_cast<int32_t>(limitRect.width_ - windowTitleBarH);
int32_t limitMinPosY = limitRect.posY_;
int32_t limitMaxPosY = limitRect.posY_ + static_cast<int32_t>(limitRect.height_ - windowTitleBarH);
Rect dockWinRect;
DockWindowShowState dockShownState = GetDockWindowShowState(node->GetDisplayId(), dockWinRect);
if (dockShownState == DockWindowShowState::SHOWN_IN_BOTTOM) {
WLOGFD("dock window show in bottom");
limitMaxPosY = dockWinRect.posY_ - static_cast<int32_t>(windowTitleBarH);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_LEFT) {
WLOGFD("dock window show in left");
limitMinPosX = dockWinRect.posX_ + static_cast<int32_t>(dockWinRect.width_ + windowTitleBarH);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_RIGHT) {
WLOGFD("dock window show in right");
limitMaxPosX = dockWinRect.posX_ - static_cast<int32_t>(windowTitleBarH);
}
// limitMinPosX is minimum (x + width)
if (oriWinRect.posX_ + static_cast<int32_t>(oriWinRect.width_) < limitMinPosX) {
if (oriWinRect.width_ != lastRect.width_) {
winRect.width_ = static_cast<uint32_t>(limitMinPosX - oriWinRect.posX_);
}
}
// maximum position x
if (oriWinRect.posX_ > limitMaxPosX) {
winRect.posX_ = limitMaxPosX;
if (oriWinRect.width_ != lastRect.width_) {
winRect.width_ = oriWinRect.posX_ + static_cast<int32_t>(oriWinRect.width_) - winRect.posX_;
}
}
// minimum position y
if (oriWinRect.posY_ < limitMinPosY) {
winRect.posY_ = limitMinPosY;
if (oriWinRect.height_ != lastRect.height_) {
winRect.height_ = oriWinRect.posY_ + static_cast<int32_t>(oriWinRect.height_) - winRect.posY_;
}
}
// maximum position y
if (winRect.posY_ > limitMaxPosY) {
winRect.posY_ = limitMaxPosY;
if (oriWinRect.height_ != lastRect.height_) {
winRect.height_ = oriWinRect.posY_ + static_cast<int32_t>(oriWinRect.height_) - winRect.posY_;
}
}
WLOGFI("After limit by position, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
}
void WindowLayoutPolicy::LimitWindowPositionWhenInitRectOrMove(const sptr<WindowNode>& node, Rect& winRect) const
{
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
Rect limitRect;
// if is corss-display window, the limit rect should be full limitRect
if (node->isShowingOnMultiDisplays_) {
limitRect = displayGroupLimitRect_;
} else {
limitRect = limitRectMap_[node->GetDisplayId()];
}
// limit position of the main floating window(window which support dragging)
if (WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode())) {
Rect dockWinRect;
DockWindowShowState dockShownState = GetDockWindowShowState(node->GetDisplayId(), dockWinRect);
winRect.posY_ = std::max(limitRect.posY_, winRect.posY_);
winRect.posY_ = std::min(limitRect.posY_ + static_cast<int32_t>(limitRect.height_ - windowTitleBarH),
winRect.posY_);
if (dockShownState == DockWindowShowState::SHOWN_IN_BOTTOM) {
WLOGFD("dock window show in bottom");
winRect.posY_ = std::min(dockWinRect.posY_ + static_cast<int32_t>(dockWinRect.height_ - windowTitleBarH),
winRect.posY_);
}
winRect.posX_ = std::max(limitRect.posX_ + static_cast<int32_t>(windowTitleBarH - winRect.width_),
winRect.posX_);
if (dockShownState == DockWindowShowState::SHOWN_IN_LEFT) {
WLOGFD("dock window show in left");
winRect.posX_ = std::max(static_cast<int32_t>(dockWinRect.width_ + windowTitleBarH - winRect.width_),
winRect.posX_);
}
winRect.posX_ = std::min(limitRect.posX_ + static_cast<int32_t>(limitRect.width_ - windowTitleBarH),
winRect.posX_);
if (dockShownState == DockWindowShowState::SHOWN_IN_RIGHT) {
WLOGFD("dock window show in right");
winRect.posX_ = std::min(dockWinRect.posX_ - static_cast<int32_t>(windowTitleBarH),
winRect.posX_);
}
}
WLOGFI("After limit by position if init or move, winRect: %{public}d %{public}d %{public}u %{public}u",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
}
DockWindowShowState WindowLayoutPolicy::GetDockWindowShowState(DisplayId displayId, Rect& dockWinRect) const
@@ -501,84 +829,6 @@ DockWindowShowState WindowLayoutPolicy::GetDockWindowShowState(DisplayId display
return DockWindowShowState::NOT_SHOWN;
}
void WindowLayoutPolicy::LimitMainFloatingWindowPositionWithDrag(const sptr<WindowNode>& node, Rect& winRect) const
{
if (WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode())) {
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
const Rect lastRect = node->GetWindowRect();
// fix rect in case of moving window when dragging
winRect = WindowHelper::GetFixedWindowRectByLimitSize(winRect, lastRect,
IsVerticalDisplay(node->GetDisplayId()), virtualPixelRatio);
// if is mutiDisplay, the limit rect should be full limitRect when move or drag
Rect limitRect;
if (isMultiDisplay_) {
limitRect = displayGroupLimitRect_;
} else {
limitRect = limitRectMap_[node->GetDisplayId()];
}
winRect = WindowHelper::GetFixedWindowRectByLimitPosition(winRect, lastRect,
virtualPixelRatio, limitRect);
Rect dockWinRect;
DockWindowShowState dockShownState = GetDockWindowShowState(node->GetDisplayId(), dockWinRect);
if (dockShownState == DockWindowShowState::SHOWN_IN_BOTTOM) {
WLOGFI("dock window show in bottom");
winRect.posY_ = std::min(dockWinRect.posY_ - static_cast<int32_t>(windowTitleBarH), winRect.posY_);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_LEFT) {
WLOGFI("dock window show in left");
winRect.posX_ = std::max(static_cast<int32_t>(dockWinRect.width_ + windowTitleBarH - winRect.width_),
winRect.posX_);
} else if (dockShownState == DockWindowShowState::SHOWN_IN_RIGHT) {
WLOGFI("dock window show in right");
winRect.posX_ = std::min(dockWinRect.posX_ - static_cast<int32_t>(windowTitleBarH),
winRect.posX_);
}
}
}
void WindowLayoutPolicy::LimitMainFloatingWindowPosition(const sptr<WindowNode>& node, Rect& winRect) const
{
float virtualPixelRatio = GetVirtualPixelRatio(node->GetDisplayId());
uint32_t windowTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
Rect limitRect;
// if is corss-display window, the limit rect should be full limitRect
if (node->isShowingOnMultiDisplays_) {
limitRect = displayGroupLimitRect_;
} else {
limitRect = limitRectMap_[node->GetDisplayId()];
}
// limit position of the main floating window(window which support dragging)
if (WindowHelper::IsMainFloatingWindow(node->GetWindowType(), node->GetWindowMode())) {
Rect dockWinRect;
DockWindowShowState dockShownState = GetDockWindowShowState(node->GetDisplayId(), dockWinRect);
winRect.posY_ = std::max(limitRect.posY_, winRect.posY_);
winRect.posY_ = std::min(limitRect.posY_ + static_cast<int32_t>(limitRect.height_ - windowTitleBarH),
winRect.posY_);
if (dockShownState == DockWindowShowState::SHOWN_IN_BOTTOM) {
WLOGFI("dock window show in bottom");
winRect.posY_ = std::min(dockWinRect.posY_ + static_cast<int32_t>(dockWinRect.height_ - windowTitleBarH),
winRect.posY_);
}
winRect.posX_ = std::max(limitRect.posX_ + static_cast<int32_t>(windowTitleBarH - winRect.width_),
winRect.posX_);
if (dockShownState == DockWindowShowState::SHOWN_IN_LEFT) {
WLOGFI("dock window show in left");
winRect.posX_ = std::max(static_cast<int32_t>(dockWinRect.width_ + windowTitleBarH - winRect.width_),
winRect.posX_);
}
winRect.posX_ = std::min(limitRect.posX_ + static_cast<int32_t>(limitRect.width_ - windowTitleBarH),
winRect.posX_);
if (dockShownState == DockWindowShowState::SHOWN_IN_RIGHT) {
WLOGFI("dock window show in right");
winRect.posX_ = std::min(dockWinRect.posX_ - static_cast<int32_t>(windowTitleBarH),
winRect.posX_);
}
}
}
AvoidPosType WindowLayoutPolicy::GetAvoidPosType(const Rect& rect, DisplayId displayId) const
{
const auto& displayRectMap = displayGroupInfo_->GetAllDisplayRects();
@@ -676,5 +926,10 @@ Rect WindowLayoutPolicy::GetDisplayGroupRect() const
{
return displayGroupRect_;
}
void WindowLayoutPolicy::SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig)
{
floatingWindowLimitsConfig_ = floatingWindowLimitsConfig;
}
}
}
wmserver/src/window_layout_policy_cascade.cpp
+2 -10
View File
@@ -247,20 +247,12 @@ void WindowLayoutPolicyCascade::ApplyWindowRectConstraints(const sptr<WindowNode
{
WLOGFI("Before apply constraints winRect:[%{public}d, %{public}d, %{public}u, %{public}u]",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
auto reason = node->GetWindowSizeChangeReason();
if (node->GetWindowType() == WindowType::WINDOW_TYPE_DOCK_SLICE) { // if divider, limit position
LimitMoveBounds(winRect, node->GetDisplayId());
}
// if drag or move window, limit size and position
if (reason == WindowSizeChangeReason::DRAG || reason == WindowSizeChangeReason::MOVE) {
LimitMainFloatingWindowPositionWithDrag(node, winRect);
} else {
// Limit window to the maximum window size if size change is other reason, such as init window rect when show
LimitFloatingWindowSize(node, displayGroupInfo_->GetDisplayRect(node->GetDisplayId()), winRect);
LimitMainFloatingWindowPosition(node, winRect);
}
LimitFloatingWindowSize(node, displayGroupInfo_->GetDisplayRect(node->GetDisplayId()), winRect);
LimitMainFloatingWindowPosition(node, winRect);
WLOGFI("After apply constraints winRect:[%{public}d, %{public}d, %{public}u, %{public}u]",
winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
wmserver/src/window_manager_config.cpp
+55 -10
View File
@@ -24,7 +24,8 @@ namespace {
}
std::map<std::string, bool> WindowManagerConfig::enableConfig_;
std::map<std::string, std::vector<int>> WindowManagerConfig::numbersConfig_;
std::map<std::string, std::vector<int>> WindowManagerConfig::intNumbersConfig_;
std::map<std::string, std::vector<float>> WindowManagerConfig::floatNumbersConfig_;
bool WindowManagerConfig::LoadConfigXml(const std::string& configFilePath)
{
@@ -57,8 +58,14 @@ bool WindowManagerConfig::LoadConfigXml(const std::string& configFilePath)
continue;
}
if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("maxAppWindowNumber")) ||
!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("modeChangeHotZones"))) {
ReadNumbersConfigInfo(curNodePtr);
!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("modeChangeHotZones")) ||
!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("floatingWindowLimitSize"))) {
ReadIntNumbersConfigInfo(curNodePtr);
continue;
}
if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("floatingWindowLimitRatio"))) {
ReadFloatNumbersConfigInfo(curNodePtr);
continue;
}
}
@@ -91,7 +98,7 @@ void WindowManagerConfig::ReadEnableConfigInfo(const xmlNodePtr& currNode)
xmlFree(enable);
}
void WindowManagerConfig::ReadNumbersConfigInfo(const xmlNodePtr& currNode)
void WindowManagerConfig::ReadIntNumbersConfigInfo(const xmlNodePtr& currNode)
{
xmlChar* context = xmlNodeGetContent(currNode);
if (context == nullptr) {
@@ -104,15 +111,41 @@ void WindowManagerConfig::ReadNumbersConfigInfo(const xmlNodePtr& currNode)
auto numbers = WindowHelper::Split(numbersStr, " ");
for (auto& num : numbers) {
if (!WindowHelper::IsNumber(num)) {
WLOGFE("[WmConfig] read number error: nodeName:(%{public}s)", currNode->name);
WLOGFE("[WmConfig] read int number error: nodeName:(%{public}s)", currNode->name);
xmlFree(context);
return;
}
numbersVec.emplace_back(std::stoi(num));
}
std::string nodeName = reinterpret_cast<const char *>(currNode->name);
numbersConfig_[nodeName] = numbersVec;
intNumbersConfig_[nodeName] = numbersVec;
xmlFree(context);
}
void WindowManagerConfig::ReadFloatNumbersConfigInfo(const xmlNodePtr& currNode)
{
xmlChar* context = xmlNodeGetContent(currNode);
if (context == nullptr) {
WLOGFE("[WmConfig] read xml node error: nodeName:(%{public}s)", currNode->name);
return;
}
std::vector<float> numbersVec;
std::string numbersStr = reinterpret_cast<const char*>(context);
auto numbers = WindowHelper::Split(numbersStr, " ");
for (auto& num : numbers) {
if (!WindowHelper::IsFloatingNumber(num)) {
WLOGFE("[WmConfig] read float number error: nodeName:(%{public}s)", currNode->name);
xmlFree(context);
return;
}
numbersVec.emplace_back(std::stof(num));
}
std::string nodeName = reinterpret_cast<const char *>(currNode->name);
floatNumbersConfig_[nodeName] = numbersVec;
xmlFree(context);
}
@@ -121,9 +154,14 @@ const std::map<std::string, bool>& WindowManagerConfig::GetEnableConfig()
return enableConfig_;
}
const std::map<std::string, std::vector<int>>& WindowManagerConfig::GetNumbersConfig()
const std::map<std::string, std::vector<int>>& WindowManagerConfig::GetIntNumbersConfig()
{
return numbersConfig_;
return intNumbersConfig_;
}
const std::map<std::string, std::vector<float>>& WindowManagerConfig::GetFloatNumbersConfig()
{
return floatNumbersConfig_;
}
void WindowManagerConfig::DumpConfig()
@@ -132,12 +170,19 @@ void WindowManagerConfig::DumpConfig()
WLOGFI("[WmConfig] Enable: %{public}s %{public}u", enable.first.c_str(), enable.second);
}
for (auto& numbers : numbersConfig_) {
WLOGFI("[WmConfig] Numbers: %{public}s %{public}zu", numbers.first.c_str(), numbers.second.size());
for (auto& numbers : intNumbersConfig_) {
WLOGFI("[WmConfig] Int numbers: %{public}s %{public}zu", numbers.first.c_str(), numbers.second.size());
for (auto& num : numbers.second) {
WLOGFI("[WmConfig] Num: %{public}d", num);
}
}
for (auto& numbers : floatNumbersConfig_) {
WLOGFI("[WmConfig] Float numbers: %{public}s %{public}zu", numbers.first.c_str(), numbers.second.size());
for (auto& num : numbers.second) {
WLOGFI("[WmConfig] Num: %{public}f", num);
}
}
}
} // namespace Rosen
} // namespace OHOS
wmserver/src/window_manager_service.cpp
+30 -5
View File
@@ -195,7 +195,8 @@ int WindowManagerService::Dump(int fd, const std::vector<std::u16string>& args)
void WindowManagerService::ConfigureWindowManagerService()
{
const auto& enableConfig = WindowManagerConfig::GetEnableConfig();
const auto& numbersConfig = WindowManagerConfig::GetNumbersConfig();
const auto& intNumbersConfig = WindowManagerConfig::GetIntNumbersConfig();
const auto& floatNumbersConfig = WindowManagerConfig::GetFloatNumbersConfig();
if (enableConfig.count("decor") != 0) {
systemConfig_.isSystemDecorEnable_ = enableConfig.at("decor");
@@ -209,15 +210,15 @@ void WindowManagerService::ConfigureWindowManagerService()
systemConfig_.isStretchable_ = enableConfig.at("stretchable");
}
if (numbersConfig.count("maxAppWindowNumber") != 0) {
auto numbers = numbersConfig.at("maxAppWindowNumber");
if (intNumbersConfig.count("maxAppWindowNumber") != 0) {
auto numbers = intNumbersConfig.at("maxAppWindowNumber");
if (numbers.size() == 1) {
windowRoot_->SetMaxAppWindowNumber(numbers[0]);
}
}
if (numbersConfig.count("modeChangeHotZones") != 0) {
auto numbers = numbersConfig.at("modeChangeHotZones");
if (intNumbersConfig.count("modeChangeHotZones") != 0) {
auto numbers = intNumbersConfig.at("modeChangeHotZones");
if (numbers.size() == 3) { // 3 hot zones
hotZonesConfig_.fullscreenRange_ = static_cast<uint32_t>(numbers[0]); // 0 fullscreen
hotZonesConfig_.primaryRange_ = static_cast<uint32_t>(numbers[1]); // 1 primary
@@ -225,6 +226,30 @@ void WindowManagerService::ConfigureWindowManagerService()
hotZonesConfig_.isModeChangeHotZoneConfigured_ = true;
}
}
FloatingWindowLimitsConfig floatingWindowLimitsConfig;
if (intNumbersConfig.count("floatingWindowLimitSize") != 0) {
auto numbers = intNumbersConfig.at("floatingWindowLimitSize");
if (numbers.size() == 4) { // 4, limitSize
floatingWindowLimitsConfig.maxWidth_ = static_cast<uint32_t>(numbers[0]); // 0 max width
floatingWindowLimitsConfig.maxHeight_ = static_cast<uint32_t>(numbers[1]); // 1 max height
floatingWindowLimitsConfig.minWidth_ = static_cast<uint32_t>(numbers[2]); // 2 min width
floatingWindowLimitsConfig.minHeight_ = static_cast<uint32_t>(numbers[3]); // 3 min height
floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
}
}
if (floatNumbersConfig.count("floatingWindowLimitRatio") != 0) {
auto numbers = floatNumbersConfig.at("floatingWindowLimitRatio");
if (numbers.size() == 2) { // 2, limitRatio
floatingWindowLimitsConfig.maxRatio_ = static_cast<float>(numbers[0]); // 0 max ratio
floatingWindowLimitsConfig.minRatio_ = static_cast<float>(numbers[1]); // 1 min ratio
floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
}
}
windowRoot_->SetFloatingWindowLimitsConfig(floatingWindowLimitsConfig);
}
void WindowManagerService::OnStop()
wmserver/src/window_node.cpp
+10
View File
@@ -188,6 +188,16 @@ void WindowNode::SetCallingUid(int32_t uid)
callingUid_ = uid;
}
void WindowNode::SetDragType(DragType dragType)
{
property_->SetDragType(dragType);
}
DragType WindowNode::GetDragType() const
{
return property_->GetDragType();
}
DisplayId WindowNode::GetDisplayId() const
{
return property_->GetDisplayId();
wmserver/src/window_root.cpp
+10
View File
@@ -97,6 +97,11 @@ sptr<WindowNodeContainer> WindowRoot::CreateWindowNodeContainer(DisplayId displa
windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
std::vector<DisplayId> displayVec = { displayId };
displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
if (container == nullptr) {
WLOGFE("create container failed, displayId :%{public}" PRIu64 "", displayId);
return nullptr;
}
container->GetLayoutPolicy()->SetFloatingWindowLimitsConfig(floatingWindowLimitsConfig_);
return container;
}
@@ -1157,5 +1162,10 @@ WMError WindowRoot::GetModeChangeHotZones(DisplayId displayId,
container->GetModeChangeHotZones(displayId, hotZones, config);
return WMError::WM_OK;
}
void WindowRoot::SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig)
{
floatingWindowLimitsConfig_ = floatingWindowLimitsConfig;
}
} // namespace Rosen
} // namespace OHOS