1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/platform_window/platform_window_delegate.h"
#include <sstream>
#include "base/notreached.h"
#include "third_party/skia/include/core/SkPath.h"
#include "ui/base/owned_window_anchor.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/size.h"
namespace ui {
bool PlatformWindowDelegate::State::WillProduceFrameOnUpdateFrom(
const State& old) const {
// None of the following changes will produce a new frame:
// - bounds origin and fullscreen type: no relayout scheduled.
// - ui scale: does not imply in a new frame per-se, though inherently implies
// in bounds_dip and/or size_px change. See its declaration for further
// explanation.
//
// Anything else will produce a frame, except for the occlusion state. We do
// not check that here since there isn't enough information to determine if
// it will produce a frame, as it depends on whether native occlusion is
// enabled and if the ui compositor changes visibility.
//
// Note: Changing the window state produces a new frame as
// OnWindowStateChanged will schedule relayout even without the bounds change.
return old.window_state != window_state ||
old.bounds_dip.size() != bounds_dip.size() || old.size_px != size_px ||
old.window_scale != window_scale;
}
std::string PlatformWindowDelegate::State::ToString() const {
std::stringstream result;
result << "State {";
result << "window_state = " << static_cast<int>(window_state);
result << ", bounds_dip = " << bounds_dip.ToString();
result << ", size_px = " << size_px.ToString();
result << ", window_scale = " << window_scale;
result << ", ui_scale = " << ui_scale;
result << ", occlusion_state = " << static_cast<int>(occlusion_state);
result << "}";
return result.str();
}
PlatformWindowDelegate::PlatformWindowDelegate() = default;
PlatformWindowDelegate::~PlatformWindowDelegate() = default;
gfx::Insets PlatformWindowDelegate::CalculateInsetsInDIP(
PlatformWindowState window_state) const {
return gfx::Insets();
}
#if BUILDFLAG(IS_LINUX)
void PlatformWindowDelegate::OnWindowTiledStateChanged(
WindowTiledEdges new_tiled_edges) {}
#endif
std::optional<gfx::Size> PlatformWindowDelegate::GetMinimumSizeForWindow()
const {
return std::nullopt;
}
std::optional<gfx::Size> PlatformWindowDelegate::GetMaximumSizeForWindow()
const {
return std::nullopt;
}
bool PlatformWindowDelegate::CanMaximize() const {
return false;
}
bool PlatformWindowDelegate::CanFullscreen() const {
return false;
}
SkPath PlatformWindowDelegate::GetWindowMaskForWindowShapeInPixels() {
return SkPath();
}
void PlatformWindowDelegate::OnOcclusionStateChanged(
PlatformWindowOcclusionState occlusion_state) {}
int64_t PlatformWindowDelegate::OnStateUpdate(const State& old,
const State& latest) {
NOTREACHED();
}
std::optional<OwnedWindowAnchor>
PlatformWindowDelegate::GetOwnedWindowAnchorAndRectInDIP() {
return std::nullopt;
}
bool PlatformWindowDelegate::OnRotateFocus(
PlatformWindowDelegate::RotateDirection direction,
bool reset) {
return false;
}
gfx::Rect PlatformWindowDelegate::ConvertRectToPixels(
const gfx::Rect& rect_in_dip) const {
return rect_in_dip;
}
gfx::Rect PlatformWindowDelegate::ConvertRectToDIP(
const gfx::Rect& rect_in_pixels) const {
return rect_in_pixels;
}
gfx::PointF PlatformWindowDelegate::ConvertScreenPointToLocalDIP(
const gfx::Point& screen_in_pixels) const {
return gfx::PointF(screen_in_pixels);
}
gfx::Insets PlatformWindowDelegate::ConvertInsetsToPixels(
const gfx::Insets& insets_dip) const {
return insets_dip;
}
} // namespace ui
|
