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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_WM_CORE_WINDOW_UTIL_H_
#define UI_WM_CORE_WINDOW_UTIL_H_
#include <memory>
#include <utility>
#include <vector>
#include "base/component_export.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "ui/base/mojom/window_show_state.mojom-forward.h"
#include "ui/display/types/display_constants.h"
namespace aura {
class Window;
}
namespace ui {
class Layer;
class LayerOwner;
class LayerTreeOwner;
} // namespace ui
namespace wm {
COMPONENT_EXPORT(UI_WM) void ActivateWindow(aura::Window* window);
COMPONENT_EXPORT(UI_WM) void DeactivateWindow(aura::Window* window);
COMPONENT_EXPORT(UI_WM) bool IsActiveWindow(const aura::Window* window);
COMPONENT_EXPORT(UI_WM) bool CanActivateWindow(const aura::Window* window);
COMPONENT_EXPORT(UI_WM)
void SetWindowFullscreen(
aura::Window* window,
bool fullscreen,
int64_t target_display_id = display::kInvalidDisplayId);
// Returns true if |window|'s show state is |state|.
COMPONENT_EXPORT(UI_WM)
bool WindowStateIs(const aura::Window* window,
ui::mojom::WindowShowState state);
// Returns |window|'s current show state.
COMPONENT_EXPORT(UI_WM)
ui::mojom::WindowShowState GetWindowState(const aura::Window* window);
// Sets the window state to |state|.
COMPONENT_EXPORT(UI_WM)
void SetWindowState(aura::Window* window, ui::mojom::WindowShowState state);
// Restores the window state from the current state to its previous applicable
// state. As an example, if the current state is minimized, Restore() will
// change the window's sate to its applicable pre-minimized state, which is the
// same as calling Unminimize() function.
COMPONENT_EXPORT(UI_WM) void Restore(aura::Window* window);
// Changes a window's state to its pre-minimized state.
COMPONENT_EXPORT(UI_WM) void Unminimize(aura::Window* window);
// Retrieves the activatable window for |window|. If |window| is activatable,
// this will just return it, otherwise it will climb the parent/transient parent
// chain looking for a window that is activatable, per the ActivationClient.
// If you're looking for a function to get the activatable "top level" window,
// this is probably the function you're looking for.
COMPONENT_EXPORT(UI_WM)
aura::Window* GetActivatableWindow(aura::Window* window);
// Retrieves the toplevel window for |window|. The ActivationClient makes this
// determination.
COMPONENT_EXPORT(UI_WM) aura::Window* GetToplevelWindow(aura::Window* window);
COMPONENT_EXPORT(UI_WM)
const aura::Window* GetToplevelWindow(const aura::Window* window);
// Returns the existing Layer for |root| (and all its descendants) and creates
// a new layer for |root| and all its descendants. This is intended for
// animations that want to animate between the existing visuals and a new state.
//
// As a result of this |root| has freshly created layers, meaning the layers
// have not yet been painted to.
COMPONENT_EXPORT(UI_WM)
std::unique_ptr<ui::LayerTreeOwner> RecreateLayers(ui::LayerOwner* root);
using MapLayerFunc =
base::RepeatingCallback<std::unique_ptr<ui::Layer>(ui::LayerOwner*)>;
// Maps |map_func| over each layer of the layer tree and returns a copy of the
// layer tree. The recursion stops at the level when |map_func| returns nullptr
// on the owner's layer. MapLayers might return nullptr when |map_func| returns
// nullptr on the root layer's owner.
COMPONENT_EXPORT(UI_WM)
std::unique_ptr<ui::LayerTreeOwner> RecreateLayersWithClosure(
ui::LayerOwner* root,
const MapLayerFunc& map_func);
// Returns a layer tree that mirrors |root|. Used for live window previews. If
// |sync_bounds| is true, the bounds of all mirror layers except the root are
// synchronized. See |sync_bounds_with_source_| in ui::Layer.
COMPONENT_EXPORT(UI_WM)
std::unique_ptr<ui::LayerTreeOwner> MirrorLayers(ui::LayerOwner* root,
bool sync_bounds);
// Convenience functions that get the TransientWindowManager for the window and
// redirect appropriately. These are preferable to calling functions on
// TransientWindowManager as they handle the appropriate null checks.
COMPONENT_EXPORT(UI_WM) aura::Window* GetTransientParent(aura::Window* window);
COMPONENT_EXPORT(UI_WM)
const aura::Window* GetTransientParent(const aura::Window* window);
COMPONENT_EXPORT(UI_WM)
const std::vector<raw_ptr<aura::Window, VectorExperimental>>&
GetTransientChildren(const aura::Window* window);
COMPONENT_EXPORT(UI_WM)
void AddTransientChild(aura::Window* parent, aura::Window* child);
COMPONENT_EXPORT(UI_WM)
void RemoveTransientChild(aura::Window* parent, aura::Window* child);
COMPONENT_EXPORT(UI_WM) aura::Window* GetTransientRoot(aura::Window* window);
// Returns true if |window| has |ancestor| as a transient ancestor. A transient
// ancestor is found by following the transient parent chain of the window.
COMPONENT_EXPORT(UI_WM)
bool HasTransientAncestor(const aura::Window* window,
const aura::Window* ancestor);
// Snap the window's layer to physical pixel boundary.
COMPONENT_EXPORT(UI_WM) void SnapWindowToPixelBoundary(aura::Window* window);
} // namespace wm
#endif // UI_WM_CORE_WINDOW_UTIL_H_
|
