2007-11-27 19:40:25 +00:00
|
|
|
/********************************************************************
|
2007-04-29 17:35:43 +00:00
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
|
|
|
|
Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
|
2007-11-27 19:40:25 +00:00
|
|
|
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/>.
|
|
|
|
*********************************************************************/
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#ifndef KWIN_UTILS_H
|
|
|
|
#define KWIN_UTILS_H
|
|
|
|
|
2013-04-25 14:54:12 +00:00
|
|
|
// cmake stuff
|
2007-04-29 17:35:43 +00:00
|
|
|
#include <config-kwin.h>
|
2007-12-17 14:14:53 +00:00
|
|
|
#include <kwinconfig.h>
|
2013-04-25 14:54:12 +00:00
|
|
|
// kwin
|
|
|
|
#include <kwinglobals.h>
|
|
|
|
// KDE
|
2014-03-18 13:32:53 +00:00
|
|
|
#include <netwm_def.h>
|
2013-04-25 14:54:12 +00:00
|
|
|
// Qt
|
2014-12-05 10:42:15 +00:00
|
|
|
#include <QLoggingCategory>
|
2013-04-30 07:15:29 +00:00
|
|
|
#include <QList>
|
2013-04-25 15:21:54 +00:00
|
|
|
#include <QPoint>
|
|
|
|
#include <QRect>
|
2013-04-25 14:54:12 +00:00
|
|
|
#include <QScopedPointer>
|
2015-12-15 09:22:03 +00:00
|
|
|
#include <QProcess>
|
2013-04-25 14:54:12 +00:00
|
|
|
// system
|
2019-07-09 19:19:26 +00:00
|
|
|
#include <climits>
|
2014-12-05 10:42:15 +00:00
|
|
|
Q_DECLARE_LOGGING_CATEGORY(KWIN_CORE)
|
2018-12-10 10:57:24 +00:00
|
|
|
Q_DECLARE_LOGGING_CATEGORY(KWIN_VIRTUALKEYBOARD)
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2007-12-07 15:53:43 +00:00
|
|
|
// window types that are supported as normal windows (i.e. KWin actually manages them)
|
2014-02-03 08:37:08 +00:00
|
|
|
const NET::WindowTypes SUPPORTED_MANAGED_WINDOW_TYPES_MASK = NET::NormalMask | NET::DesktopMask | NET::DockMask
|
2011-01-30 14:34:42 +00:00
|
|
|
| NET::ToolbarMask | NET::MenuMask | NET::DialogMask /*| NET::OverrideMask*/ | NET::TopMenuMask
|
2019-05-02 08:29:38 +00:00
|
|
|
| NET::UtilityMask | NET::SplashMask | NET::NotificationMask | NET::OnScreenDisplayMask
|
|
|
|
| NET::CriticalNotificationMask;
|
2007-12-07 15:53:43 +00:00
|
|
|
// window types that are supported as unmanaged (mainly for compositing)
|
2014-02-03 08:37:08 +00:00
|
|
|
const NET::WindowTypes SUPPORTED_UNMANAGED_WINDOW_TYPES_MASK = NET::NormalMask | NET::DesktopMask | NET::DockMask
|
2011-01-30 14:34:42 +00:00
|
|
|
| NET::ToolbarMask | NET::MenuMask | NET::DialogMask /*| NET::OverrideMask*/ | NET::TopMenuMask
|
|
|
|
| NET::UtilityMask | NET::SplashMask | NET::DropdownMenuMask | NET::PopupMenuMask
|
2019-05-02 08:29:38 +00:00
|
|
|
| NET::TooltipMask | NET::NotificationMask | NET::ComboBoxMask | NET::DNDIconMask | NET::OnScreenDisplayMask
|
|
|
|
| NET::CriticalNotificationMask;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
const QPoint invalidPoint(INT_MIN, INT_MIN);
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
class Toplevel;
|
|
|
|
class Client;
|
|
|
|
class Unmanaged;
|
|
|
|
class Deleted;
|
|
|
|
class Group;
|
|
|
|
class Options;
|
|
|
|
|
|
|
|
typedef QList< Toplevel* > ToplevelList;
|
|
|
|
typedef QList< Client* > ClientList;
|
|
|
|
typedef QList< const Client* > ConstClientList;
|
|
|
|
typedef QList< Unmanaged* > UnmanagedList;
|
|
|
|
typedef QList< Deleted* > DeletedList;
|
|
|
|
|
|
|
|
typedef QList< Group* > GroupList;
|
|
|
|
|
|
|
|
extern Options* options;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
enum Layer {
|
2007-04-29 17:35:43 +00:00
|
|
|
UnknownLayer = -1,
|
|
|
|
FirstLayer = 0,
|
|
|
|
DesktopLayer = FirstLayer,
|
|
|
|
BelowLayer,
|
|
|
|
NormalLayer,
|
|
|
|
DockLayer,
|
|
|
|
AboveLayer,
|
2014-01-20 10:02:07 +00:00
|
|
|
NotificationLayer, // layer for windows of type notification
|
2007-04-29 17:35:43 +00:00
|
|
|
ActiveLayer, // active fullscreen, or active dialog
|
2019-05-02 08:29:38 +00:00
|
|
|
CriticalNotificationLayer, // layer for notifications that should be shown even on top of fullscreen
|
2015-01-02 11:11:54 +00:00
|
|
|
OnScreenDisplayLayer, // layer for On Screen Display windows such as volume feedback
|
2012-04-07 14:43:27 +00:00
|
|
|
UnmanagedLayer, // layer for override redirect windows.
|
2007-04-29 17:35:43 +00:00
|
|
|
NumLayers // number of layers, must be last
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// yes, I know this is not 100% like standard operator++
|
2011-01-30 14:34:42 +00:00
|
|
|
inline void operator++(Layer& lay)
|
|
|
|
{
|
|
|
|
lay = static_cast< Layer >(lay + 1);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
enum StrutArea {
|
2009-02-17 15:50:00 +00:00
|
|
|
StrutAreaInvalid = 0, // Null
|
|
|
|
StrutAreaTop = 1 << 0,
|
|
|
|
StrutAreaRight = 1 << 1,
|
|
|
|
StrutAreaBottom = 1 << 2,
|
|
|
|
StrutAreaLeft = 1 << 3,
|
|
|
|
StrutAreaAll = StrutAreaTop | StrutAreaRight | StrutAreaBottom | StrutAreaLeft
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
|
|
|
Q_DECLARE_FLAGS(StrutAreas, StrutArea)
|
2009-02-17 15:50:00 +00:00
|
|
|
|
|
|
|
class StrutRect : public QRect
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit StrutRect(QRect rect = QRect(), StrutArea area = StrutAreaInvalid);
|
|
|
|
StrutRect(const StrutRect& other);
|
|
|
|
inline StrutArea area() const {
|
|
|
|
return m_area;
|
2009-02-17 15:50:00 +00:00
|
|
|
};
|
2011-01-30 14:34:42 +00:00
|
|
|
private:
|
|
|
|
StrutArea m_area;
|
|
|
|
};
|
2009-02-17 15:50:00 +00:00
|
|
|
typedef QVector<StrutRect> StrutRects;
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
enum ShadeMode {
|
2007-04-29 17:35:43 +00:00
|
|
|
ShadeNone, // not shaded
|
|
|
|
ShadeNormal, // normally shaded - isShade() is true only here
|
|
|
|
ShadeHover, // "shaded", but visible due to hover unshade
|
|
|
|
ShadeActivated // "shaded", but visible due to alt+tab to the window
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-12-02 12:49:08 +00:00
|
|
|
/**
|
|
|
|
* Maximize mode. These values specify how a window is maximized.
|
2019-02-02 18:17:44 +00:00
|
|
|
*
|
|
|
|
* @note these values are written to session files, don't change the order
|
|
|
|
**/
|
2014-12-02 12:49:08 +00:00
|
|
|
enum MaximizeMode {
|
|
|
|
MaximizeRestore = 0, ///< The window is not maximized in any direction.
|
|
|
|
MaximizeVertical = 1, ///< The window is maximized vertically.
|
|
|
|
MaximizeHorizontal = 2, ///< The window is maximized horizontally.
|
|
|
|
/// Equal to @p MaximizeVertical | @p MaximizeHorizontal
|
|
|
|
MaximizeFull = MaximizeVertical | MaximizeHorizontal
|
|
|
|
};
|
|
|
|
|
|
|
|
inline
|
|
|
|
MaximizeMode operator^(MaximizeMode m1, MaximizeMode m2)
|
|
|
|
{
|
|
|
|
return MaximizeMode(int(m1) ^ int(m2));
|
|
|
|
}
|
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
enum class QuickTileFlag {
|
2018-06-14 13:48:02 +00:00
|
|
|
None = 0,
|
|
|
|
Left = 1 << 0,
|
|
|
|
Right = 1 << 1,
|
|
|
|
Top = 1 << 2,
|
|
|
|
Bottom = 1 << 3,
|
|
|
|
Horizontal = Left | Right,
|
|
|
|
Vertical = Top | Bottom,
|
|
|
|
Maximize = Left | Right | Top | Bottom,
|
2017-07-18 19:12:37 +00:00
|
|
|
};
|
|
|
|
Q_DECLARE_FLAGS(QuickTileMode, QuickTileFlag)
|
|
|
|
|
2014-03-20 08:42:35 +00:00
|
|
|
template <typename T> using ScopedCPointer = QScopedPointer<T, QScopedPointerPodDeleter>;
|
2012-03-26 15:20:04 +00:00
|
|
|
|
2017-05-03 19:17:25 +00:00
|
|
|
void KWIN_EXPORT updateXTime();
|
2016-11-15 09:22:56 +00:00
|
|
|
void KWIN_EXPORT grabXServer();
|
|
|
|
void KWIN_EXPORT ungrabXServer();
|
2017-09-17 07:42:17 +00:00
|
|
|
bool KWIN_EXPORT grabXKeyboard(xcb_window_t w = XCB_WINDOW_NONE);
|
2016-11-15 09:22:56 +00:00
|
|
|
void KWIN_EXPORT ungrabXKeyboard();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2012-12-11 20:09:58 +00:00
|
|
|
/**
|
2019-01-12 10:31:32 +00:00
|
|
|
* Small helper class which performs grabXServer in the ctor and
|
|
|
|
* ungrabXServer in the dtor. Use this class to ensure that grab and
|
2012-12-11 20:09:58 +00:00
|
|
|
* ungrab are matched.
|
2014-04-25 10:09:11 +00:00
|
|
|
*
|
|
|
|
* To simplify usage consider using the macro GRAB_SERVER_DURING_CONTEXT
|
2012-12-11 20:09:58 +00:00
|
|
|
**/
|
|
|
|
class XServerGrabber
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
XServerGrabber() {
|
|
|
|
grabXServer();
|
|
|
|
}
|
|
|
|
~XServerGrabber() {
|
|
|
|
ungrabXServer();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-04-25 10:09:11 +00:00
|
|
|
#define GRAB_SERVER_DURING_CONTEXT XServerGrabber xserverGrabber;
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
// the docs say it's UrgencyHint, but it's often #defined as XUrgencyHint
|
|
|
|
#ifndef UrgencyHint
|
|
|
|
#define UrgencyHint XUrgencyHint
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// converting between X11 mouse/keyboard state mask and Qt button/keyboard states
|
2011-01-30 14:34:42 +00:00
|
|
|
Qt::MouseButton x11ToQtMouseButton(int button);
|
2017-09-23 18:21:26 +00:00
|
|
|
Qt::MouseButton KWIN_EXPORT x11ToQtMouseButton(int button);
|
2016-08-16 13:31:14 +00:00
|
|
|
Qt::MouseButtons KWIN_EXPORT x11ToQtMouseButtons(int state);
|
|
|
|
Qt::KeyboardModifiers KWIN_EXPORT x11ToQtKeyboardModifiers(int state);
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-05-19 10:03:53 +00:00
|
|
|
/**
|
|
|
|
* Separate the concept of an unet QPoint and 0,0
|
2019-02-02 18:17:44 +00:00
|
|
|
**/
|
2015-05-19 10:03:53 +00:00
|
|
|
class ClearablePoint
|
|
|
|
{
|
|
|
|
public:
|
2015-10-28 10:16:48 +00:00
|
|
|
inline bool isValid() const {
|
2015-05-19 10:03:53 +00:00
|
|
|
return m_valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void clear(){
|
|
|
|
m_valid = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void setPoint(const QPoint &point) {
|
|
|
|
m_point = point; m_valid = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline QPoint point() const {
|
|
|
|
return m_point;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
QPoint m_point;
|
|
|
|
bool m_valid = false;
|
|
|
|
};
|
|
|
|
|
2015-12-15 09:22:03 +00:00
|
|
|
/**
|
|
|
|
* QProcess subclass which unblocks SIGUSR in the child process.
|
|
|
|
**/
|
|
|
|
class KWIN_EXPORT Process : public QProcess
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
public:
|
|
|
|
explicit Process(QObject *parent = nullptr);
|
|
|
|
virtual ~Process();
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void setupChildProcess() override;
|
|
|
|
};
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|
|
|
|
|
2009-02-17 15:50:00 +00:00
|
|
|
// Must be outside namespace
|
2011-01-30 14:34:42 +00:00
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::StrutAreas)
|
2017-07-18 19:12:37 +00:00
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::QuickTileMode)
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
#endif
|