2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2006 Lubos Lunak <l.lunak@kde.org>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#include "unmanaged.h"
|
|
|
|
|
|
|
|
#include "deleted.h"
|
2022-03-23 10:13:38 +00:00
|
|
|
#include "effects.h"
|
2021-11-26 10:03:14 +00:00
|
|
|
#include "platform.h"
|
2021-02-04 09:07:20 +00:00
|
|
|
#include "surfaceitem_x11.h"
|
2022-01-18 08:35:52 +00:00
|
|
|
#include "utils/common.h"
|
2022-04-22 09:27:33 +00:00
|
|
|
#include "wayland/surface_interface.h"
|
2022-03-23 10:13:38 +00:00
|
|
|
#include "workspace.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-04-26 09:27:30 +00:00
|
|
|
#include <QDebug>
|
2021-08-12 14:08:00 +00:00
|
|
|
#include <QTimer>
|
|
|
|
#include <QWidget>
|
2019-03-19 14:01:29 +00:00
|
|
|
#include <QWindow>
|
2013-04-26 09:27:30 +00:00
|
|
|
|
2013-08-20 07:48:14 +00:00
|
|
|
#include <xcb/shape.h>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2021-02-03 20:15:34 +00:00
|
|
|
using namespace KWaylandServer;
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2019-09-19 19:12:44 +00:00
|
|
|
// window types that are supported as unmanaged (mainly for compositing)
|
2022-03-23 10:13:38 +00:00
|
|
|
const NET::WindowTypes SUPPORTED_UNMANAGED_WINDOW_TYPES_MASK = NET::NormalMask
|
|
|
|
| NET::DesktopMask
|
|
|
|
| NET::DockMask
|
|
|
|
| NET::ToolbarMask
|
|
|
|
| NET::MenuMask
|
|
|
|
| NET::DialogMask
|
|
|
|
/*| NET::OverrideMask*/
|
|
|
|
| NET::TopMenuMask
|
|
|
|
| NET::UtilityMask
|
|
|
|
| NET::SplashMask
|
|
|
|
| NET::DropdownMenuMask
|
|
|
|
| NET::PopupMenuMask
|
|
|
|
| NET::TooltipMask
|
|
|
|
| NET::NotificationMask
|
|
|
|
| NET::ComboBoxMask
|
|
|
|
| NET::DNDIconMask
|
|
|
|
| NET::OnScreenDisplayMask
|
|
|
|
| NET::CriticalNotificationMask;
|
2019-09-19 19:12:44 +00:00
|
|
|
|
2013-05-08 11:39:06 +00:00
|
|
|
Unmanaged::Unmanaged()
|
2022-04-22 17:39:12 +00:00
|
|
|
: Window()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2021-02-03 20:15:34 +00:00
|
|
|
switch (kwinApp()->operationMode()) {
|
|
|
|
case Application::OperationModeXwayland:
|
2021-02-04 09:07:20 +00:00
|
|
|
// The wayland surface is associated with the override-redirect window asynchronously.
|
2022-04-22 17:39:12 +00:00
|
|
|
connect(this, &Window::surfaceChanged, this, &Unmanaged::associate);
|
2021-02-03 20:15:34 +00:00
|
|
|
break;
|
|
|
|
case Application::OperationModeX11:
|
2021-02-04 09:07:20 +00:00
|
|
|
// We have no way knowing whether the override-redirect window can be painted. Mark it
|
|
|
|
// as ready for painting after synthetic 50ms delay.
|
|
|
|
QTimer::singleShot(50, this, &Unmanaged::initialize);
|
2021-02-03 20:15:34 +00:00
|
|
|
break;
|
|
|
|
case Application::OperationModeWaylandOnly:
|
|
|
|
Q_UNREACHABLE();
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
Unmanaged::~Unmanaged()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2021-02-03 20:15:34 +00:00
|
|
|
void Unmanaged::associate()
|
|
|
|
{
|
|
|
|
if (surface()->isMapped()) {
|
2021-02-04 09:07:20 +00:00
|
|
|
initialize();
|
2021-02-03 20:15:34 +00:00
|
|
|
} else {
|
2021-02-04 09:07:20 +00:00
|
|
|
// Queued connection because we want to mark the window ready for painting after
|
|
|
|
// the associated surface item has processed the new surface state.
|
|
|
|
connect(surface(), &SurfaceInterface::mapped, this, &Unmanaged::initialize, Qt::QueuedConnection);
|
2021-02-03 20:15:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-04 09:07:20 +00:00
|
|
|
void Unmanaged::initialize()
|
|
|
|
{
|
|
|
|
setReadyForPainting();
|
|
|
|
|
|
|
|
// With unmanaged windows there is a race condition between the client painting the window
|
|
|
|
// and us setting up damage tracking. If the client wins we won't get a damage event even
|
|
|
|
// though the window has been painted. To avoid this we mark the whole window as damaged
|
|
|
|
// and schedule a repaint immediately after creating the damage object.
|
2021-04-05 11:54:25 +00:00
|
|
|
if (auto item = surfaceItem()) {
|
|
|
|
item->addDamage(item->rect());
|
|
|
|
}
|
2021-02-04 09:07:20 +00:00
|
|
|
}
|
|
|
|
|
2019-09-06 14:30:26 +00:00
|
|
|
bool Unmanaged::track(xcb_window_t w)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-19 19:19:02 +00:00
|
|
|
XServerGrabber xserverGrabber;
|
2014-04-25 10:09:11 +00:00
|
|
|
Xcb::WindowAttributes attr(w);
|
|
|
|
Xcb::WindowGeometry geo(w);
|
|
|
|
if (attr.isNull() || attr->map_state != XCB_MAP_STATE_VIEWABLE) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2014-04-25 10:09:11 +00:00
|
|
|
if (attr->_class == XCB_WINDOW_CLASS_INPUT_ONLY) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (geo.isNull()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2022-03-23 10:13:38 +00:00
|
|
|
setWindowHandles(w); // the window is also the frame
|
2014-04-25 10:09:11 +00:00
|
|
|
Xcb::selectInput(w, attr->your_event_mask | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE);
|
2021-05-15 10:56:35 +00:00
|
|
|
m_bufferGeometry = geo.rect();
|
2019-12-04 13:18:34 +00:00
|
|
|
m_frameGeometry = geo.rect();
|
2020-06-30 13:59:54 +00:00
|
|
|
m_clientGeometry = geo.rect();
|
2021-08-28 15:34:58 +00:00
|
|
|
checkOutput();
|
2014-04-25 10:09:11 +00:00
|
|
|
m_visual = attr->visual;
|
|
|
|
bit_depth = geo->depth;
|
2022-02-08 22:28:03 +00:00
|
|
|
info = new NETWinInfo(kwinApp()->x11Connection(), w, kwinApp()->x11RootWindow(),
|
2014-04-11 06:06:26 +00:00
|
|
|
NET::WMWindowType | NET::WMPid,
|
2022-03-23 10:13:38 +00:00
|
|
|
NET::WM2Opacity | NET::WM2WindowRole | NET::WM2WindowClass | NET::WM2OpaqueRegion);
|
2021-03-03 07:15:12 +00:00
|
|
|
setOpacity(info->opacityF());
|
2007-11-13 19:25:44 +00:00
|
|
|
getResourceClass();
|
|
|
|
getWmClientLeader();
|
|
|
|
getWmClientMachine();
|
2022-03-25 12:20:32 +00:00
|
|
|
if (Xcb::Extensions::self()->isShapeAvailable()) {
|
2022-02-08 22:22:38 +00:00
|
|
|
xcb_shape_select_input(kwinApp()->x11Connection(), w, true);
|
2022-03-25 12:20:32 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
detectShape(w);
|
2011-10-22 09:02:49 +00:00
|
|
|
getWmOpaqueRegion();
|
2014-01-24 11:34:16 +00:00
|
|
|
getSkipCloseAnimation();
|
2007-04-29 17:35:43 +00:00
|
|
|
setupCompositing();
|
2019-03-19 14:01:29 +00:00
|
|
|
if (QWindow *internalWindow = findInternalWindow()) {
|
|
|
|
m_outline = internalWindow->property("__kwin_outline").toBool();
|
|
|
|
}
|
2022-03-25 12:20:32 +00:00
|
|
|
if (effects) {
|
2022-03-23 10:13:38 +00:00
|
|
|
static_cast<EffectsHandlerImpl *>(effects)->checkInputWindowStacking();
|
2022-03-25 12:20:32 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
return true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-04-07 14:23:17 +00:00
|
|
|
void Unmanaged::release(ReleaseReason releaseReason)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2022-03-23 10:13:38 +00:00
|
|
|
Deleted *del = nullptr;
|
2014-04-07 14:23:17 +00:00
|
|
|
if (releaseReason != ReleaseReason::KWinShutsDown) {
|
2012-04-22 07:27:53 +00:00
|
|
|
del = Deleted::create(this);
|
|
|
|
}
|
2021-06-08 07:02:14 +00:00
|
|
|
Q_EMIT windowClosed(this, del);
|
2014-04-07 14:23:17 +00:00
|
|
|
finishCompositing(releaseReason);
|
|
|
|
if (!QWidget::find(window()) && releaseReason != ReleaseReason::Destroyed) { // don't affect our own windows
|
2022-03-25 12:20:32 +00:00
|
|
|
if (Xcb::Extensions::self()->isShapeAvailable()) {
|
2022-02-08 22:22:38 +00:00
|
|
|
xcb_shape_select_input(kwinApp()->x11Connection(), window(), false);
|
2022-03-25 12:20:32 +00:00
|
|
|
}
|
2013-08-19 08:52:22 +00:00
|
|
|
Xcb::selectInput(window(), XCB_EVENT_MASK_NO_EVENT);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2020-07-20 08:07:08 +00:00
|
|
|
workspace()->removeUnmanaged(this);
|
2014-04-07 14:23:17 +00:00
|
|
|
if (releaseReason != ReleaseReason::KWinShutsDown) {
|
2012-04-22 07:27:53 +00:00
|
|
|
disownDataPassedToDeleted();
|
|
|
|
del->unrefWindow();
|
|
|
|
}
|
2013-04-26 07:47:45 +00:00
|
|
|
deleteUnmanaged(this);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2022-03-23 10:13:38 +00:00
|
|
|
void Unmanaged::deleteUnmanaged(Unmanaged *c)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
delete c;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-10-24 10:00:16 +00:00
|
|
|
bool Unmanaged::hasScheduledRelease() const
|
|
|
|
{
|
|
|
|
return m_scheduledRelease;
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
int Unmanaged::desktop() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
return NET::OnAllDesktops; // TODO for some window types should be the current desktop?
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2010-05-11 20:30:20 +00:00
|
|
|
QStringList Unmanaged::activities() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-05-11 20:30:20 +00:00
|
|
|
return QStringList();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-05-11 20:30:20 +00:00
|
|
|
|
2018-11-07 16:22:41 +00:00
|
|
|
QVector<VirtualDesktop *> Unmanaged::desktops() const
|
[wayland] Use the new plasma virtual desktop protocol
Summary:
implement virtual desktop support for Wayland.
use the new virtual desktop protocol from D12820
The VirtualDesktopManager class needed some big change in order
to accomodate it, which is where most changes are.
Other than that, it's mostly connections to wire up
VirtualDesktopsManager and VirtualDesktopsManagement(the wayland protocol impl)
Depends on D12820
Other notable detail, is the client visibility updated to reflect the presence
of the client in the plasmavirtualdesktop.
(and the unSetDesktop concept)
Test Plan: used a bit a plasma session together with D12820, D13748 and D13746
Reviewers: #plasma, #kwin, graesslin, davidedmundson
Reviewed By: #plasma, #kwin, davidedmundson
Subscribers: hein, zzag, davidedmundson, kwin
Tags: #kwin
Maniphest Tasks: T4457
Differential Revision: https://phabricator.kde.org/D13887
2018-10-29 22:29:15 +00:00
|
|
|
{
|
2018-11-07 16:22:41 +00:00
|
|
|
return QVector<VirtualDesktop *>();
|
[wayland] Use the new plasma virtual desktop protocol
Summary:
implement virtual desktop support for Wayland.
use the new virtual desktop protocol from D12820
The VirtualDesktopManager class needed some big change in order
to accomodate it, which is where most changes are.
Other than that, it's mostly connections to wire up
VirtualDesktopsManager and VirtualDesktopsManagement(the wayland protocol impl)
Depends on D12820
Other notable detail, is the client visibility updated to reflect the presence
of the client in the plasmavirtualdesktop.
(and the unSetDesktop concept)
Test Plan: used a bit a plasma session together with D12820, D13748 and D13746
Reviewers: #plasma, #kwin, graesslin, davidedmundson
Reviewed By: #plasma, #kwin, davidedmundson
Subscribers: hein, zzag, davidedmundson, kwin
Tags: #kwin
Maniphest Tasks: T4457
Differential Revision: https://phabricator.kde.org/D13887
2018-10-29 22:29:15 +00:00
|
|
|
}
|
|
|
|
|
2007-07-18 15:01:59 +00:00
|
|
|
QPoint Unmanaged::clientPos() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2022-03-23 10:13:38 +00:00
|
|
|
return QPoint(0, 0); // unmanaged windows don't have decorations
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-07-18 15:01:59 +00:00
|
|
|
|
2012-09-06 07:09:31 +00:00
|
|
|
NET::WindowType Unmanaged::windowType(bool direct, int supportedTypes) const
|
|
|
|
{
|
|
|
|
// for unmanaged windows the direct does not make any difference
|
|
|
|
// as there are no rules to check and no hacks to apply
|
|
|
|
Q_UNUSED(direct)
|
|
|
|
if (supportedTypes == 0) {
|
|
|
|
supportedTypes = SUPPORTED_UNMANAGED_WINDOW_TYPES_MASK;
|
|
|
|
}
|
2014-02-03 08:37:08 +00:00
|
|
|
return info->windowType(NET::WindowTypes(supportedTypes));
|
2012-09-06 07:09:31 +00:00
|
|
|
}
|
|
|
|
|
2019-03-19 14:01:29 +00:00
|
|
|
bool Unmanaged::isOutline() const
|
|
|
|
{
|
|
|
|
return m_outline;
|
|
|
|
}
|
|
|
|
|
|
|
|
QWindow *Unmanaged::findInternalWindow() const
|
|
|
|
{
|
|
|
|
const QWindowList windows = kwinApp()->topLevelWindows();
|
|
|
|
for (QWindow *w : windows) {
|
|
|
|
if (w->winId() == window()) {
|
|
|
|
return w;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-11-26 10:03:14 +00:00
|
|
|
void Unmanaged::checkOutput()
|
|
|
|
{
|
|
|
|
setOutput(kwinApp()->platform()->outputAt(frameGeometry().center()));
|
|
|
|
}
|
|
|
|
|
2021-02-04 09:07:20 +00:00
|
|
|
void Unmanaged::damageNotifyEvent()
|
|
|
|
{
|
|
|
|
Q_ASSERT(kwinApp()->operationMode() == Application::OperationModeX11);
|
|
|
|
SurfaceItemX11 *item = static_cast<SurfaceItemX11 *>(surfaceItem());
|
|
|
|
if (item) {
|
|
|
|
item->processDamage();
|
|
|
|
}
|
2019-04-15 23:34:27 +00:00
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|