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
|
// Copyright 2013 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/wm/core/transient_window_stacking_client.h"
#include <stddef.h>
#include <algorithm>
#include "ui/aura/client/transient_window_client.h"
#include "ui/wm/core/transient_window_manager.h"
#include "ui/wm/core/window_util.h"
using aura::Window;
namespace wm {
namespace {
// Populates |ancestors| with all transient ancestors of |window| that are
// siblings of |window|. Returns true if any ancestors were found, false if not.
bool GetAllTransientAncestors(Window* window, Window::Windows* ancestors) {
Window* parent = window->parent();
for (; window; window = GetTransientParent(window)) {
if (window->parent() == parent)
ancestors->push_back(window);
}
return (!ancestors->empty());
}
// Replaces |window1| and |window2| with their possible transient ancestors that
// are still siblings (have a common transient parent). |window1| and |window2|
// are not modified if such ancestors cannot be found.
void FindCommonTransientAncestor(Window** window1, Window** window2) {
DCHECK(window1);
DCHECK(window2);
DCHECK(*window1);
DCHECK(*window2);
// Assemble chains of ancestors of both windows.
Window::Windows ancestors1;
Window::Windows ancestors2;
if (!GetAllTransientAncestors(*window1, &ancestors1) ||
!GetAllTransientAncestors(*window2, &ancestors2)) {
return;
}
// Walk the two chains backwards and look for the first difference.
auto it1 = ancestors1.rbegin();
auto it2 = ancestors2.rbegin();
for (; it1 != ancestors1.rend() && it2 != ancestors2.rend(); ++it1, ++it2) {
if (*it1 != *it2) {
*window1 = *it1;
*window2 = *it2;
break;
}
}
}
} // namespace
// static
TransientWindowStackingClient* TransientWindowStackingClient::instance_ = NULL;
TransientWindowStackingClient::TransientWindowStackingClient() {
instance_ = this;
}
TransientWindowStackingClient::~TransientWindowStackingClient() {
if (instance_ == this)
instance_ = NULL;
}
bool TransientWindowStackingClient::AdjustStacking(
Window** child,
Window** target,
Window::StackDirection* direction) {
const TransientWindowManager* transient_manager =
TransientWindowManager::GetIfExists(*child);
if (transient_manager && transient_manager->IsStackingTransient(*target))
return true;
// For windows that have transient children stack the transient ancestors that
// are siblings. This prevents one transient group from being inserted in the
// middle of another.
FindCommonTransientAncestor(child, target);
// When stacking above skip to the topmost transient descendant of the target.
if (*direction == Window::STACK_ABOVE &&
!HasTransientAncestor(*child, *target)) {
const Window::Windows& siblings((*child)->parent()->children());
size_t target_i = std::ranges::find(siblings, *target) - siblings.begin();
while (target_i + 1 < siblings.size() &&
HasTransientAncestor(siblings[target_i + 1], *target)) {
++target_i;
}
*target = siblings[target_i];
}
return *child != *target;
}
} // namespace wm
|
