mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-13 10:06:28 +01:00
047e8f9349
- Building on macOS now requires the 10.15 SDK. Xcode 11.3 is recommended as Xcode 11.4 is not currently supported (see https://crbug.com/1065146). - Jumbo build configuration is no longer supported. Chromium is skipping the M82 release and consequently no CEF 4085 branch will be created. For details on the Chromium decision see https://groups.google.com/a/chromium.org/d/msg/chromium-dev/Vn7uzglqLz0/JItlSrZxBAAJ
476 lines
16 KiB
C++
476 lines
16 KiB
C++
// Copyright 2014 The Chromium Embedded Framework Authors.
|
|
// Portions copyright 2014 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 "libcef/browser/native/window_x11.h"
|
|
#include "libcef/browser/thread_util.h"
|
|
|
|
#include "ui/base/x/x11_util.h"
|
|
#include "ui/events/platform/platform_event_source.h"
|
|
#include "ui/events/x/x11_event_translation.h"
|
|
#include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
|
|
#include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
|
|
|
|
#include <X11/Xatom.h>
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
#include <X11/extensions/XInput2.h>
|
|
|
|
namespace {
|
|
|
|
const char kAtom[] = "ATOM";
|
|
const char kWMDeleteWindow[] = "WM_DELETE_WINDOW";
|
|
const char kWMProtocols[] = "WM_PROTOCOLS";
|
|
const char kNetWMName[] = "_NET_WM_NAME";
|
|
const char kNetWMPid[] = "_NET_WM_PID";
|
|
const char kNetWMPing[] = "_NET_WM_PING";
|
|
const char kNetWMState[] = "_NET_WM_STATE";
|
|
const char kXdndProxy[] = "XdndProxy";
|
|
const char kUTF8String[] = "UTF8_STRING";
|
|
|
|
::Window FindChild(::Display* display, ::Window window) {
|
|
::Window root;
|
|
::Window parent;
|
|
::Window* children;
|
|
::Window child_window = x11::None;
|
|
unsigned int nchildren;
|
|
if (XQueryTree(display, window, &root, &parent, &children, &nchildren) &&
|
|
nchildren == 1) {
|
|
child_window = children[0];
|
|
XFree(children);
|
|
}
|
|
return child_window;
|
|
}
|
|
|
|
::Window FindToplevelParent(::Display* display, ::Window window) {
|
|
::Window top_level_window = window;
|
|
::Window root = x11::None;
|
|
::Window parent = x11::None;
|
|
::Window* children = nullptr;
|
|
unsigned int nchildren = 0;
|
|
// Enumerate all parents of "window" to find the highest level window
|
|
// that either:
|
|
// - has a parent that does not contain the _NET_WM_PID property
|
|
// - has a parent that is the root window.
|
|
while (XQueryTree(display, window, &root, &parent, &children, &nchildren)) {
|
|
if (children) {
|
|
XFree(children);
|
|
}
|
|
|
|
top_level_window = window;
|
|
if (!ui::PropertyExists(parent, kNetWMPid) || parent == root) {
|
|
break;
|
|
}
|
|
window = parent;
|
|
}
|
|
return top_level_window;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
CEF_EXPORT XDisplay* cef_get_xdisplay() {
|
|
if (!CEF_CURRENTLY_ON(CEF_UIT))
|
|
return nullptr;
|
|
return gfx::GetXDisplay();
|
|
}
|
|
|
|
CefWindowX11::CefWindowX11(CefRefPtr<CefBrowserHostImpl> browser,
|
|
::Window parent_xwindow,
|
|
const gfx::Rect& bounds,
|
|
const std::string& title)
|
|
: browser_(browser),
|
|
xdisplay_(gfx::GetXDisplay()),
|
|
parent_xwindow_(parent_xwindow),
|
|
xwindow_(0),
|
|
window_mapped_(false),
|
|
bounds_(bounds),
|
|
focus_pending_(false),
|
|
weak_ptr_factory_(this) {
|
|
if (parent_xwindow_ == x11::None)
|
|
parent_xwindow_ = DefaultRootWindow(xdisplay_);
|
|
|
|
XSetWindowAttributes swa;
|
|
memset(&swa, 0, sizeof(swa));
|
|
swa.background_pixmap = x11::None;
|
|
swa.override_redirect = false;
|
|
xwindow_ = XCreateWindow(xdisplay_, parent_xwindow_, bounds.x(), bounds.y(),
|
|
bounds.width(), bounds.height(),
|
|
0, // border width
|
|
CopyFromParent, // depth
|
|
InputOutput,
|
|
CopyFromParent, // visual
|
|
CWBackPixmap | CWOverrideRedirect, &swa);
|
|
CHECK(xwindow_);
|
|
|
|
DCHECK(ui::X11EventSource::HasInstance());
|
|
ui::X11EventSource::GetInstance()->AddXEventDispatcher(this);
|
|
|
|
long event_mask = FocusChangeMask | StructureNotifyMask | PropertyChangeMask;
|
|
XSelectInput(xdisplay_, xwindow_, event_mask);
|
|
XFlush(xdisplay_);
|
|
|
|
// TODO(erg): We currently only request window deletion events. We also
|
|
// should listen for activation events and anything else that GTK+ listens
|
|
// for, and do something useful.
|
|
::Atom protocols[2];
|
|
protocols[0] = gfx::GetAtom(kWMDeleteWindow);
|
|
protocols[1] = gfx::GetAtom(kNetWMPing);
|
|
XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
|
|
|
|
// We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
|
|
// the desktop environment.
|
|
XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
|
|
|
|
// Likewise, the X server needs to know this window's pid so it knows which
|
|
// program to kill if the window hangs.
|
|
// XChangeProperty() expects "pid" to be long.
|
|
static_assert(sizeof(long) >= sizeof(pid_t),
|
|
"pid_t should not be larger than long");
|
|
long pid = getpid();
|
|
XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom(kNetWMPid), XA_CARDINAL, 32,
|
|
PropModeReplace, reinterpret_cast<unsigned char*>(&pid), 1);
|
|
|
|
// Set the initial window name, if provided.
|
|
if (!title.empty()) {
|
|
XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom(kNetWMName),
|
|
gfx::GetAtom(kUTF8String), 8, PropModeReplace,
|
|
reinterpret_cast<const unsigned char*>(title.c_str()),
|
|
title.size());
|
|
}
|
|
}
|
|
|
|
CefWindowX11::~CefWindowX11() {
|
|
DCHECK(!xwindow_);
|
|
DCHECK(ui::X11EventSource::HasInstance());
|
|
ui::X11EventSource::GetInstance()->RemoveXEventDispatcher(this);
|
|
}
|
|
|
|
void CefWindowX11::Close() {
|
|
XEvent ev = {0};
|
|
ev.xclient.type = ClientMessage;
|
|
ev.xclient.window = xwindow_;
|
|
ev.xclient.message_type = gfx::GetAtom(kWMProtocols);
|
|
ev.xclient.format = 32;
|
|
ev.xclient.data.l[0] = gfx::GetAtom(kWMDeleteWindow);
|
|
ev.xclient.data.l[1] = x11::CurrentTime;
|
|
XSendEvent(xdisplay_, xwindow_, false, NoEventMask, &ev);
|
|
|
|
auto host = GetHost();
|
|
if (host)
|
|
host->Close();
|
|
}
|
|
|
|
void CefWindowX11::Show() {
|
|
if (xwindow_ == x11::None)
|
|
return;
|
|
|
|
if (!window_mapped_) {
|
|
// Before we map the window, set size hints. Otherwise, some window managers
|
|
// will ignore toplevel XMoveWindow commands.
|
|
XSizeHints size_hints;
|
|
size_hints.flags = PPosition | PWinGravity;
|
|
size_hints.x = bounds_.x();
|
|
size_hints.y = bounds_.y();
|
|
// Set StaticGravity so that the window position is not affected by the
|
|
// frame width when running with window manager.
|
|
size_hints.win_gravity = StaticGravity;
|
|
XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
|
|
|
|
XMapWindow(xdisplay_, xwindow_);
|
|
|
|
// TODO(thomasanderson): Find out why this flush is necessary.
|
|
XFlush(xdisplay_);
|
|
window_mapped_ = true;
|
|
|
|
// Setup the drag and drop proxy on the top level window of the application
|
|
// to be the child of this window.
|
|
::Window child = FindChild(xdisplay_, xwindow_);
|
|
::Window toplevel_window = FindToplevelParent(xdisplay_, xwindow_);
|
|
DCHECK(toplevel_window);
|
|
if (child && toplevel_window) {
|
|
// Configure the drag&drop proxy property for the top-most window so
|
|
// that all drag&drop-related messages will be sent to the child
|
|
// DesktopWindowTreeHostX11. The proxy property is referenced by
|
|
// DesktopDragDropClientAuraX11::FindWindowFor.
|
|
::Window proxy_target = gfx::kNullAcceleratedWidget;
|
|
ui::GetXIDProperty(toplevel_window, kXdndProxy, &proxy_target);
|
|
|
|
if (proxy_target != child) {
|
|
// Set the proxy target for the top-most window.
|
|
XChangeProperty(xdisplay_, toplevel_window, gfx::GetAtom(kXdndProxy),
|
|
XA_WINDOW, 32, PropModeReplace,
|
|
reinterpret_cast<unsigned char*>(&child), 1);
|
|
// Do the same for the proxy target per the spec.
|
|
XChangeProperty(xdisplay_, child, gfx::GetAtom(kXdndProxy), XA_WINDOW,
|
|
32, PropModeReplace,
|
|
reinterpret_cast<unsigned char*>(&child), 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CefWindowX11::Hide() {
|
|
if (xwindow_ == x11::None)
|
|
return;
|
|
|
|
if (window_mapped_) {
|
|
XWithdrawWindow(xdisplay_, xwindow_, 0);
|
|
window_mapped_ = false;
|
|
}
|
|
}
|
|
|
|
void CefWindowX11::Focus() {
|
|
if (xwindow_ == x11::None || !window_mapped_)
|
|
return;
|
|
|
|
if (browser_.get()) {
|
|
::Window child = FindChild(xdisplay_, xwindow_);
|
|
if (child && ui::IsWindowVisible(child)) {
|
|
// Give focus to the child DesktopWindowTreeHostX11.
|
|
XSetInputFocus(xdisplay_, child, RevertToParent, x11::CurrentTime);
|
|
}
|
|
} else {
|
|
XSetInputFocus(xdisplay_, xwindow_, RevertToParent, x11::CurrentTime);
|
|
}
|
|
}
|
|
|
|
void CefWindowX11::SetBounds(const gfx::Rect& bounds) {
|
|
if (xwindow_ == x11::None)
|
|
return;
|
|
|
|
bool origin_changed = bounds_.origin() != bounds.origin();
|
|
bool size_changed = bounds_.size() != bounds.size();
|
|
XWindowChanges changes = {0};
|
|
unsigned value_mask = 0;
|
|
|
|
if (size_changed) {
|
|
changes.width = bounds.width();
|
|
changes.height = bounds.height();
|
|
value_mask = CWHeight | CWWidth;
|
|
}
|
|
|
|
if (origin_changed) {
|
|
changes.x = bounds.x();
|
|
changes.y = bounds.y();
|
|
value_mask |= CWX | CWY;
|
|
}
|
|
|
|
if (value_mask)
|
|
XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
|
|
}
|
|
|
|
gfx::Rect CefWindowX11::GetBoundsInScreen() {
|
|
int x, y;
|
|
Window child;
|
|
if (XTranslateCoordinates(xdisplay_, xwindow_, DefaultRootWindow(xdisplay_),
|
|
0, 0, &x, &y, &child)) {
|
|
return gfx::Rect(gfx::Point(x, y), bounds_.size());
|
|
}
|
|
return gfx::Rect();
|
|
}
|
|
|
|
views::DesktopWindowTreeHostX11* CefWindowX11::GetHost() {
|
|
if (browser_.get()) {
|
|
::Window child = FindChild(xdisplay_, xwindow_);
|
|
if (child) {
|
|
return static_cast<views::DesktopWindowTreeHostX11*>(
|
|
views::DesktopWindowTreeHostLinux::GetHostForWidget(child));
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool CefWindowX11::CanDispatchEvent(const ui::PlatformEvent& event) {
|
|
DCHECK_NE(xwindow_, x11::None);
|
|
return !!current_xevent_;
|
|
}
|
|
|
|
uint32_t CefWindowX11::DispatchEvent(const ui::PlatformEvent& event) {
|
|
DCHECK_NE(xwindow_, x11::None);
|
|
DCHECK(event);
|
|
DCHECK(current_xevent_);
|
|
|
|
ProcessXEvent(current_xevent_);
|
|
return ui::POST_DISPATCH_STOP_PROPAGATION;
|
|
}
|
|
|
|
// Called by X11EventSourceLibevent to determine whether this XEventDispatcher
|
|
// implementation is able to process the next translated event sent by it.
|
|
void CefWindowX11::CheckCanDispatchNextPlatformEvent(XEvent* xev) {
|
|
current_xevent_ = IsTargetedBy(*xev) ? xev : nullptr;
|
|
}
|
|
|
|
void CefWindowX11::PlatformEventDispatchFinished() {
|
|
current_xevent_ = nullptr;
|
|
}
|
|
|
|
ui::PlatformEventDispatcher* CefWindowX11::GetPlatformEventDispatcher() {
|
|
return this;
|
|
}
|
|
|
|
bool CefWindowX11::DispatchXEvent(XEvent* xev) {
|
|
if (!IsTargetedBy(*xev))
|
|
return false;
|
|
ProcessXEvent(xev);
|
|
return true;
|
|
}
|
|
|
|
void CefWindowX11::ContinueFocus() {
|
|
if (!focus_pending_)
|
|
return;
|
|
if (browser_.get())
|
|
browser_->SetFocus(true);
|
|
focus_pending_ = false;
|
|
}
|
|
|
|
bool CefWindowX11::TopLevelAlwaysOnTop() const {
|
|
::Window toplevel_window = FindToplevelParent(xdisplay_, xwindow_);
|
|
|
|
Atom state_atom = gfx::GetAtom("_NET_WM_STATE");
|
|
Atom state_keep_above = gfx::GetAtom("_NET_WM_STATE_KEEP_ABOVE");
|
|
Atom* states;
|
|
|
|
Atom actual_type;
|
|
int actual_format;
|
|
unsigned long num_items;
|
|
unsigned long bytes_after;
|
|
|
|
XGetWindowProperty(xdisplay_, toplevel_window, state_atom, 0, 1024,
|
|
x11::False, XA_ATOM, &actual_type, &actual_format,
|
|
&num_items, &bytes_after,
|
|
reinterpret_cast<unsigned char**>(&states));
|
|
|
|
bool always_on_top = false;
|
|
|
|
for (unsigned long i = 0; i < num_items; ++i) {
|
|
if (states[i] == state_keep_above) {
|
|
always_on_top = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
XFree(states);
|
|
|
|
return always_on_top;
|
|
}
|
|
|
|
bool CefWindowX11::IsTargetedBy(const XEvent& xev) const {
|
|
::Window target_window =
|
|
(xev.type == GenericEvent)
|
|
? static_cast<XIDeviceEvent*>(xev.xcookie.data)->event
|
|
: xev.xany.window;
|
|
return target_window == xwindow_;
|
|
}
|
|
|
|
void CefWindowX11::ProcessXEvent(XEvent* xev) {
|
|
switch (xev->type) {
|
|
case ConfigureNotify: {
|
|
DCHECK_EQ(xwindow_, xev->xconfigure.event);
|
|
DCHECK_EQ(xwindow_, xev->xconfigure.window);
|
|
// It's possible that the X window may be resized by some other means
|
|
// than from within Aura (e.g. the X window manager can change the
|
|
// size). Make sure the root window size is maintained properly.
|
|
gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
|
|
xev->xconfigure.width, xev->xconfigure.height);
|
|
bounds_ = bounds;
|
|
|
|
if (browser_.get()) {
|
|
::Window child = FindChild(xdisplay_, xwindow_);
|
|
if (child) {
|
|
// Resize the child DesktopWindowTreeHostX11 to match this window.
|
|
XWindowChanges changes = {0};
|
|
changes.width = bounds.width();
|
|
changes.height = bounds.height();
|
|
XConfigureWindow(xdisplay_, child, CWHeight | CWWidth, &changes);
|
|
|
|
browser_->NotifyMoveOrResizeStarted();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case ClientMessage: {
|
|
Atom message_type = xev->xclient.message_type;
|
|
if (message_type == gfx::GetAtom(kWMProtocols)) {
|
|
Atom protocol = static_cast<Atom>(xev->xclient.data.l[0]);
|
|
if (protocol == gfx::GetAtom(kWMDeleteWindow)) {
|
|
// We have received a close message from the window manager.
|
|
if (!browser_ || browser_->TryCloseBrowser()) {
|
|
// Allow the close.
|
|
XDestroyWindow(xdisplay_, xwindow_);
|
|
|
|
xwindow_ = x11::None;
|
|
|
|
if (browser_.get()) {
|
|
// Force the browser to be destroyed and release the reference
|
|
// added in PlatformCreateWindow().
|
|
browser_->WindowDestroyed();
|
|
}
|
|
|
|
delete this;
|
|
}
|
|
} else if (protocol == gfx::GetAtom(kNetWMPing)) {
|
|
XEvent reply_event = *xev;
|
|
reply_event.xclient.window = parent_xwindow_;
|
|
|
|
XSendEvent(xdisplay_, reply_event.xclient.window, false,
|
|
SubstructureRedirectMask | SubstructureNotifyMask,
|
|
&reply_event);
|
|
XFlush(xdisplay_);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case x11::FocusIn:
|
|
// This message is received first followed by a "_NET_ACTIVE_WINDOW"
|
|
// message sent to the root window. When X11DesktopHandler handles the
|
|
// "_NET_ACTIVE_WINDOW" message it will erroneously mark the WebView
|
|
// (hosted in a DesktopWindowTreeHostX11) as unfocused. Use a delayed
|
|
// task here to restore the WebView's focus state.
|
|
if (!focus_pending_) {
|
|
focus_pending_ = true;
|
|
CEF_POST_DELAYED_TASK(CEF_UIT,
|
|
base::Bind(&CefWindowX11::ContinueFocus,
|
|
weak_ptr_factory_.GetWeakPtr()),
|
|
100);
|
|
}
|
|
break;
|
|
case x11::FocusOut:
|
|
// Cancel the pending focus change if some other window has gained focus
|
|
// while waiting for the async task to run. Otherwise we can get stuck in
|
|
// a focus change loop.
|
|
if (focus_pending_)
|
|
focus_pending_ = false;
|
|
break;
|
|
case PropertyNotify: {
|
|
::Atom changed_atom = xev->xproperty.atom;
|
|
if (changed_atom == gfx::GetAtom(kNetWMState)) {
|
|
// State change event like minimize/maximize.
|
|
if (browser_.get()) {
|
|
::Window child = FindChild(xdisplay_, xwindow_);
|
|
if (child) {
|
|
// Forward the state change to the child DesktopWindowTreeHostX11
|
|
// window so that resource usage will be reduced while the window is
|
|
// minimized.
|
|
std::vector<::Atom> atom_list;
|
|
if (ui::GetAtomArrayProperty(xwindow_, kNetWMState, &atom_list) &&
|
|
!atom_list.empty()) {
|
|
ui::SetAtomArrayProperty(child, kNetWMState, "ATOM", atom_list);
|
|
} else {
|
|
// Set an empty list of property values to pass the check in
|
|
// DesktopWindowTreeHostX11::OnWMStateUpdated().
|
|
XChangeProperty(xdisplay_, child,
|
|
gfx::GetAtom(kNetWMState), // name
|
|
gfx::GetAtom(kAtom), // type
|
|
32, // size in bits of items in 'value'
|
|
PropModeReplace, NULL,
|
|
0); // num items
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|