kwin/unmanaged.cpp

216 lines
6.2 KiB
C++
Raw Normal View History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "unmanaged.h"
#include "workspace.h"
#include "effects.h"
#include "deleted.h"
#include "utils.h"
#include "xcbutils.h"
#include <QTimer>
#include <QDebug>
#include <QWindow>
#include <xcb/shape.h>
namespace KWin
{
// window types that are supported as unmanaged (mainly for compositing)
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;
Unmanaged::Unmanaged()
: Toplevel()
2011-01-30 14:34:42 +00:00
{
2011-08-17 21:51:55 +00:00
connect(this, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SIGNAL(geometryChanged()));
QTimer::singleShot(50, this, SLOT(setReadyForPainting()));
2011-01-30 14:34:42 +00:00
}
Unmanaged::~Unmanaged()
2011-01-30 14:34:42 +00:00
{
}
bool Unmanaged::track(xcb_window_t w)
2011-01-30 14:34:42 +00:00
{
XServerGrabber xserverGrabber;
Xcb::WindowAttributes attr(w);
Xcb::WindowGeometry geo(w);
if (attr.isNull() || attr->map_state != XCB_MAP_STATE_VIEWABLE) {
return false;
2011-01-30 14:34:42 +00:00
}
if (attr->_class == XCB_WINDOW_CLASS_INPUT_ONLY) {
return false;
}
if (geo.isNull()) {
return false;
2011-01-30 14:34:42 +00:00
}
setWindowHandles(w); // the window is also the frame
Xcb::selectInput(w, attr->your_event_mask | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE);
geom = geo.rect();
checkScreen();
m_visual = attr->visual;
bit_depth = geo->depth;
info = new NETWinInfo(connection(), w, rootWindow(),
NET::WMWindowType | NET::WMPid,
NET::WM2Opacity |
NET::WM2WindowRole |
NET::WM2WindowClass |
NET::WM2OpaqueRegion);
getResourceClass();
getWmClientLeader();
getWmClientMachine();
if (Xcb::Extensions::self()->isShapeAvailable())
xcb_shape_select_input(connection(), w, true);
2011-01-30 14:34:42 +00:00
detectShape(w);
getWmOpaqueRegion();
getSkipCloseAnimation();
setupCompositing();
if (QWindow *internalWindow = findInternalWindow()) {
m_outline = internalWindow->property("__kwin_outline").toBool();
}
2011-01-30 14:34:42 +00:00
if (effects)
static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking();
return true;
2011-01-30 14:34:42 +00:00
}
void Unmanaged::release(ReleaseReason releaseReason)
2011-01-30 14:34:42 +00:00
{
Deleted* del = nullptr;
if (releaseReason != ReleaseReason::KWinShutsDown) {
del = Deleted::create(this);
}
emit windowClosed(this, del);
finishCompositing(releaseReason);
if (!QWidget::find(window()) && releaseReason != ReleaseReason::Destroyed) { // don't affect our own windows
if (Xcb::Extensions::self()->isShapeAvailable())
xcb_shape_select_input(connection(), window(), false);
Xcb::selectInput(window(), XCB_EVENT_MASK_NO_EVENT);
2011-01-30 14:34:42 +00:00
}
if (releaseReason != ReleaseReason::KWinShutsDown) {
workspace()->removeUnmanaged(this);
addWorkspaceRepaint(del->visibleRect());
disownDataPassedToDeleted();
del->unrefWindow();
}
deleteUnmanaged(this);
2011-01-30 14:34:42 +00:00
}
void Unmanaged::deleteUnmanaged(Unmanaged* c)
2011-01-30 14:34:42 +00:00
{
delete c;
2011-01-30 14:34:42 +00:00
}
bool Unmanaged::hasScheduledRelease() const
{
return m_scheduledRelease;
}
int Unmanaged::desktop() const
2011-01-30 14:34:42 +00:00
{
return NET::OnAllDesktops; // TODO for some window types should be the current desktop?
2011-01-30 14:34:42 +00:00
}
QStringList Unmanaged::activities() const
2011-01-30 14:34:42 +00:00
{
return QStringList();
2011-01-30 14:34:42 +00:00
}
QVector<VirtualDesktop *> Unmanaged::desktops() const
{
return QVector<VirtualDesktop *>();
}
QPoint Unmanaged::clientPos() const
2011-01-30 14:34:42 +00:00
{
return QPoint(0, 0); // unmanaged windows don't have decorations
}
QSize Unmanaged::clientSize() const
2011-01-30 14:34:42 +00:00
{
return size();
2011-01-30 14:34:42 +00:00
}
QRect Unmanaged::transparentRect() const
2011-01-30 14:34:42 +00:00
{
return QRect(clientPos(), clientSize());
2011-01-30 14:34:42 +00:00
}
2011-01-30 14:34:42 +00:00
void Unmanaged::debug(QDebug& stream) const
{
stream << "\'ID:" << window() << "\'";
2011-01-30 14:34:42 +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;
}
return info->windowType(NET::WindowTypes(supportedTypes));
}
bool Unmanaged::isOutline() const
{
return m_outline;
}
void Unmanaged::addDamage(const QRegion &damage)
{
repaints_region += damage;
Toplevel::addDamage(damage);
}
QWindow *Unmanaged::findInternalWindow() const
{
const QWindowList windows = kwinApp()->topLevelWindows();
for (QWindow *w : windows) {
if (w->winId() == window()) {
return w;
}
}
return nullptr;
}
bool Unmanaged::setupCompositing()
{
if (!Toplevel::setupCompositing()) {
return false;
}
// 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.
addDamageFull();
return true;
}
} // namespace