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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
// 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.
#ifndef UI_GTK_GTK_UI_H_
#define UI_GTK_GTK_UI_H_
#include <array>
#include <map>
#include <memory>
#include <optional>
#include <unordered_map>
#include <vector>
#include "base/containers/fixed_flat_map.h"
#include "base/memory/raw_ptr.h"
#include "printing/buildflags/buildflags.h"
#include "ui/base/glib/scoped_gsignal.h"
#include "ui/color/color_provider.h"
#include "ui/color/color_provider_key.h"
#include "ui/gfx/color_utils.h"
#include "ui/gfx/font_render_params.h"
#include "ui/gtk/gtk_ui_platform.h"
#include "ui/linux/linux_ui.h"
#include "ui/linux/window_frame_provider.h"
#include "ui/views/window/frame_buttons.h"
#if BUILDFLAG(ENABLE_PRINTING)
#include "printing/printing_context_linux.h" // nogncheck
#endif
typedef struct _GParamSpec GParamSpec;
typedef struct _GdkDisplay GdkDisplay;
typedef struct _GdkMonitor GdkMonitor;
typedef struct _GtkParamSpec GtkParamSpec;
typedef struct _GtkSettings GtkSettings;
typedef struct _GtkStyle GtkStyle;
namespace gtk {
using ColorMap = std::map<int, SkColor>;
class GtkKeyBindingsHandler;
class NativeThemeGtk;
class SettingsProvider;
// Interface to GTK desktop features.
class GtkUi : public ui::LinuxUiAndTheme {
public:
GtkUi();
GtkUi(const GtkUi&) = delete;
GtkUi& operator=(const GtkUi&) = delete;
~GtkUi() override;
// Static delegate getter, used by different objects (created by GtkUi), e.g:
// Dialogs, IME Context, when platform-specific functionality is required.
static GtkUiPlatform* GetPlatform();
// Setters used by SettingsProvider:
void SetWindowButtonOrdering(
const std::vector<views::FrameButton>& leading_buttons,
const std::vector<views::FrameButton>& trailing_buttons);
void SetWindowFrameAction(WindowFrameActionSource source,
WindowFrameAction action);
// ui::LinuxUi:
bool Initialize() override;
void InitializeFontSettings() override;
base::TimeDelta GetCursorBlinkInterval() const override;
gfx::Image GetIconForContentType(const std::string& content_type,
int size,
float scale) const override;
base::flat_map<std::string, std::string> GetKeyboardLayoutMap() override;
#if BUILDFLAG(ENABLE_PRINTING)
printing::PrintDialogLinuxInterface* CreatePrintDialog(
printing::PrintingContextLinux* context) override;
gfx::Size GetPdfPaperSize(printing::PrintingContextLinux* context) override;
#endif
ui::SelectFileDialog* CreateSelectFileDialog(
void* listener,
std::unique_ptr<ui::SelectFilePolicy> policy) const override;
std::string GetCursorThemeName() override;
int GetCursorThemeSize() override;
std::unique_ptr<ui::LinuxInputMethodContext> CreateInputMethodContext(
ui::LinuxInputMethodContextDelegate* delegate) const override;
ui::TextEditCommand GetTextEditCommandForEvent(const ui::Event& event,
int text_flags) override;
gfx::FontRenderParams GetDefaultFontRenderParams() override;
bool AnimationsEnabled() const override;
void AddWindowButtonOrderObserver(
ui::WindowButtonOrderObserver* observer) override;
void RemoveWindowButtonOrderObserver(
ui::WindowButtonOrderObserver* observer) override;
WindowFrameAction GetWindowFrameAction(
WindowFrameActionSource source) override;
std::vector<std::string> GetCmdLineFlagsForCopy() const override;
// ui::LinuxUiTheme:
ui::NativeTheme* GetNativeTheme() const override;
bool GetColor(int id, SkColor* color, bool use_custom_frame) const override;
bool GetDisplayProperty(int id, int* result) const override;
void GetFocusRingColor(SkColor* color) const override;
void GetActiveSelectionBgColor(SkColor* color) const override;
void GetActiveSelectionFgColor(SkColor* color) const override;
void GetInactiveSelectionBgColor(SkColor* color) const override;
void GetInactiveSelectionFgColor(SkColor* color) const override;
bool PreferDarkTheme() const override;
void SetDarkTheme(bool dark) override;
void SetAccentColor(std::optional<SkColor> accent_color) override;
std::unique_ptr<ui::NavButtonProvider> CreateNavButtonProvider() override;
ui::WindowFrameProvider* GetWindowFrameProvider(bool solid_frame,
bool tiled,
bool maximized) override;
private:
using TintMap = std::map<int, color_utils::HSL>;
void OnThemeChanged(GtkSettings* settings, GtkParamSpec* param);
void OnCursorThemeNameChanged(GtkSettings* settings, GtkParamSpec* param);
void OnCursorThemeSizeChanged(GtkSettings* settings, GtkParamSpec* param);
void OnEnableAnimationsChanged(GtkSettings* settings, GtkParamSpec* param);
void OnGtkXftDpiChanged(GtkSettings* settings, GParamSpec* param);
void OnScreenResolutionChanged(GdkScreen* screen, GParamSpec* param);
void OnMonitorChanged(GdkMonitor* monitor, GParamSpec* param);
void OnMonitorAdded(GdkDisplay* display, GdkMonitor* monitor);
void OnMonitorRemoved(GdkDisplay* display, GdkMonitor* monitor);
void OnMonitorsChanged(GListModel* list,
guint position,
guint removed,
guint added);
// Loads all GTK-provided settings.
void LoadGtkValues();
// Extracts colors and tints from the GTK theme, both for the
// ThemeService interface and the colors we send to Blink.
void UpdateColors();
// Listen for scale factor changes on `monitor`.
void TrackMonitor(GdkMonitor* monitor);
// Updates the device scale factor so that the default font size can be
// recalculated.
void UpdateDeviceScaleFactor();
display::DisplayConfig GetDisplayConfig() const;
void AddGtkNativeColorMixer(ui::ColorProvider* provider,
const ui::ColorProviderKey& key);
std::unique_ptr<GtkUiPlatform> platform_;
raw_ptr<NativeThemeGtk> native_theme_;
// Colors calculated by LoadGtkValues() that are given to the
// caller while |use_gtk_| is true.
ColorMap colors_;
// Frame colors (and colors that depend on frame colors) when using
// Chrome-rendered borders and titlebar.
ColorMap custom_frame_colors_;
// Frame colors (and colors that depend on frame colors) when using
// system-rendered borders and titlebar.
ColorMap native_frame_colors_;
// Colors that we pass to Blink. These are generated each time the theme
// changes.
SkColor focus_ring_color_;
SkColor active_selection_bg_color_;
SkColor active_selection_fg_color_;
SkColor inactive_selection_bg_color_;
SkColor inactive_selection_fg_color_;
std::optional<SkColor> accent_color_;
std::optional<gfx::FontRenderParams> default_font_render_params_;
std::unique_ptr<SettingsProvider> settings_provider_;
// This is only used on GTK3.
std::unique_ptr<GtkKeyBindingsHandler> key_bindings_handler_;
// The action to take when middle, double, or right clicking the titlebar.
base::flat_map<WindowFrameActionSource, WindowFrameAction>
window_frame_actions_;
// Paints a native window frame. Typically only one of these will be
// non-null. The exception is when the user starts or stops their compositor
// while Chrome is running. This 3D array is indexed first by whether the
// frame is translucent (0) or solid(1), then by whether the frame is normal
// (0) or tiled (1), then by whether the frame is maximized (0) or not (1).
std::array<
std::array<std::array<std::unique_ptr<ui::WindowFrameProvider>, 2>, 2>,
2>
frame_providers_;
// Objects to notify when the window frame button order changes.
base::ObserverList<ui::WindowButtonOrderObserver>::Unchecked
window_button_order_observer_list_;
std::vector<ScopedGSignal> signals_;
// Two signals are registered for each monitor, so keep them in a pair.
std::unordered_map<GdkMonitor*, std::pair<ScopedGSignal, ScopedGSignal>>
monitor_signals_;
};
} // namespace gtk
#endif // UI_GTK_GTK_UI_H_
|
