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
126
127
128
129
130
131
132
|
// 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/notimplemented.h"
#include "base/notreached.h"
#include "third_party/skia/include/core/SkPath.h"
#include "ui/base/owned_window_anchor.h"
#include "ui/gfx/display_color_spaces.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;
}
void PlatformWindowDelegate::OnDisplayColorSpacesChanged(
scoped_refptr<gfx::DisplayColorSpacesRef> color_spaces) {
NOTIMPLEMENTED_LOG_ONCE();
}
} // namespace ui
|
