blob: b211315fc9ca0c97d991b01993559d1fe0cd4d51 (
plain)
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
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/aura/mus/focus_synchronizer.h"
#include "base/auto_reset.h"
#include "services/ui/public/interfaces/window_tree.mojom.h"
#include "ui/aura/client/focus_client.h"
#include "ui/aura/env.h"
#include "ui/aura/mus/focus_synchronizer_delegate.h"
#include "ui/aura/mus/window_mus.h"
#include "ui/aura/window.h"
namespace aura {
FocusSynchronizer::FocusSynchronizer(FocusSynchronizerDelegate* delegate,
ui::mojom::WindowTree* window_tree)
: delegate_(delegate), window_tree_(window_tree) {
Env::GetInstance()->AddObserver(this);
}
FocusSynchronizer::~FocusSynchronizer() {
SetActiveFocusClient(nullptr);
Env::GetInstance()->RemoveObserver(this);
}
void FocusSynchronizer::SetFocusFromServer(WindowMus* window) {
if (focused_window_ == window)
return;
DCHECK(!setting_focus_);
base::AutoReset<bool> focus_reset(&setting_focus_, true);
base::AutoReset<WindowMus*> window_setting_focus_to_reset(
&window_setting_focus_to_, window);
Env* env = Env::GetInstance();
if (window) {
Window* root = window->GetWindow()->GetRootWindow();
// The client should provide a focus client for all roots.
DCHECK(client::GetFocusClient(root));
if (env->active_focus_client_root() != root)
env->SetActiveFocusClient(client::GetFocusClient(root), root);
window->GetWindow()->Focus();
} else if (env->active_focus_client()) {
env->active_focus_client()->FocusWindow(nullptr);
}
}
void FocusSynchronizer::OnFocusedWindowDestroyed() {
focused_window_ = nullptr;
}
void FocusSynchronizer::SetActiveFocusClient(
client::FocusClient* focus_client) {
if (focus_client == active_focus_client_)
return;
if (active_focus_client_)
active_focus_client_->RemoveObserver(this);
active_focus_client_ = focus_client;
if (active_focus_client_)
active_focus_client_->AddObserver(this);
}
void FocusSynchronizer::SetFocusedWindow(WindowMus* window) {
const uint32_t change_id = delegate_->CreateChangeIdForFocus(focused_window_);
focused_window_ = window;
window_tree_->SetFocus(change_id,
window ? window->server_id() : kInvalidServerId);
}
void FocusSynchronizer::OnWindowFocused(Window* gained_focus,
Window* lost_focus) {
WindowMus* gained_focus_mus = WindowMus::Get(gained_focus);
if (setting_focus_ && gained_focus_mus == window_setting_focus_to_) {
focused_window_ = gained_focus_mus;
return;
}
SetFocusedWindow(gained_focus_mus);
}
void FocusSynchronizer::OnWindowInitialized(Window* window) {}
void FocusSynchronizer::OnActiveFocusClientChanged(
client::FocusClient* focus_client,
Window* window) {
SetActiveFocusClient(focus_client);
if (setting_focus_)
return;
if (focus_client) {
Window* focused_window = focus_client->GetFocusedWindow();
SetFocusedWindow(focused_window ? WindowMus::Get(focused_window)
: WindowMus::Get(window));
} else {
SetFocusedWindow(nullptr);
}
}
} // namespace aura
|
