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>
|
2009-02-17 15:50:00 +00:00
|
|
|
Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
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
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
This file contains things relevant to geometry, i.e. workspace size,
|
|
|
|
window positions and window sizes.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
#include "x11client.h"
|
2011-08-21 19:50:23 +00:00
|
|
|
#include "composite.h"
|
2013-02-19 16:30:59 +00:00
|
|
|
#include "cursor.h"
|
2013-04-26 08:41:24 +00:00
|
|
|
#include "netinfo.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "workspace.h"
|
|
|
|
|
|
|
|
#include "placement.h"
|
|
|
|
#include "geometrytip.h"
|
|
|
|
#include "rules.h"
|
2013-04-03 10:19:27 +00:00
|
|
|
#include "screens.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "effects.h"
|
2013-01-21 08:04:06 +00:00
|
|
|
#include "screenedge.h"
|
2019-08-26 07:44:04 +00:00
|
|
|
#include "internal_client.h"
|
2013-09-06 13:32:55 +00:00
|
|
|
#include <QApplication>
|
2013-09-02 11:14:39 +00:00
|
|
|
#include <QDebug>
|
2010-01-03 17:26:27 +00:00
|
|
|
#include <QVarLengthArray>
|
2008-11-15 03:04:44 +00:00
|
|
|
|
2011-04-28 09:16:27 +00:00
|
|
|
#include "outline.h"
|
2019-08-30 21:36:58 +00:00
|
|
|
#include "xdgshellclient.h"
|
2015-06-08 19:29:07 +00:00
|
|
|
#include "wayland_server.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
#include <KDecoration2/Decoration>
|
|
|
|
#include <KDecoration2/DecoratedClient>
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2013-07-18 14:22:34 +00:00
|
|
|
static inline int sign(int v) {
|
|
|
|
return (v > 0) - (v < 0);
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
//********************************************
|
|
|
|
// Workspace
|
|
|
|
//********************************************
|
|
|
|
|
2011-05-08 18:39:27 +00:00
|
|
|
extern int screen_number;
|
|
|
|
extern bool is_multihead;
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Resizes the workspace after an XRANDR screen size change
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
void Workspace::desktopResized()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2014-11-25 07:34:10 +00:00
|
|
|
QRect geom = screens()->geometry();
|
2017-08-07 04:57:37 +00:00
|
|
|
if (rootInfo()) {
|
|
|
|
NETSize desktop_geometry;
|
|
|
|
desktop_geometry.width = geom.width();
|
|
|
|
desktop_geometry.height = geom.height();
|
|
|
|
rootInfo()->setDesktopGeometry(desktop_geometry);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
updateClientArea();
|
2011-09-30 11:22:39 +00:00
|
|
|
saveOldScreenSizes(); // after updateClientArea(), so that one still uses the previous one
|
2013-01-21 08:04:06 +00:00
|
|
|
|
|
|
|
// TODO: emit a signal instead and remove the deep function calls into edges and effects
|
2013-01-25 09:15:00 +00:00
|
|
|
ScreenEdges::self()->recreateEdges();
|
2013-01-21 08:04:06 +00:00
|
|
|
|
2011-11-26 15:15:46 +00:00
|
|
|
if (effects) {
|
|
|
|
static_cast<EffectsHandlerImpl*>(effects)->desktopResized(geom.size());
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-09-30 11:22:39 +00:00
|
|
|
void Workspace::saveOldScreenSizes()
|
|
|
|
{
|
2016-06-08 10:46:02 +00:00
|
|
|
olddisplaysize = screens()->displaySize();
|
2011-09-30 11:22:39 +00:00
|
|
|
oldscreensizes.clear();
|
|
|
|
for( int i = 0;
|
2013-04-03 10:19:27 +00:00
|
|
|
i < screens()->count();
|
2011-09-30 11:22:39 +00:00
|
|
|
++i )
|
2013-04-03 10:19:27 +00:00
|
|
|
oldscreensizes.append( screens()->geometry( i ));
|
2011-09-30 11:22:39 +00:00
|
|
|
}
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Updates the current client areas according to the current clients.
|
|
|
|
*
|
|
|
|
* If the area changes or force is @c true, the new areas are propagated to the world.
|
|
|
|
*
|
|
|
|
* The client area is the area that is available for clients (that
|
|
|
|
* which is not taken by windows like panels, the top-of-screen menu
|
|
|
|
* etc).
|
|
|
|
*
|
|
|
|
* @see clientArea()
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2011-01-30 14:34:42 +00:00
|
|
|
void Workspace::updateClientArea(bool force)
|
|
|
|
{
|
2013-04-03 10:19:27 +00:00
|
|
|
const Screens *s = Screens::self();
|
|
|
|
int nscreens = s->count();
|
2012-11-16 07:23:47 +00:00
|
|
|
const int numberOfDesktops = VirtualDesktopManager::self()->count();
|
|
|
|
QVector< QRect > new_wareas(numberOfDesktops + 1);
|
|
|
|
QVector< StrutRects > new_rmoveareas(numberOfDesktops + 1);
|
|
|
|
QVector< QVector< QRect > > new_sareas(numberOfDesktops + 1);
|
2011-01-30 14:34:42 +00:00
|
|
|
QVector< QRect > screens(nscreens);
|
2012-03-27 17:14:53 +00:00
|
|
|
QRect desktopArea;
|
2013-04-03 10:19:27 +00:00
|
|
|
for (int i = 0; i < nscreens; i++) {
|
|
|
|
desktopArea |= s->geometry(i);
|
2012-03-27 17:14:53 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int iS = 0;
|
2007-04-29 17:35:43 +00:00
|
|
|
iS < nscreens;
|
2011-01-30 14:34:42 +00:00
|
|
|
iS ++) {
|
2013-04-03 10:19:27 +00:00
|
|
|
screens [iS] = s->geometry(iS);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
for (int i = 1;
|
2012-11-16 07:23:47 +00:00
|
|
|
i <= numberOfDesktops;
|
2011-01-30 14:34:42 +00:00
|
|
|
++i) {
|
2008-07-29 13:44:08 +00:00
|
|
|
new_wareas[ i ] = desktopArea;
|
2011-01-30 14:34:42 +00:00
|
|
|
new_sareas[ i ].resize(nscreens);
|
|
|
|
for (int iS = 0;
|
|
|
|
iS < nscreens;
|
|
|
|
iS ++)
|
2008-07-29 13:44:08 +00:00
|
|
|
new_sareas[ i ][ iS ] = screens[ iS ];
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
for (ClientList::ConstIterator it = clients.constBegin(); it != clients.constEnd(); ++it) {
|
|
|
|
if (!(*it)->hasStrut())
|
2008-07-29 13:44:08 +00:00
|
|
|
continue;
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect r = (*it)->adjustedClientArea(desktopArea, desktopArea);
|
2016-06-02 08:53:05 +00:00
|
|
|
// sanity check that a strut doesn't exclude a complete screen geometry
|
|
|
|
// this is a violation to EWMH, as KWin just ignores the strut
|
|
|
|
for (int i = 0; i < Screens::self()->count(); i++) {
|
|
|
|
if (!r.intersects(Screens::self()->geometry(i))) {
|
|
|
|
qCDebug(KWIN_CORE) << "Adjusted client area would exclude a complete screen, ignore";
|
|
|
|
r = desktopArea;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
StrutRects strutRegion = (*it)->strutRects();
|
2017-07-08 06:41:16 +00:00
|
|
|
const QRect clientsScreenRect = KWin::screens()->geometry((*it)->screen());
|
|
|
|
for (auto strut = strutRegion.begin(); strut != strutRegion.end(); strut++) {
|
|
|
|
*strut = StrutRect((*strut).intersected(clientsScreenRect), (*strut).area());
|
|
|
|
}
|
2009-02-15 16:37:42 +00:00
|
|
|
|
|
|
|
// Ignore offscreen xinerama struts. These interfere with the larger monitors on the setup
|
|
|
|
// and should be ignored so that applications that use the work area to work out where
|
|
|
|
// windows can go can use the entire visible area of the larger monitors.
|
|
|
|
// This goes against the EWMH description of the work area but it is a toss up between
|
|
|
|
// having unusable sections of the screen (Which can be quite large with newer monitors)
|
|
|
|
// or having some content appear offscreen (Relatively rare compared to other).
|
|
|
|
bool hasOffscreenXineramaStrut = (*it)->hasOffscreenXineramaStrut();
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((*it)->isOnAllDesktops()) {
|
|
|
|
for (int i = 1;
|
2012-11-16 07:23:47 +00:00
|
|
|
i <= numberOfDesktops;
|
2011-01-30 14:34:42 +00:00
|
|
|
++i) {
|
|
|
|
if (!hasOffscreenXineramaStrut)
|
|
|
|
new_wareas[ i ] = new_wareas[ i ].intersected(r);
|
2009-02-17 15:50:00 +00:00
|
|
|
new_rmoveareas[ i ] += strutRegion;
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int iS = 0;
|
|
|
|
iS < nscreens;
|
|
|
|
iS ++) {
|
2016-06-02 08:53:05 +00:00
|
|
|
const auto geo = new_sareas[ i ][ iS ].intersected(
|
2011-01-30 14:34:42 +00:00
|
|
|
(*it)->adjustedClientArea(desktopArea, screens[ iS ]));
|
2018-08-29 18:02:16 +00:00
|
|
|
// ignore the geometry if it results in the screen getting removed completely
|
2016-06-02 08:53:05 +00:00
|
|
|
if (!geo.isEmpty()) {
|
|
|
|
new_sareas[ i ][ iS ] = geo;
|
|
|
|
}
|
2008-07-29 13:44:08 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
|
|
|
if (!hasOffscreenXineramaStrut)
|
|
|
|
new_wareas[(*it)->desktop()] = new_wareas[(*it)->desktop()].intersected(r);
|
|
|
|
new_rmoveareas[(*it)->desktop()] += strutRegion;
|
|
|
|
for (int iS = 0;
|
|
|
|
iS < nscreens;
|
|
|
|
iS ++) {
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "adjusting new_sarea: " << screens[ iS ];
|
2016-06-02 08:53:05 +00:00
|
|
|
const auto geo = new_sareas[(*it)->desktop()][ iS ].intersected(
|
2011-01-30 14:34:42 +00:00
|
|
|
(*it)->adjustedClientArea(desktopArea, screens[ iS ]));
|
2018-08-29 18:02:16 +00:00
|
|
|
// ignore the geometry if it results in the screen getting removed completely
|
2016-06-02 08:53:05 +00:00
|
|
|
if (!geo.isEmpty()) {
|
|
|
|
new_sareas[(*it)->desktop()][ iS ] = geo;
|
|
|
|
}
|
2008-07-29 13:44:08 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-06-08 19:29:07 +00:00
|
|
|
if (waylandServer()) {
|
2019-08-30 21:36:58 +00:00
|
|
|
auto updateStrutsForWaylandClient = [&] (XdgShellClient *c) {
|
2015-06-08 19:29:07 +00:00
|
|
|
// assuming that only docks have "struts" and that all docks have a strut
|
2015-06-19 22:14:49 +00:00
|
|
|
if (!c->hasStrut()) {
|
2015-06-08 19:29:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-06-09 08:01:05 +00:00
|
|
|
auto margins = [c] (const QRect &geometry) {
|
|
|
|
QMargins margins;
|
2019-09-27 10:01:10 +00:00
|
|
|
if (!geometry.intersects(c->frameGeometry())) {
|
2016-06-09 08:01:05 +00:00
|
|
|
return margins;
|
|
|
|
}
|
|
|
|
// figure out which areas of the overall screen setup it borders
|
2019-09-27 10:01:10 +00:00
|
|
|
const bool left = c->frameGeometry().left() == geometry.left();
|
|
|
|
const bool right = c->frameGeometry().right() == geometry.right();
|
|
|
|
const bool top = c->frameGeometry().top() == geometry.top();
|
|
|
|
const bool bottom = c->frameGeometry().bottom() == geometry.bottom();
|
|
|
|
const bool horizontal = c->frameGeometry().width() >= c->frameGeometry().height();
|
2016-06-09 08:01:05 +00:00
|
|
|
if (left && ((!top && !bottom) || !horizontal)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
margins.setLeft(c->frameGeometry().width());
|
2016-06-09 08:01:05 +00:00
|
|
|
}
|
|
|
|
if (right && ((!top && !bottom) || !horizontal)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
margins.setRight(c->frameGeometry().width());
|
2016-06-09 08:01:05 +00:00
|
|
|
}
|
|
|
|
if (top && ((!left && !right) || horizontal)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
margins.setTop(c->frameGeometry().height());
|
2016-06-09 08:01:05 +00:00
|
|
|
}
|
|
|
|
if (bottom && ((!left && !right) || horizontal)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
margins.setBottom(c->frameGeometry().height());
|
2016-06-09 08:01:05 +00:00
|
|
|
}
|
|
|
|
return margins;
|
|
|
|
};
|
2017-07-10 15:15:52 +00:00
|
|
|
auto marginsToStrutArea = [] (const QMargins &margins) {
|
|
|
|
if (margins.left() != 0) {
|
|
|
|
return StrutAreaLeft;
|
|
|
|
}
|
|
|
|
if (margins.right() != 0) {
|
|
|
|
return StrutAreaRight;
|
|
|
|
}
|
|
|
|
if (margins.top() != 0) {
|
|
|
|
return StrutAreaTop;
|
|
|
|
}
|
|
|
|
if (margins.bottom() != 0) {
|
|
|
|
return StrutAreaBottom;
|
|
|
|
}
|
|
|
|
return StrutAreaInvalid;
|
|
|
|
};
|
|
|
|
const auto strut = margins(KWin::screens()->geometry(c->screen()));
|
2019-09-27 10:01:10 +00:00
|
|
|
const StrutRects strutRegion = StrutRects{StrutRect(c->frameGeometry(), marginsToStrutArea(strut))};
|
2016-06-09 08:01:05 +00:00
|
|
|
QRect r = desktopArea - margins(KWin::screens()->geometry());
|
2015-06-08 19:29:07 +00:00
|
|
|
if (c->isOnAllDesktops()) {
|
|
|
|
for (int i = 1; i <= numberOfDesktops; ++i) {
|
2016-06-09 08:01:05 +00:00
|
|
|
new_wareas[ i ] = new_wareas[ i ].intersected(r);
|
2015-06-08 19:29:07 +00:00
|
|
|
for (int iS = 0; iS < nscreens; ++iS) {
|
2016-06-09 08:01:05 +00:00
|
|
|
new_sareas[ i ][ iS ] = new_sareas[ i ][ iS ].intersected(screens[iS] - margins(screens[iS]));
|
2015-06-08 19:29:07 +00:00
|
|
|
}
|
2017-07-10 15:15:52 +00:00
|
|
|
new_rmoveareas[ i ] += strutRegion;
|
2015-06-08 19:29:07 +00:00
|
|
|
}
|
|
|
|
} else {
|
2016-06-09 08:01:05 +00:00
|
|
|
new_wareas[c->desktop()] = new_wareas[c->desktop()].intersected(r);
|
2015-06-08 19:29:07 +00:00
|
|
|
for (int iS = 0; iS < nscreens; iS++) {
|
2016-06-09 08:01:05 +00:00
|
|
|
new_sareas[c->desktop()][ iS ] = new_sareas[c->desktop()][ iS ].intersected(screens[iS] - margins(screens[iS]));
|
2015-06-08 19:29:07 +00:00
|
|
|
}
|
2017-07-10 15:15:52 +00:00
|
|
|
new_rmoveareas[ c->desktop() ] += strutRegion;
|
2015-06-08 19:29:07 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
const auto clients = waylandServer()->clients();
|
|
|
|
for (auto c : clients) {
|
|
|
|
updateStrutsForWaylandClient(c);
|
|
|
|
}
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
#if 0
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int i = 1;
|
2007-04-29 17:35:43 +00:00
|
|
|
i <= numberOfDesktops();
|
2011-01-30 14:34:42 +00:00
|
|
|
++i) {
|
|
|
|
for (int iS = 0;
|
|
|
|
iS < nscreens;
|
|
|
|
iS ++)
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "new_sarea: " << new_sareas[ i ][ iS ];
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
bool changed = force;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (screenarea.isEmpty())
|
2007-04-29 17:35:43 +00:00
|
|
|
changed = true;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int i = 1;
|
2012-11-16 07:23:47 +00:00
|
|
|
!changed && i <= numberOfDesktops;
|
2011-01-30 14:34:42 +00:00
|
|
|
++i) {
|
|
|
|
if (workarea[ i ] != new_wareas[ i ])
|
2008-07-29 13:44:08 +00:00
|
|
|
changed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (restrictedmovearea[ i ] != new_rmoveareas[ i ])
|
2009-02-17 15:50:00 +00:00
|
|
|
changed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (screenarea[ i ].size() != new_sareas[ i ].size())
|
2008-07-29 13:44:08 +00:00
|
|
|
changed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int iS = 0;
|
|
|
|
!changed && iS < nscreens;
|
|
|
|
iS ++)
|
2008-07-29 13:44:08 +00:00
|
|
|
if (new_sareas[ i ][ iS ] != screenarea [ i ][ iS ])
|
2008-07-29 13:36:55 +00:00
|
|
|
changed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (changed) {
|
2007-04-29 17:35:43 +00:00
|
|
|
workarea = new_wareas;
|
2009-02-17 15:50:00 +00:00
|
|
|
oldrestrictedmovearea = restrictedmovearea;
|
|
|
|
restrictedmovearea = new_rmoveareas;
|
2007-04-29 17:35:43 +00:00
|
|
|
screenarea = new_sareas;
|
2017-08-07 04:57:37 +00:00
|
|
|
if (rootInfo()) {
|
|
|
|
NETRect r;
|
|
|
|
for (int i = 1; i <= numberOfDesktops; i++) {
|
|
|
|
r.pos.x = workarea[ i ].x();
|
|
|
|
r.pos.y = workarea[ i ].y();
|
|
|
|
r.size.width = workarea[ i ].width();
|
|
|
|
r.size.height = workarea[ i ].height();
|
|
|
|
rootInfo()->setWorkArea(i, r);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-16 06:34:25 +00:00
|
|
|
for (auto it = m_allClients.constBegin();
|
|
|
|
it != m_allClients.constEnd();
|
2011-01-30 14:34:42 +00:00
|
|
|
++it)
|
2007-04-29 17:35:43 +00:00
|
|
|
(*it)->checkWorkspacePosition();
|
2011-09-29 15:52:19 +00:00
|
|
|
|
2011-09-30 11:22:39 +00:00
|
|
|
oldrestrictedmovearea.clear(); // reset, no longer valid or needed
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
void Workspace::updateClientArea()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
updateClientArea(false);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Returns the area available for clients. This is the desktop
|
|
|
|
* geometry minus windows on the dock. Placement algorithms should
|
|
|
|
* refer to this rather than Screens::geometry.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect Workspace::clientArea(clientAreaOption opt, int screen, int desktop) const
|
|
|
|
{
|
|
|
|
if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
|
2012-11-16 07:23:47 +00:00
|
|
|
desktop = VirtualDesktopManager::self()->current();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (screen == -1)
|
2013-04-03 10:19:27 +00:00
|
|
|
screen = screens()->current();
|
2016-06-08 10:46:02 +00:00
|
|
|
const QSize displaySize = screens()->displaySize();
|
2011-01-30 14:34:42 +00:00
|
|
|
|
2011-05-08 18:39:27 +00:00
|
|
|
QRect sarea, warea;
|
|
|
|
|
|
|
|
if (is_multihead) {
|
|
|
|
sarea = (!screenarea.isEmpty()
|
2011-01-30 14:34:42 +00:00
|
|
|
&& screen < screenarea[ desktop ].size()) // screens may be missing during KWin initialization or screen config changes
|
2011-05-08 18:39:27 +00:00
|
|
|
? screenarea[ desktop ][ screen_number ]
|
2013-04-03 10:19:27 +00:00
|
|
|
: screens()->geometry(screen_number);
|
2011-05-08 18:39:27 +00:00
|
|
|
warea = workarea[ desktop ].isNull()
|
2013-04-03 10:19:27 +00:00
|
|
|
? screens()->geometry(screen_number)
|
2011-05-08 18:39:27 +00:00
|
|
|
: workarea[ desktop ];
|
|
|
|
} else {
|
|
|
|
sarea = (!screenarea.isEmpty()
|
|
|
|
&& screen < screenarea[ desktop ].size()) // screens may be missing during KWin initialization or screen config changes
|
|
|
|
? screenarea[ desktop ][ screen ]
|
2013-04-03 10:19:27 +00:00
|
|
|
: screens()->geometry(screen);
|
2011-05-08 18:39:27 +00:00
|
|
|
warea = workarea[ desktop ].isNull()
|
2016-06-08 10:46:02 +00:00
|
|
|
? QRect(0, 0, displaySize.width(), displaySize.height())
|
2011-05-08 18:39:27 +00:00
|
|
|
: workarea[ desktop ];
|
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
switch(opt) {
|
|
|
|
case MaximizeArea:
|
2012-01-22 10:04:55 +00:00
|
|
|
case PlacementArea:
|
2011-01-30 14:34:42 +00:00
|
|
|
return sarea;
|
|
|
|
case MaximizeFullArea:
|
|
|
|
case FullScreenArea:
|
|
|
|
case MovementArea:
|
2012-01-22 10:04:55 +00:00
|
|
|
case ScreenArea:
|
2011-05-08 18:39:27 +00:00
|
|
|
if (is_multihead)
|
2013-04-03 10:19:27 +00:00
|
|
|
return screens()->geometry(screen_number);
|
2011-01-30 14:34:42 +00:00
|
|
|
else
|
2013-04-03 10:19:27 +00:00
|
|
|
return screens()->geometry(screen);
|
2011-01-30 14:34:42 +00:00
|
|
|
case WorkArea:
|
2011-05-08 18:39:27 +00:00
|
|
|
if (is_multihead)
|
|
|
|
return sarea;
|
|
|
|
else
|
|
|
|
return warea;
|
2011-01-30 14:34:42 +00:00
|
|
|
case FullArea:
|
2016-06-08 10:46:02 +00:00
|
|
|
return QRect(0, 0, displaySize.width(), displaySize.height());
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
abort();
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-05-08 18:39:27 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect Workspace::clientArea(clientAreaOption opt, const QPoint& p, int desktop) const
|
|
|
|
{
|
2013-04-03 10:19:27 +00:00
|
|
|
return clientArea(opt, screens()->number(p), desktop);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-07 12:18:19 +00:00
|
|
|
|
2015-03-06 07:58:59 +00:00
|
|
|
QRect Workspace::clientArea(clientAreaOption opt, const AbstractClient* c) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-27 10:01:10 +00:00
|
|
|
return clientArea(opt, c->frameGeometry().center(), c->desktop());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
QRegion Workspace::restrictedMoveArea(int desktop, StrutAreas areas) const
|
|
|
|
{
|
|
|
|
if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
|
2012-11-16 07:23:47 +00:00
|
|
|
desktop = VirtualDesktopManager::self()->current();
|
2009-02-17 15:50:00 +00:00
|
|
|
QRegion region;
|
2011-01-30 14:34:42 +00:00
|
|
|
foreach (const StrutRect & rect, restrictedmovearea[desktop])
|
|
|
|
if (areas & rect.area())
|
|
|
|
region += rect;
|
2009-02-17 15:50:00 +00:00
|
|
|
return region;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2011-09-30 11:22:39 +00:00
|
|
|
bool Workspace::inUpdateClientArea() const
|
|
|
|
{
|
|
|
|
return !oldrestrictedmovearea.isEmpty();
|
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
QRegion Workspace::previousRestrictedMoveArea(int desktop, StrutAreas areas) const
|
|
|
|
{
|
|
|
|
if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
|
2012-11-16 07:23:47 +00:00
|
|
|
desktop = VirtualDesktopManager::self()->current();
|
2009-02-17 15:50:00 +00:00
|
|
|
QRegion region;
|
2011-01-30 14:34:42 +00:00
|
|
|
foreach (const StrutRect & rect, oldrestrictedmovearea.at(desktop))
|
|
|
|
if (areas & rect.area())
|
|
|
|
region += rect;
|
2009-02-17 15:50:00 +00:00
|
|
|
return region;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-07 12:18:19 +00:00
|
|
|
|
2011-09-30 11:22:39 +00:00
|
|
|
QVector< QRect > Workspace::previousScreenSizes() const
|
2011-09-29 15:52:19 +00:00
|
|
|
{
|
2011-09-30 11:22:39 +00:00
|
|
|
return oldscreensizes;
|
2011-09-29 15:52:19 +00:00
|
|
|
}
|
|
|
|
|
2011-09-30 12:50:18 +00:00
|
|
|
int Workspace::oldDisplayWidth() const
|
|
|
|
{
|
|
|
|
return olddisplaysize.width();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Workspace::oldDisplayHeight() const
|
|
|
|
{
|
|
|
|
return olddisplaysize.height();
|
|
|
|
}
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Client \a c is moved around to position \a pos. This gives the
|
|
|
|
* workspace the opportunity to interveniate and to implement
|
|
|
|
* snap-to-windows functionality.
|
|
|
|
*
|
|
|
|
* The parameter \a snapAdjust is a multiplier used to calculate the
|
|
|
|
* effective snap zones. When 1.0, it means that the snap zones will be
|
|
|
|
* used without change.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2015-09-18 11:46:42 +00:00
|
|
|
QPoint Workspace::adjustClientPosition(AbstractClient* c, QPoint pos, bool unrestricted, double snapAdjust)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-04-10 12:57:18 +00:00
|
|
|
QSize borderSnapZone(options->borderSnapZone(), options->borderSnapZone());
|
|
|
|
QRect maxRect;
|
2014-12-02 12:49:08 +00:00
|
|
|
int guideMaximized = MaximizeRestore;
|
|
|
|
if (c->maximizeMode() != MaximizeRestore) {
|
2013-08-27 21:46:55 +00:00
|
|
|
maxRect = clientArea(MaximizeArea, pos + c->rect().center(), c->desktop());
|
2019-09-27 10:01:10 +00:00
|
|
|
QRect geo = c->frameGeometry();
|
2014-12-02 12:49:08 +00:00
|
|
|
if (c->maximizeMode() & MaximizeHorizontal && (geo.x() == maxRect.left() || geo.right() == maxRect.right())) {
|
|
|
|
guideMaximized |= MaximizeHorizontal;
|
2013-04-10 12:57:18 +00:00
|
|
|
borderSnapZone.setWidth(qMax(borderSnapZone.width() + 2, maxRect.width() / 16));
|
|
|
|
}
|
2014-12-02 12:49:08 +00:00
|
|
|
if (c->maximizeMode() & MaximizeVertical && (geo.y() == maxRect.top() || geo.bottom() == maxRect.bottom())) {
|
|
|
|
guideMaximized |= MaximizeVertical;
|
2013-04-10 12:57:18 +00:00
|
|
|
borderSnapZone.setHeight(qMax(borderSnapZone.height() + 2, maxRect.height() / 16));
|
|
|
|
}
|
|
|
|
}
|
2013-02-17 00:56:01 +00:00
|
|
|
|
2013-04-10 12:57:18 +00:00
|
|
|
if (options->windowSnapZone() || !borderSnapZone.isNull() || options->centerSnapZone()) {
|
2013-02-17 00:56:01 +00:00
|
|
|
|
2012-02-20 09:25:13 +00:00
|
|
|
const bool sOWO = options->isSnapOnlyWhenOverlapping();
|
2013-08-15 09:54:46 +00:00
|
|
|
const int screen = screens()->number(pos + c->rect().center());
|
2013-04-10 12:57:18 +00:00
|
|
|
if (maxRect.isNull())
|
2013-08-15 09:54:46 +00:00
|
|
|
maxRect = clientArea(MovementArea, screen, c->desktop());
|
2007-04-29 17:35:43 +00:00
|
|
|
const int xmin = maxRect.left();
|
2011-01-30 14:34:42 +00:00
|
|
|
const int xmax = maxRect.right() + 1; //desk size
|
2007-04-29 17:35:43 +00:00
|
|
|
const int ymin = maxRect.top();
|
2011-01-30 14:34:42 +00:00
|
|
|
const int ymax = maxRect.bottom() + 1;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
const int cx(pos.x());
|
|
|
|
const int cy(pos.y());
|
|
|
|
const int cw(c->width());
|
|
|
|
const int ch(c->height());
|
2011-01-30 14:34:42 +00:00
|
|
|
const int rx(cx + cw);
|
|
|
|
const int ry(cy + ch); //these don't change
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
int nx(cx), ny(cy); //buffers
|
|
|
|
int deltaX(xmax);
|
|
|
|
int deltaY(ymax); //minimum distance to other clients
|
|
|
|
|
|
|
|
int lx, ly, lrx, lry; //coords and size for the comparison client, l
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// border snap
|
2013-04-10 12:57:18 +00:00
|
|
|
const int snapX = borderSnapZone.width() * snapAdjust; //snap trigger
|
|
|
|
const int snapY = borderSnapZone.height() * snapAdjust;
|
|
|
|
if (snapX || snapY) {
|
2019-09-27 10:01:10 +00:00
|
|
|
QRect geo = c->frameGeometry();
|
2019-09-24 13:24:06 +00:00
|
|
|
QMargins frameMargins = c->frameMargins();
|
2013-02-17 00:56:01 +00:00
|
|
|
|
2013-08-15 09:54:46 +00:00
|
|
|
// snap to titlebar / snap to window borders on inner screen edges
|
2019-04-23 22:49:10 +00:00
|
|
|
AbstractClient::Position titlePos = c->titlebarPosition();
|
2019-09-24 13:24:06 +00:00
|
|
|
if (frameMargins.left() && (titlePos == AbstractClient::PositionLeft || (c->maximizeMode() & MaximizeHorizontal) ||
|
|
|
|
screens()->intersecting(geo.translated(maxRect.x() - (frameMargins.left() + geo.x()), 0)) > 1)) {
|
|
|
|
frameMargins.setLeft(0);
|
|
|
|
}
|
|
|
|
if (frameMargins.right() && (titlePos == AbstractClient::PositionRight || (c->maximizeMode() & MaximizeHorizontal) ||
|
|
|
|
screens()->intersecting(geo.translated(maxRect.right() + frameMargins.right() - geo.right(), 0)) > 1)) {
|
|
|
|
frameMargins.setRight(0);
|
|
|
|
}
|
|
|
|
if (frameMargins.top() && (titlePos == AbstractClient::PositionTop || (c->maximizeMode() & MaximizeVertical) ||
|
|
|
|
screens()->intersecting(geo.translated(0, maxRect.y() - (frameMargins.top() + geo.y()))) > 1)) {
|
|
|
|
frameMargins.setTop(0);
|
|
|
|
}
|
|
|
|
if (frameMargins.bottom() && (titlePos == AbstractClient::PositionBottom || (c->maximizeMode() & MaximizeVertical) ||
|
|
|
|
screens()->intersecting(geo.translated(0, maxRect.bottom() + frameMargins.bottom() - geo.bottom())) > 1)) {
|
|
|
|
frameMargins.setBottom(0);
|
|
|
|
}
|
2013-04-10 12:57:18 +00:00
|
|
|
if ((sOWO ? (cx < xmin) : true) && (qAbs(xmin - cx) < snapX)) {
|
2013-06-19 19:28:21 +00:00
|
|
|
deltaX = xmin - cx;
|
2019-09-24 13:24:06 +00:00
|
|
|
nx = xmin - frameMargins.left();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-04-10 12:57:18 +00:00
|
|
|
if ((sOWO ? (rx > xmax) : true) && (qAbs(rx - xmax) < snapX) && (qAbs(xmax - rx) < deltaX)) {
|
2013-06-19 19:28:21 +00:00
|
|
|
deltaX = rx - xmax;
|
2019-09-24 13:24:06 +00:00
|
|
|
nx = xmax - cw + frameMargins.right();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-04-10 12:57:18 +00:00
|
|
|
if ((sOWO ? (cy < ymin) : true) && (qAbs(ymin - cy) < snapY)) {
|
2013-06-19 19:28:21 +00:00
|
|
|
deltaY = ymin - cy;
|
2019-09-24 13:24:06 +00:00
|
|
|
ny = ymin - frameMargins.top();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-04-10 12:57:18 +00:00
|
|
|
if ((sOWO ? (ry > ymax) : true) && (qAbs(ry - ymax) < snapY) && (qAbs(ymax - ry) < deltaY)) {
|
2013-06-19 19:28:21 +00:00
|
|
|
deltaY = ry - ymax;
|
2019-09-24 13:24:06 +00:00
|
|
|
ny = ymax - ch + frameMargins.bottom();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// windows snap
|
2013-04-10 12:57:18 +00:00
|
|
|
int snap = options->windowSnapZone() * snapAdjust;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (snap) {
|
2015-09-18 11:46:42 +00:00
|
|
|
for (auto l = m_allClients.constBegin(); l != m_allClients.constEnd(); ++l) {
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((*l) == c)
|
|
|
|
continue;
|
|
|
|
if ((*l)->isMinimized())
|
|
|
|
continue; // is minimized
|
2016-11-02 11:35:47 +00:00
|
|
|
if (!(*l)->isShown(false))
|
|
|
|
continue;
|
2013-06-19 19:17:31 +00:00
|
|
|
if (!((*l)->isOnDesktop(c->desktop()) || c->isOnDesktop((*l)->desktop())))
|
|
|
|
continue; // wrong virtual desktop
|
|
|
|
if (!(*l)->isOnCurrentActivity())
|
|
|
|
continue; // wrong activity
|
|
|
|
if ((*l)->isDesktop() || (*l)->isSplash())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
lx = (*l)->x();
|
|
|
|
ly = (*l)->y();
|
|
|
|
lrx = lx + (*l)->width();
|
|
|
|
lry = ly + (*l)->height();
|
|
|
|
|
2014-12-02 12:49:08 +00:00
|
|
|
if (!(guideMaximized & MaximizeHorizontal) &&
|
2013-08-16 19:21:21 +00:00
|
|
|
(((cy <= lry) && (cy >= ly)) || ((ry >= ly) && (ry <= lry)) || ((cy <= ly) && (ry >= lry)))) {
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (cx < lrx) : true) && (qAbs(lrx - cx) < snap) && (qAbs(lrx - cx) < deltaX)) {
|
|
|
|
deltaX = qAbs(lrx - cx);
|
|
|
|
nx = lrx;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (rx > lx) : true) && (qAbs(rx - lx) < snap) && (qAbs(rx - lx) < deltaX)) {
|
|
|
|
deltaX = qAbs(rx - lx);
|
|
|
|
nx = lx - cw;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-12-02 12:49:08 +00:00
|
|
|
if (!(guideMaximized & MaximizeVertical) &&
|
2013-08-16 19:21:21 +00:00
|
|
|
(((cx <= lrx) && (cx >= lx)) || ((rx >= lx) && (rx <= lrx)) || ((cx <= lx) && (rx >= lrx)))) {
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (cy < lry) : true) && (qAbs(lry - cy) < snap) && (qAbs(lry - cy) < deltaY)) {
|
|
|
|
deltaY = qAbs(lry - cy);
|
|
|
|
ny = lry;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
//if ( (qAbs( ry-ly ) < snap) && (qAbs( ry - ly ) < deltaY ))
|
|
|
|
if ((sOWO ? (ry > ly) : true) && (qAbs(ry - ly) < snap) && (qAbs(ry - ly) < deltaY)) {
|
|
|
|
deltaY = qAbs(ry - ly);
|
|
|
|
ny = ly - ch;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
}
|
2008-07-25 10:19:28 +00:00
|
|
|
|
2013-06-19 19:17:31 +00:00
|
|
|
// Corner snapping
|
2014-12-02 12:49:08 +00:00
|
|
|
if (!(guideMaximized & MaximizeVertical) && (nx == lrx || nx + cw == lx)) {
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (ry > lry) : true) && (qAbs(lry - ry) < snap) && (qAbs(lry - ry) < deltaY)) {
|
|
|
|
deltaY = qAbs(lry - ry);
|
|
|
|
ny = lry - ch;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (cy < ly) : true) && (qAbs(cy - ly) < snap) && (qAbs(cy - ly) < deltaY)) {
|
|
|
|
deltaY = qAbs(cy - ly);
|
|
|
|
ny = ly;
|
|
|
|
}
|
|
|
|
}
|
2014-12-02 12:49:08 +00:00
|
|
|
if (!(guideMaximized & MaximizeHorizontal) && (ny == lry || ny + ch == ly)) {
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (rx > lrx) : true) && (qAbs(lrx - rx) < snap) && (qAbs(lrx - rx) < deltaX)) {
|
|
|
|
deltaX = qAbs(lrx - rx);
|
|
|
|
nx = lrx - cw;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-06-19 19:17:31 +00:00
|
|
|
if ((sOWO ? (cx < lx) : true) && (qAbs(cx - lx) < snap) && (qAbs(cx - lx) < deltaX)) {
|
|
|
|
deltaX = qAbs(cx - lx);
|
|
|
|
nx = lx;
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-07-09 15:18:47 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// center snap
|
2012-02-20 09:25:13 +00:00
|
|
|
snap = options->centerSnapZone() * snapAdjust; //snap trigger
|
2011-01-30 14:34:42 +00:00
|
|
|
if (snap) {
|
|
|
|
int diffX = qAbs((xmin + xmax) / 2 - (cx + cw / 2));
|
|
|
|
int diffY = qAbs((ymin + ymax) / 2 - (cy + ch / 2));
|
|
|
|
if (diffX < snap && diffY < snap && diffX < deltaX && diffY < deltaY) {
|
|
|
|
// Snap to center of screen
|
|
|
|
nx = (xmin + xmax) / 2 - cw / 2;
|
|
|
|
ny = (ymin + ymax) / 2 - ch / 2;
|
2013-04-10 12:57:18 +00:00
|
|
|
} else if (options->borderSnapZone()) {
|
2011-01-30 14:34:42 +00:00
|
|
|
// Enhance border snap
|
|
|
|
if ((nx == xmin || nx == xmax - cw) && diffY < snap && diffY < deltaY) {
|
|
|
|
// Snap to vertical center on screen edge
|
|
|
|
ny = (ymin + ymax) / 2 - ch / 2;
|
|
|
|
} else if (((unrestricted ? ny == ymin : ny <= ymin) || ny == ymax - ch) &&
|
|
|
|
diffX < snap && diffX < deltaX) {
|
|
|
|
// Snap to horizontal center on screen edge
|
|
|
|
nx = (xmin + xmax) / 2 - cw / 2;
|
2008-07-09 15:18:47 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-07-09 15:18:47 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
pos = QPoint(nx, ny);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
return pos;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-09-18 12:05:19 +00:00
|
|
|
QRect Workspace::adjustClientSize(AbstractClient* c, QRect moveResizeGeom, int mode)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
//adapted from adjustClientPosition on 29May2004
|
|
|
|
//this function is called when resizing a window and will modify
|
|
|
|
//the new dimensions to snap to other windows/borders if appropriate
|
2012-02-20 09:25:13 +00:00
|
|
|
if (options->windowSnapZone() || options->borderSnapZone()) { // || options->centerSnapZone )
|
|
|
|
const bool sOWO = options->isSnapOnlyWhenOverlapping();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
const QRect maxRect = clientArea(MovementArea, c->rect().center(), c->desktop());
|
|
|
|
const int xmin = maxRect.left();
|
|
|
|
const int xmax = maxRect.right(); //desk size
|
|
|
|
const int ymin = maxRect.top();
|
|
|
|
const int ymax = maxRect.bottom();
|
|
|
|
|
|
|
|
const int cx(moveResizeGeom.left());
|
|
|
|
const int cy(moveResizeGeom.top());
|
|
|
|
const int rx(moveResizeGeom.right());
|
|
|
|
const int ry(moveResizeGeom.bottom());
|
|
|
|
|
|
|
|
int newcx(cx), newcy(cy); //buffers
|
|
|
|
int newrx(rx), newry(ry);
|
|
|
|
int deltaX(xmax);
|
|
|
|
int deltaY(ymax); //minimum distance to other clients
|
|
|
|
|
|
|
|
int lx, ly, lrx, lry; //coords and size for the comparison client, l
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// border snap
|
2012-02-20 09:25:13 +00:00
|
|
|
int snap = options->borderSnapZone(); //snap trigger
|
2011-01-30 14:34:42 +00:00
|
|
|
if (snap) {
|
2007-04-29 17:35:43 +00:00
|
|
|
deltaX = int(snap);
|
|
|
|
deltaY = int(snap);
|
|
|
|
|
|
|
|
#define SNAP_BORDER_TOP \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((sOWO?(newcy<ymin):true) && (qAbs(ymin-newcy)<deltaY)) \
|
|
|
|
{ \
|
|
|
|
deltaY = qAbs(ymin-newcy); \
|
|
|
|
newcy = ymin; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_BORDER_BOTTOM \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((sOWO?(newry>ymax):true) && (qAbs(ymax-newry)<deltaY)) \
|
|
|
|
{ \
|
|
|
|
deltaY = qAbs(ymax-newcy); \
|
|
|
|
newry = ymax; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_BORDER_LEFT \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((sOWO?(newcx<xmin):true) && (qAbs(xmin-newcx)<deltaX)) \
|
|
|
|
{ \
|
|
|
|
deltaX = qAbs(xmin-newcx); \
|
|
|
|
newcx = xmin; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_BORDER_RIGHT \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((sOWO?(newrx>xmax):true) && (qAbs(xmax-newrx)<deltaX)) \
|
|
|
|
{ \
|
|
|
|
deltaX = qAbs(xmax-newrx); \
|
|
|
|
newrx = xmax; \
|
|
|
|
}
|
|
|
|
switch(mode) {
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottomRight:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_BOTTOM
|
|
|
|
SNAP_BORDER_RIGHT
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionRight:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_RIGHT
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottom:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_BOTTOM
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTopLeft:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_TOP
|
|
|
|
SNAP_BORDER_LEFT
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionLeft:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_LEFT
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTop:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_TOP
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTopRight:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_TOP
|
|
|
|
SNAP_BORDER_RIGHT
|
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottomLeft:
|
2011-01-30 14:34:42 +00:00
|
|
|
SNAP_BORDER_BOTTOM
|
|
|
|
SNAP_BORDER_LEFT
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
break;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// windows snap
|
2012-02-20 09:25:13 +00:00
|
|
|
snap = options->windowSnapZone();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (snap) {
|
2007-04-29 17:35:43 +00:00
|
|
|
deltaX = int(snap);
|
|
|
|
deltaY = int(snap);
|
2015-09-18 12:05:19 +00:00
|
|
|
for (auto l = m_allClients.constBegin(); l != m_allClients.constEnd(); ++l) {
|
2012-11-16 07:23:47 +00:00
|
|
|
if ((*l)->isOnDesktop(VirtualDesktopManager::self()->current()) &&
|
2011-01-30 14:34:42 +00:00
|
|
|
!(*l)->isMinimized()
|
|
|
|
&& (*l) != c) {
|
|
|
|
lx = (*l)->x() - 1;
|
|
|
|
ly = (*l)->y() - 1;
|
|
|
|
lrx = (*l)->x() + (*l)->width();
|
|
|
|
lry = (*l)->y() + (*l)->height();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define WITHIN_HEIGHT ((( newcy <= lry ) && ( newcy >= ly )) || \
|
2011-01-30 14:34:42 +00:00
|
|
|
(( newry >= ly ) && ( newry <= lry )) || \
|
|
|
|
(( newcy <= ly ) && ( newry >= lry )) )
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define WITHIN_WIDTH ( (( cx <= lrx ) && ( cx >= lx )) || \
|
2011-01-30 14:34:42 +00:00
|
|
|
(( rx >= lx ) && ( rx <= lrx )) || \
|
|
|
|
(( cx <= lx ) && ( rx >= lrx )) )
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_TOP if ( (sOWO?(newcy<lry):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& WITHIN_WIDTH \
|
|
|
|
&& (qAbs( lry - newcy ) < deltaY) ) { \
|
|
|
|
deltaY = qAbs( lry - newcy ); \
|
|
|
|
newcy=lry; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_BOTTOM if ( (sOWO?(newry>ly):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& WITHIN_WIDTH \
|
|
|
|
&& (qAbs( ly - newry ) < deltaY) ) { \
|
|
|
|
deltaY = qAbs( ly - newry ); \
|
|
|
|
newry=ly; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_LEFT if ( (sOWO?(newcx<lrx):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& WITHIN_HEIGHT \
|
|
|
|
&& (qAbs( lrx - newcx ) < deltaX)) { \
|
|
|
|
deltaX = qAbs( lrx - newcx ); \
|
|
|
|
newcx=lrx; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_RIGHT if ( (sOWO?(newrx>lx):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& WITHIN_HEIGHT \
|
|
|
|
&& (qAbs( lx - newrx ) < deltaX)) \
|
|
|
|
{ \
|
|
|
|
deltaX = qAbs( lx - newrx ); \
|
|
|
|
newrx=lx; \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2008-07-25 10:19:28 +00:00
|
|
|
#define SNAP_WINDOW_C_TOP if ( (sOWO?(newcy<ly):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& (newcx == lrx || newrx == lx) \
|
|
|
|
&& qAbs(ly-newcy) < deltaY ) { \
|
|
|
|
deltaY = qAbs( ly - newcy + 1 ); \
|
|
|
|
newcy = ly + 1; \
|
|
|
|
}
|
2008-07-25 10:19:28 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_C_BOTTOM if ( (sOWO?(newry>lry):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& (newcx == lrx || newrx == lx) \
|
|
|
|
&& qAbs(lry-newry) < deltaY ) { \
|
|
|
|
deltaY = qAbs( lry - newry - 1 ); \
|
|
|
|
newry = lry - 1; \
|
|
|
|
}
|
2008-07-25 10:19:28 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_C_LEFT if ( (sOWO?(newcx<lx):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& (newcy == lry || newry == ly) \
|
|
|
|
&& qAbs(lx-newcx) < deltaX ) { \
|
|
|
|
deltaX = qAbs( lx - newcx + 1 ); \
|
|
|
|
newcx = lx + 1; \
|
|
|
|
}
|
2008-07-25 10:19:28 +00:00
|
|
|
|
|
|
|
#define SNAP_WINDOW_C_RIGHT if ( (sOWO?(newrx>lrx):true) \
|
2011-01-30 14:34:42 +00:00
|
|
|
&& (newcy == lry || newry == ly) \
|
|
|
|
&& qAbs(lrx-newrx) < deltaX ) { \
|
|
|
|
deltaX = qAbs( lrx - newrx - 1 ); \
|
|
|
|
newrx = lrx - 1; \
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(mode) {
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottomRight:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_BOTTOM
|
|
|
|
SNAP_WINDOW_RIGHT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_BOTTOM
|
|
|
|
SNAP_WINDOW_C_RIGHT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionRight:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_RIGHT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_RIGHT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottom:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_BOTTOM
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_BOTTOM
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTopLeft:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_TOP
|
|
|
|
SNAP_WINDOW_LEFT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_TOP
|
|
|
|
SNAP_WINDOW_C_LEFT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionLeft:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_LEFT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_LEFT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTop:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_TOP
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_TOP
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionTopRight:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_TOP
|
|
|
|
SNAP_WINDOW_RIGHT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_TOP
|
|
|
|
SNAP_WINDOW_C_RIGHT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2019-04-23 22:49:10 +00:00
|
|
|
case AbstractClient::PositionBottomLeft:
|
2007-04-29 17:35:43 +00:00
|
|
|
SNAP_WINDOW_BOTTOM
|
|
|
|
SNAP_WINDOW_LEFT
|
2008-07-25 10:19:28 +00:00
|
|
|
SNAP_WINDOW_C_BOTTOM
|
|
|
|
SNAP_WINDOW_C_LEFT
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
2011-01-30 14:34:42 +00:00
|
|
|
default:
|
2008-09-17 11:44:51 +00:00
|
|
|
abort();
|
2007-04-29 17:35:43 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-07-09 15:18:47 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
// center snap
|
2008-07-09 15:18:47 +00:00
|
|
|
//snap = options->centerSnapZone;
|
|
|
|
//if (snap)
|
|
|
|
// {
|
|
|
|
// // Don't resize snap to center as it interferes too much
|
|
|
|
// // There are two ways of implementing this if wanted:
|
|
|
|
// // 1) Snap only to the same points that the move snap does, and
|
|
|
|
// // 2) Snap to the horizontal and vertical center lines of the screen
|
|
|
|
// }
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
moveResizeGeom = QRect(QPoint(newcx, newcy), QPoint(newrx, newry));
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
return moveResizeGeom;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
2019-04-18 12:28:11 +00:00
|
|
|
* Marks the client as being moved or resized by the user.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-04-18 12:28:11 +00:00
|
|
|
void Workspace::setMoveResizeClient(AbstractClient *c)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
Q_ASSERT(!c || !movingClient); // Catch attempts to move a second
|
|
|
|
// window while still moving the first one.
|
|
|
|
movingClient = c;
|
|
|
|
if (movingClient)
|
|
|
|
++block_focus;
|
|
|
|
else
|
|
|
|
--block_focus;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2009-02-12 10:01:40 +00:00
|
|
|
// When kwin crashes, windows will not be gravitated back to their original position
|
|
|
|
// and will remain offset by the size of the decoration. So when restarting, fix this
|
|
|
|
// (the property with the size of the frame remains on the window after the crash).
|
2012-03-26 15:30:34 +00:00
|
|
|
void Workspace::fixPositionAfterCrash(xcb_window_t w, const xcb_get_geometry_reply_t *geometry)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-19 15:16:14 +00:00
|
|
|
NETWinInfo i(connection(), w, rootWindow(), NET::WMFrameExtents, NET::Properties2());
|
2009-02-12 10:01:40 +00:00
|
|
|
NETStrut frame = i.frameExtents();
|
2012-03-26 15:30:34 +00:00
|
|
|
|
|
|
|
if (frame.left != 0 || frame.top != 0) {
|
2012-11-26 10:04:30 +00:00
|
|
|
// left and top needed due to narrowing conversations restrictions in C++11
|
|
|
|
const uint32_t left = frame.left;
|
|
|
|
const uint32_t top = frame.top;
|
|
|
|
const uint32_t values[] = { geometry->x - left, geometry->y - top };
|
2012-03-26 15:30:34 +00:00
|
|
|
xcb_configure_window(connection(), w, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-02-12 10:01:40 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
//********************************************
|
|
|
|
// Client
|
|
|
|
//********************************************
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Returns \a area with the client's strut taken into account.
|
|
|
|
*
|
|
|
|
* Used from Workspace in updateClientArea.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
// TODO move to Workspace?
|
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
QRect X11Client::adjustedClientArea(const QRect &desktopArea, const QRect& area) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
QRect r = area;
|
|
|
|
NETExtendedStrut str = strut();
|
|
|
|
QRect stareaL = QRect(
|
2011-01-30 14:34:42 +00:00
|
|
|
0,
|
|
|
|
str . left_start,
|
|
|
|
str . left_width,
|
|
|
|
str . left_end - str . left_start + 1);
|
|
|
|
QRect stareaR = QRect(
|
|
|
|
desktopArea . right() - str . right_width + 1,
|
|
|
|
str . right_start,
|
|
|
|
str . right_width,
|
|
|
|
str . right_end - str . right_start + 1);
|
|
|
|
QRect stareaT = QRect(
|
|
|
|
str . top_start,
|
|
|
|
0,
|
|
|
|
str . top_end - str . top_start + 1,
|
|
|
|
str . top_width);
|
|
|
|
QRect stareaB = QRect(
|
|
|
|
str . bottom_start,
|
|
|
|
desktopArea . bottom() - str . bottom_width + 1,
|
|
|
|
str . bottom_end - str . bottom_start + 1,
|
|
|
|
str . bottom_width);
|
|
|
|
|
|
|
|
QRect screenarea = workspace()->clientArea(ScreenArea, this);
|
2007-04-29 17:35:43 +00:00
|
|
|
// HACK: workarea handling is not xinerama aware, so if this strut
|
|
|
|
// reserves place at a xinerama edge that's inside the virtual screen,
|
|
|
|
// ignore the strut for workspace setting.
|
2016-06-08 10:46:02 +00:00
|
|
|
if (area == QRect(QPoint(0, 0), screens()->displaySize())) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaL.left() < screenarea.left())
|
2007-04-29 17:35:43 +00:00
|
|
|
stareaL = QRect();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaR.right() > screenarea.right())
|
2007-04-29 17:35:43 +00:00
|
|
|
stareaR = QRect();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaT.top() < screenarea.top())
|
2007-04-29 17:35:43 +00:00
|
|
|
stareaT = QRect();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaB.bottom() < screenarea.bottom())
|
2007-04-29 17:35:43 +00:00
|
|
|
stareaB = QRect();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
// Handle struts at xinerama edges that are inside the virtual screen.
|
|
|
|
// They're given in virtual screen coordinates, make them affect only
|
|
|
|
// their xinerama screen.
|
2011-01-30 14:34:42 +00:00
|
|
|
stareaL.setLeft(qMax(stareaL.left(), screenarea.left()));
|
|
|
|
stareaR.setRight(qMin(stareaR.right(), screenarea.right()));
|
|
|
|
stareaT.setTop(qMax(stareaT.top(), screenarea.top()));
|
|
|
|
stareaB.setBottom(qMin(stareaB.bottom(), screenarea.bottom()));
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaL . intersects(area)) {
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "Moving left of: " << r << " to " << stareaL.right() + 1;
|
2011-01-30 14:34:42 +00:00
|
|
|
r . setLeft(stareaL . right() + 1);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaR . intersects(area)) {
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "Moving right of: " << r << " to " << stareaR.left() - 1;
|
2011-01-30 14:34:42 +00:00
|
|
|
r . setRight(stareaR . left() - 1);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaT . intersects(area)) {
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "Moving top of: " << r << " to " << stareaT.bottom() + 1;
|
2011-01-30 14:34:42 +00:00
|
|
|
r . setTop(stareaT . bottom() + 1);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (stareaB . intersects(area)) {
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "Moving bottom of: " << r << " to " << stareaB.top() - 1;
|
2011-01-30 14:34:42 +00:00
|
|
|
r . setBottom(stareaB . top() - 1);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2016-04-11 15:24:08 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
return r;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
NETExtendedStrut X11Client::strut() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
NETExtendedStrut ext = info->extendedStrut();
|
|
|
|
NETStrut str = info->strut();
|
2016-06-08 10:46:02 +00:00
|
|
|
const QSize displaySize = screens()->displaySize();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
|
|
|
|
&& (str.left != 0 || str.right != 0 || str.top != 0 || str.bottom != 0)) {
|
2007-04-29 17:35:43 +00:00
|
|
|
// build extended from simple
|
2011-01-30 14:34:42 +00:00
|
|
|
if (str.left != 0) {
|
2007-04-29 17:35:43 +00:00
|
|
|
ext.left_width = str.left;
|
|
|
|
ext.left_start = 0;
|
2016-06-08 10:46:02 +00:00
|
|
|
ext.left_end = displaySize.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (str.right != 0) {
|
2007-04-29 17:35:43 +00:00
|
|
|
ext.right_width = str.right;
|
|
|
|
ext.right_start = 0;
|
2016-06-08 10:46:02 +00:00
|
|
|
ext.right_end = displaySize.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (str.top != 0) {
|
2007-04-29 17:35:43 +00:00
|
|
|
ext.top_width = str.top;
|
|
|
|
ext.top_start = 0;
|
2016-06-08 10:46:02 +00:00
|
|
|
ext.top_end = displaySize.width();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (str.bottom != 0) {
|
2007-04-29 17:35:43 +00:00
|
|
|
ext.bottom_width = str.bottom;
|
|
|
|
ext.bottom_start = 0;
|
2016-06-08 10:46:02 +00:00
|
|
|
ext.bottom_end = displaySize.width();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
return ext;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
StrutRect X11Client::strutRect(StrutArea area) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(area != StrutAreaAll); // Not valid
|
2016-06-08 10:46:02 +00:00
|
|
|
const QSize displaySize = screens()->displaySize();
|
2009-02-17 15:50:00 +00:00
|
|
|
NETExtendedStrut strutArea = strut();
|
2011-01-30 14:34:42 +00:00
|
|
|
switch(area) {
|
|
|
|
case StrutAreaTop:
|
|
|
|
if (strutArea.top_width != 0)
|
|
|
|
return StrutRect(QRect(
|
|
|
|
strutArea.top_start, 0,
|
|
|
|
strutArea.top_end - strutArea.top_start, strutArea.top_width
|
|
|
|
), StrutAreaTop);
|
|
|
|
break;
|
|
|
|
case StrutAreaRight:
|
|
|
|
if (strutArea.right_width != 0)
|
|
|
|
return StrutRect(QRect(
|
2016-06-08 10:46:02 +00:00
|
|
|
displaySize.width() - strutArea.right_width, strutArea.right_start,
|
2011-01-30 14:34:42 +00:00
|
|
|
strutArea.right_width, strutArea.right_end - strutArea.right_start
|
|
|
|
), StrutAreaRight);
|
|
|
|
break;
|
|
|
|
case StrutAreaBottom:
|
|
|
|
if (strutArea.bottom_width != 0)
|
|
|
|
return StrutRect(QRect(
|
2016-06-08 10:46:02 +00:00
|
|
|
strutArea.bottom_start, displaySize.height() - strutArea.bottom_width,
|
2011-01-30 14:34:42 +00:00
|
|
|
strutArea.bottom_end - strutArea.bottom_start, strutArea.bottom_width
|
|
|
|
), StrutAreaBottom);
|
|
|
|
break;
|
|
|
|
case StrutAreaLeft:
|
|
|
|
if (strutArea.left_width != 0)
|
|
|
|
return StrutRect(QRect(
|
|
|
|
0, strutArea.left_start,
|
|
|
|
strutArea.left_width, strutArea.left_end - strutArea.left_start
|
|
|
|
), StrutAreaLeft);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort(); // Not valid
|
2009-02-17 15:50:00 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
return StrutRect(); // Null rect
|
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
StrutRects X11Client::strutRects() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2009-02-17 15:50:00 +00:00
|
|
|
StrutRects region;
|
2011-01-30 14:34:42 +00:00
|
|
|
region += strutRect(StrutAreaTop);
|
|
|
|
region += strutRect(StrutAreaRight);
|
|
|
|
region += strutRect(StrutAreaBottom);
|
|
|
|
region += strutRect(StrutAreaLeft);
|
2009-02-17 15:50:00 +00:00
|
|
|
return region;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::hasStrut() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
NETExtendedStrut ext = strut();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0)
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::hasOffscreenXineramaStrut() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2009-02-17 15:50:00 +00:00
|
|
|
// Get strut as a QRegion
|
|
|
|
QRegion region;
|
2011-01-30 14:34:42 +00:00
|
|
|
region += strutRect(StrutAreaTop);
|
|
|
|
region += strutRect(StrutAreaRight);
|
|
|
|
region += strutRect(StrutAreaBottom);
|
|
|
|
region += strutRect(StrutAreaLeft);
|
2009-02-15 16:37:42 +00:00
|
|
|
|
|
|
|
// Remove all visible areas so that only the invisible remain
|
2013-04-03 10:19:27 +00:00
|
|
|
for (int i = 0; i < screens()->count(); i ++)
|
|
|
|
region -= screens()->geometry(i);
|
2009-02-15 16:37:42 +00:00
|
|
|
|
|
|
|
// If there's anything left then we have an offscreen strut
|
2009-02-17 15:50:00 +00:00
|
|
|
return !region.isEmpty();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-13 08:59:51 +00:00
|
|
|
void AbstractClient::checkWorkspacePosition(QRect oldGeometry, int oldDesktop, QRect oldClientGeometry)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
enum { Left = 0, Top, Right, Bottom };
|
|
|
|
const int border[4] = { borderLeft(), borderTop(), borderRight(), borderBottom() };
|
2011-09-29 15:52:19 +00:00
|
|
|
if( !oldGeometry.isValid())
|
2019-09-27 10:01:10 +00:00
|
|
|
oldGeometry = frameGeometry();
|
2011-09-29 15:52:19 +00:00
|
|
|
if( oldDesktop == -2 )
|
|
|
|
oldDesktop = desktop();
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
if (!oldClientGeometry.isValid())
|
|
|
|
oldClientGeometry = oldGeometry.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isDesktop())
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isFullScreen()) {
|
|
|
|
QRect area = workspace()->clientArea(FullScreenArea, this);
|
2019-09-27 10:01:10 +00:00
|
|
|
if (frameGeometry() != area)
|
|
|
|
setFrameGeometry(area);
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (isDock())
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-10 00:24:54 +00:00
|
|
|
if (maximizeMode() != MaximizeRestore) {
|
2011-01-30 14:34:42 +00:00
|
|
|
// TODO update geom_restore?
|
|
|
|
changeMaximize(false, false, true); // adjust size
|
2011-09-29 15:39:04 +00:00
|
|
|
const QRect screenArea = workspace()->clientArea(ScreenArea, this);
|
2019-09-27 10:01:10 +00:00
|
|
|
QRect geom = frameGeometry();
|
2011-09-29 13:17:59 +00:00
|
|
|
checkOffscreenPosition(&geom, screenArea);
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(geom);
|
2011-07-10 00:24:54 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(electricBorderMaximizeGeometry(frameGeometry().center(), desktop()));
|
2011-07-10 00:24:54 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-05-07 13:13:48 +00:00
|
|
|
|
2013-03-22 23:42:45 +00:00
|
|
|
// this can be true only if this window was mapped before KWin
|
|
|
|
// was started - in such case, don't adjust position to workarea,
|
|
|
|
// because the window already had its position, and if a window
|
|
|
|
// with a strut altering the workarea would be managed in initialization
|
|
|
|
// after this one, this window would be moved
|
2016-02-04 10:16:55 +00:00
|
|
|
if (!workspace() || workspace()->initializing())
|
2013-03-22 23:42:45 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// If the window was touching an edge before but not now move it so it is again.
|
|
|
|
// Old and new maximums have different starting values so windows on the screen
|
|
|
|
// edge will move when a new strut is placed on the edge.
|
|
|
|
QRect oldScreenArea;
|
|
|
|
if( workspace()->inUpdateClientArea()) {
|
|
|
|
// we need to find the screen area as it was before the change
|
|
|
|
oldScreenArea = QRect( 0, 0, workspace()->oldDisplayWidth(), workspace()->oldDisplayHeight());
|
|
|
|
int distance = INT_MAX;
|
|
|
|
foreach(const QRect &r, workspace()->previousScreenSizes()) {
|
|
|
|
int d = r.contains( oldGeometry.center()) ? 0 : ( r.center() - oldGeometry.center()).manhattanLength();
|
|
|
|
if( d < distance ) {
|
|
|
|
distance = d;
|
|
|
|
oldScreenArea = r;
|
2011-09-30 11:22:39 +00:00
|
|
|
}
|
2011-09-30 12:50:18 +00:00
|
|
|
}
|
2013-03-22 23:42:45 +00:00
|
|
|
} else {
|
|
|
|
oldScreenArea = workspace()->clientArea(ScreenArea, oldGeometry.center(), oldDesktop);
|
|
|
|
}
|
Compute correct boundaries in checkWorkspacePosition
Summary:
When a client sets a strut, checkWorkspacePosition will be called to
bump clients that touch corresponding screen edge.
In order to do that, checkWorkspacePosition needs to calculate client
boundaries before and after the restricted move area was changed. As it
turns out, if the client reserves space "between" screens, calculated
boundaries can be incorrect, which may lead to some funky results, e.g.
shrunken clients.
For example, let's say that there is a dual-monitor setup. If a client
reserves some amount of space at the right border of the left screen,
then clients on the right monitor will have rightMax which is equal to
the x coordinate of screenArea.
To fix that, this change ensures that only restricted areas belonging
to the same screen as the client are taken into account when computing
the boundaries.
BUG: 404837
BUG: 406573
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D20987
2019-05-03 13:36:18 +00:00
|
|
|
const QRect oldGeomTall = QRect(oldGeometry.x(), oldScreenArea.y(), oldGeometry.width(), oldScreenArea.height()); // Full screen height
|
|
|
|
const QRect oldGeomWide = QRect(oldScreenArea.x(), oldGeometry.y(), oldScreenArea.width(), oldGeometry.height()); // Full screen width
|
2013-03-22 23:42:45 +00:00
|
|
|
int oldTopMax = oldScreenArea.y();
|
|
|
|
int oldRightMax = oldScreenArea.x() + oldScreenArea.width();
|
|
|
|
int oldBottomMax = oldScreenArea.y() + oldScreenArea.height();
|
|
|
|
int oldLeftMax = oldScreenArea.x();
|
2015-10-12 09:34:09 +00:00
|
|
|
const QRect screenArea = workspace()->clientArea(ScreenArea, geometryRestore().center(), desktop());
|
2013-03-22 23:42:45 +00:00
|
|
|
int topMax = screenArea.y();
|
|
|
|
int rightMax = screenArea.x() + screenArea.width();
|
|
|
|
int bottomMax = screenArea.y() + screenArea.height();
|
|
|
|
int leftMax = screenArea.x();
|
2015-10-12 09:34:09 +00:00
|
|
|
QRect newGeom = geometryRestore(); // geometry();
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
QRect newClientGeom = newGeom.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
|
Compute correct boundaries in checkWorkspacePosition
Summary:
When a client sets a strut, checkWorkspacePosition will be called to
bump clients that touch corresponding screen edge.
In order to do that, checkWorkspacePosition needs to calculate client
boundaries before and after the restricted move area was changed. As it
turns out, if the client reserves space "between" screens, calculated
boundaries can be incorrect, which may lead to some funky results, e.g.
shrunken clients.
For example, let's say that there is a dual-monitor setup. If a client
reserves some amount of space at the right border of the left screen,
then clients on the right monitor will have rightMax which is equal to
the x coordinate of screenArea.
To fix that, this change ensures that only restricted areas belonging
to the same screen as the client are taken into account when computing
the boundaries.
BUG: 404837
BUG: 406573
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D20987
2019-05-03 13:36:18 +00:00
|
|
|
const QRect newGeomTall = QRect(newGeom.x(), screenArea.y(), newGeom.width(), screenArea.height()); // Full screen height
|
|
|
|
const QRect newGeomWide = QRect(screenArea.x(), newGeom.y(), screenArea.width(), newGeom.height()); // Full screen width
|
2013-03-22 23:42:45 +00:00
|
|
|
// Get the max strut point for each side where the window is (E.g. Highest point for
|
|
|
|
// the bottom struts bounded by the window's left and right sides).
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
|
|
|
|
// These 4 compute old bounds ...
|
|
|
|
auto moveAreaFunc = workspace()->inUpdateClientArea() ?
|
|
|
|
&Workspace::previousRestrictedMoveArea : //... the restricted areas changed
|
|
|
|
&Workspace::restrictedMoveArea; //... when e.g. active desktop or screen changes
|
|
|
|
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaTop)) {
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
QRect rect = r & oldGeomTall;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
oldTopMax = qMax(oldTopMax, rect.y() + rect.height());
|
2013-03-22 23:42:45 +00:00
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaRight)) {
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
QRect rect = r & oldGeomWide;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
oldRightMax = qMin(oldRightMax, rect.x());
|
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaBottom)) {
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
QRect rect = r & oldGeomTall;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
oldBottomMax = qMin(oldBottomMax, rect.y());
|
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaLeft)) {
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
QRect rect = r & oldGeomWide;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
oldLeftMax = qMax(oldLeftMax, rect.x() + rect.width());
|
|
|
|
}
|
|
|
|
|
2013-03-22 23:42:45 +00:00
|
|
|
// These 4 compute new bounds
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaTop)) {
|
2013-03-22 23:42:45 +00:00
|
|
|
QRect rect = r & newGeomTall;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
topMax = qMax(topMax, rect.y() + rect.height());
|
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaRight)) {
|
2013-03-22 23:42:45 +00:00
|
|
|
QRect rect = r & newGeomWide;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
rightMax = qMin(rightMax, rect.x());
|
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaBottom)) {
|
2013-03-22 23:42:45 +00:00
|
|
|
QRect rect = r & newGeomTall;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
bottomMax = qMin(bottomMax, rect.y());
|
|
|
|
}
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaLeft)) {
|
2013-03-22 23:42:45 +00:00
|
|
|
QRect rect = r & newGeomWide;
|
|
|
|
if (!rect.isEmpty())
|
|
|
|
leftMax = qMax(leftMax, rect.x() + rect.width());
|
|
|
|
}
|
|
|
|
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
|
2013-03-22 23:42:45 +00:00
|
|
|
// Check if the sides were inside or touching but are no longer
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
bool keep[4] = {false, false, false, false};
|
|
|
|
bool save[4] = {false, false, false, false};
|
|
|
|
int padding[4] = {0, 0, 0, 0};
|
|
|
|
if (oldGeometry.x() >= oldLeftMax)
|
|
|
|
save[Left] = newGeom.x() < leftMax;
|
|
|
|
if (oldGeometry.x() == oldLeftMax)
|
|
|
|
keep[Left] = newGeom.x() != leftMax;
|
|
|
|
else if (oldClientGeometry.x() == oldLeftMax && newClientGeom.x() != leftMax) {
|
|
|
|
padding[0] = border[Left];
|
|
|
|
keep[Left] = true;
|
|
|
|
}
|
|
|
|
if (oldGeometry.y() >= oldTopMax)
|
|
|
|
save[Top] = newGeom.y() < topMax;
|
|
|
|
if (oldGeometry.y() == oldTopMax)
|
|
|
|
keep[Top] = newGeom.y() != topMax;
|
|
|
|
else if (oldClientGeometry.y() == oldTopMax && newClientGeom.y() != topMax) {
|
|
|
|
padding[1] = border[Left];
|
|
|
|
keep[Top] = true;
|
|
|
|
}
|
|
|
|
if (oldGeometry.right() <= oldRightMax - 1)
|
|
|
|
save[Right] = newGeom.right() > rightMax - 1;
|
|
|
|
if (oldGeometry.right() == oldRightMax - 1)
|
|
|
|
keep[Right] = newGeom.right() != rightMax - 1;
|
|
|
|
else if (oldClientGeometry.right() == oldRightMax - 1 && newClientGeom.right() != rightMax - 1) {
|
|
|
|
padding[2] = border[Right];
|
|
|
|
keep[Right] = true;
|
|
|
|
}
|
|
|
|
if (oldGeometry.bottom() <= oldBottomMax - 1)
|
|
|
|
save[Bottom] = newGeom.bottom() > bottomMax - 1;
|
|
|
|
if (oldGeometry.bottom() == oldBottomMax - 1)
|
|
|
|
keep[Bottom] = newGeom.bottom() != bottomMax - 1;
|
|
|
|
else if (oldClientGeometry.bottom() == oldBottomMax - 1 && newClientGeom.bottom() != bottomMax - 1) {
|
|
|
|
padding[3] = border[Bottom];
|
|
|
|
keep[Bottom] = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if randomly touches opposing edges, do not favor either
|
|
|
|
if (keep[Left] && keep[Right]) {
|
|
|
|
keep[Left] = keep[Right] = false;
|
|
|
|
padding[0] = padding[2] = 0;
|
|
|
|
}
|
|
|
|
if (keep[Top] && keep[Bottom]) {
|
|
|
|
keep[Top] = keep[Bottom] = false;
|
|
|
|
padding[1] = padding[3] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (save[Left] || keep[Left])
|
|
|
|
newGeom.moveLeft(qMax(leftMax, screenArea.x()) - padding[0]);
|
|
|
|
if (padding[0] && screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.moveLeft(newGeom.left() + padding[0]);
|
|
|
|
if (save[Top] || keep[Top])
|
|
|
|
newGeom.moveTop(qMax(topMax, screenArea.y()) - padding[1]);
|
|
|
|
if (padding[1] && screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.moveTop(newGeom.top() + padding[1]);
|
|
|
|
if (save[Right] || keep[Right])
|
|
|
|
newGeom.moveRight(qMin(rightMax - 1, screenArea.right()) + padding[2]);
|
|
|
|
if (padding[2] && screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.moveRight(newGeom.right() - padding[2]);
|
|
|
|
if (oldGeometry.x() >= oldLeftMax && newGeom.x() < leftMax)
|
|
|
|
newGeom.setLeft(qMax(leftMax, screenArea.x()));
|
|
|
|
else if (oldClientGeometry.x() >= oldLeftMax && newGeom.x() + border[Left] < leftMax) {
|
|
|
|
newGeom.setLeft(qMax(leftMax, screenArea.x()) - border[Left]);
|
|
|
|
if (screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.setLeft(newGeom.left() + border[Left]);
|
|
|
|
}
|
|
|
|
if (save[Bottom] || keep[Bottom])
|
|
|
|
newGeom.moveBottom(qMin(bottomMax - 1, screenArea.bottom()) + padding[3]);
|
|
|
|
if (padding[3] && screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.moveBottom(newGeom.bottom() - padding[3]);
|
|
|
|
if (oldGeometry.y() >= oldTopMax && newGeom.y() < topMax)
|
|
|
|
newGeom.setTop(qMax(topMax, screenArea.y()));
|
|
|
|
else if (oldClientGeometry.y() >= oldTopMax && newGeom.y() + border[Top] < topMax) {
|
|
|
|
newGeom.setTop(qMax(topMax, screenArea.y()) - border[Top]);
|
|
|
|
if (screens()->intersecting(newGeom) > 1)
|
|
|
|
newGeom.setTop(newGeom.top() + border[Top]);
|
2013-03-22 23:42:45 +00:00
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2013-03-22 23:42:45 +00:00
|
|
|
checkOffscreenPosition(&newGeom, screenArea);
|
|
|
|
// Obey size hints. TODO: We really should make sure it stays in the right place
|
2015-05-23 08:24:09 +00:00
|
|
|
if (!isShade())
|
|
|
|
newGeom.setSize(adjustedSize(newGeom.size()));
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2019-09-27 10:01:10 +00:00
|
|
|
if (newGeom != frameGeometry())
|
|
|
|
setFrameGeometry(newGeom);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-12 08:50:20 +00:00
|
|
|
void AbstractClient::checkOffscreenPosition(QRect* geom, const QRect& screenArea)
|
2011-07-28 20:18:41 +00:00
|
|
|
{
|
2015-02-06 15:29:12 +00:00
|
|
|
if (geom->left() > screenArea.right()) {
|
|
|
|
geom->moveLeft(screenArea.right() - screenArea.width()/4);
|
|
|
|
} else if (geom->right() < screenArea.left()) {
|
|
|
|
geom->moveRight(screenArea.left() + screenArea.width()/4);
|
2011-07-28 20:18:41 +00:00
|
|
|
}
|
2015-02-06 15:29:12 +00:00
|
|
|
if (geom->top() > screenArea.bottom()) {
|
|
|
|
geom->moveTop(screenArea.bottom() - screenArea.height()/4);
|
|
|
|
} else if (geom->bottom() < screenArea.top()) {
|
|
|
|
geom->moveBottom(screenArea.top() + screenArea.width()/4);
|
2011-07-28 20:18:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-13 07:51:40 +00:00
|
|
|
QSize AbstractClient::adjustedSize(const QSize& frame, Sizemode mode) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
// first, get the window size for the given frame size s
|
2014-07-22 11:11:19 +00:00
|
|
|
QSize wsize(frame.width() - (borderLeft() + borderRight()),
|
|
|
|
frame.height() - (borderTop() + borderBottom()));
|
2011-01-30 14:34:42 +00:00
|
|
|
if (wsize.isEmpty())
|
2015-05-23 08:20:04 +00:00
|
|
|
wsize = QSize(qMax(wsize.width(), 1), qMax(wsize.height(), 1));
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
return sizeForClientSize(wsize, mode, false);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// this helper returns proper size even if the window is shaded
|
2019-09-24 08:48:08 +00:00
|
|
|
// see also the comment in X11Client::setGeometry()
|
2015-10-13 07:51:40 +00:00
|
|
|
QSize AbstractClient::adjustedSize() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
return sizeForClientSize(clientSize());
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Calculate the appropriate frame size for the given client size \a
|
|
|
|
* wsize.
|
|
|
|
*
|
|
|
|
* \a wsize is adapted according to the window's size hints (minimum,
|
|
|
|
* maximum and incremental size changes).
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-09-24 08:48:08 +00:00
|
|
|
QSize X11Client::sizeForClientSize(const QSize& wsize, Sizemode mode, bool noframe) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
int w = wsize.width();
|
|
|
|
int h = wsize.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (w < 1 || h < 1) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCWarning(KWIN_CORE) << "sizeForClientSize() with empty size!" ;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// basesize, minsize, maxsize, paspect and resizeinc have all values defined,
|
|
|
|
// even if they're not set in flags - see getWmNormalHints()
|
2019-09-14 08:58:12 +00:00
|
|
|
QSize min_size = minSize();
|
|
|
|
QSize max_size = maxSize();
|
2015-12-03 12:24:44 +00:00
|
|
|
if (isDecorated()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
QSize decominsize(0, 0);
|
|
|
|
QSize border_size(borderLeft() + borderRight(), borderTop() + borderBottom());
|
2011-01-30 14:34:42 +00:00
|
|
|
if (border_size.width() > decominsize.width()) // just in case
|
|
|
|
decominsize.setWidth(border_size.width());
|
|
|
|
if (border_size.height() > decominsize.height())
|
|
|
|
decominsize.setHeight(border_size.height());
|
|
|
|
if (decominsize.width() > min_size.width())
|
|
|
|
min_size.setWidth(decominsize.width());
|
|
|
|
if (decominsize.height() > min_size.height())
|
|
|
|
min_size.setHeight(decominsize.height());
|
|
|
|
}
|
|
|
|
w = qMin(max_size.width(), w);
|
|
|
|
h = qMin(max_size.height(), h);
|
|
|
|
w = qMax(min_size.width(), w);
|
|
|
|
h = qMax(min_size.height(), h);
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
int w1 = w;
|
|
|
|
int h1 = h;
|
2015-01-21 15:05:29 +00:00
|
|
|
int width_inc = m_geometryHints.resizeIncrements().width();
|
|
|
|
int height_inc = m_geometryHints.resizeIncrements().height();
|
|
|
|
int basew_inc = m_geometryHints.baseSize().width();
|
|
|
|
int baseh_inc = m_geometryHints.baseSize().height();
|
|
|
|
if (!m_geometryHints.hasBaseSize()) {
|
|
|
|
basew_inc = m_geometryHints.minSize().width();
|
|
|
|
baseh_inc = m_geometryHints.minSize().height();
|
2014-01-30 02:46:54 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
w = int((w - basew_inc) / width_inc) * width_inc + basew_inc;
|
|
|
|
h = int((h - baseh_inc) / height_inc) * height_inc + baseh_inc;
|
2007-04-29 17:35:43 +00:00
|
|
|
// code for aspect ratios based on code from FVWM
|
|
|
|
/*
|
|
|
|
* The math looks like this:
|
|
|
|
*
|
|
|
|
* minAspectX dwidth maxAspectX
|
|
|
|
* ---------- <= ------- <= ----------
|
|
|
|
* minAspectY dheight maxAspectY
|
|
|
|
*
|
|
|
|
* If that is multiplied out, then the width and height are
|
|
|
|
* invalid in the following situations:
|
|
|
|
*
|
|
|
|
* minAspectX * dheight > minAspectY * dwidth
|
|
|
|
* maxAspectX * dheight < maxAspectY * dwidth
|
|
|
|
*
|
|
|
|
*/
|
2015-01-21 15:05:29 +00:00
|
|
|
if (m_geometryHints.hasAspect()) {
|
|
|
|
double min_aspect_w = m_geometryHints.minAspect().width(); // use doubles, because the values can be MAX_INT
|
|
|
|
double min_aspect_h = m_geometryHints.minAspect().height(); // and multiplying would go wrong otherwise
|
|
|
|
double max_aspect_w = m_geometryHints.maxAspect().width();
|
|
|
|
double max_aspect_h = m_geometryHints.maxAspect().height();
|
2007-04-29 17:35:43 +00:00
|
|
|
// According to ICCCM 4.1.2.3 PMinSize should be a fallback for PBaseSize for size increments,
|
|
|
|
// but not for aspect ratio. Since this code comes from FVWM, handles both at the same time,
|
|
|
|
// and I have no idea how it works, let's hope nobody relies on that.
|
2015-01-21 15:05:29 +00:00
|
|
|
const QSize baseSize = m_geometryHints.baseSize();
|
|
|
|
w -= baseSize.width();
|
|
|
|
h -= baseSize.height();
|
|
|
|
int max_width = max_size.width() - baseSize.width();
|
|
|
|
int min_width = min_size.width() - baseSize.width();
|
|
|
|
int max_height = max_size.height() - baseSize.height();
|
|
|
|
int min_height = min_size.height() - baseSize.height();
|
2007-04-29 17:35:43 +00:00
|
|
|
#define ASPECT_CHECK_GROW_W \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( min_aspect_w * h > min_aspect_h * w ) \
|
|
|
|
{ \
|
|
|
|
int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
|
|
|
|
if ( w + delta <= max_width ) \
|
|
|
|
w += delta; \
|
|
|
|
}
|
|
|
|
#define ASPECT_CHECK_SHRINK_H_GROW_W \
|
|
|
|
if ( min_aspect_w * h > min_aspect_h * w ) \
|
|
|
|
{ \
|
|
|
|
int delta = int( h - w * min_aspect_h / min_aspect_w ) / height_inc * height_inc; \
|
|
|
|
if ( h - delta >= min_height ) \
|
|
|
|
h -= delta; \
|
|
|
|
else \
|
|
|
|
{ \
|
2007-04-29 17:35:43 +00:00
|
|
|
int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( w + delta <= max_width ) \
|
2007-04-29 17:35:43 +00:00
|
|
|
w += delta; \
|
2011-01-30 14:34:42 +00:00
|
|
|
} \
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
#define ASPECT_CHECK_GROW_H \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( max_aspect_w * h < max_aspect_h * w ) \
|
|
|
|
{ \
|
|
|
|
int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
|
|
|
|
if ( h + delta <= max_height ) \
|
|
|
|
h += delta; \
|
|
|
|
}
|
|
|
|
#define ASPECT_CHECK_SHRINK_W_GROW_H \
|
|
|
|
if ( max_aspect_w * h < max_aspect_h * w ) \
|
|
|
|
{ \
|
|
|
|
int delta = int( w - max_aspect_w * h / max_aspect_h ) / width_inc * width_inc; \
|
|
|
|
if ( w - delta >= min_width ) \
|
|
|
|
w -= delta; \
|
|
|
|
else \
|
|
|
|
{ \
|
2007-04-29 17:35:43 +00:00
|
|
|
int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( h + delta <= max_height ) \
|
2007-04-29 17:35:43 +00:00
|
|
|
h += delta; \
|
2011-01-30 14:34:42 +00:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
switch(mode) {
|
|
|
|
case SizemodeAny:
|
2007-04-29 17:35:43 +00:00
|
|
|
#if 0 // make SizemodeAny equal to SizemodeFixedW - prefer keeping fixed width,
|
2011-01-30 14:34:42 +00:00
|
|
|
// so that changing aspect ratio to a different value and back keeps the same size (#87298)
|
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
ASPECT_CHECK_SHRINK_H_GROW_W
|
|
|
|
ASPECT_CHECK_SHRINK_W_GROW_H
|
|
|
|
ASPECT_CHECK_GROW_H
|
|
|
|
ASPECT_CHECK_GROW_W
|
|
|
|
break;
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
#endif
|
|
|
|
case SizemodeFixedW: {
|
|
|
|
// the checks are order so that attempts to modify height are first
|
|
|
|
ASPECT_CHECK_GROW_H
|
|
|
|
ASPECT_CHECK_SHRINK_H_GROW_W
|
|
|
|
ASPECT_CHECK_SHRINK_W_GROW_H
|
|
|
|
ASPECT_CHECK_GROW_W
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SizemodeFixedH: {
|
|
|
|
ASPECT_CHECK_GROW_W
|
|
|
|
ASPECT_CHECK_SHRINK_W_GROW_H
|
|
|
|
ASPECT_CHECK_SHRINK_H_GROW_W
|
|
|
|
ASPECT_CHECK_GROW_H
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SizemodeMax: {
|
|
|
|
// first checks that try to shrink
|
|
|
|
ASPECT_CHECK_SHRINK_H_GROW_W
|
|
|
|
ASPECT_CHECK_SHRINK_W_GROW_H
|
|
|
|
ASPECT_CHECK_GROW_W
|
|
|
|
ASPECT_CHECK_GROW_H
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
#undef ASPECT_CHECK_SHRINK_H_GROW_W
|
|
|
|
#undef ASPECT_CHECK_SHRINK_W_GROW_H
|
|
|
|
#undef ASPECT_CHECK_GROW_W
|
|
|
|
#undef ASPECT_CHECK_GROW_H
|
2015-01-21 15:05:29 +00:00
|
|
|
w += baseSize.width();
|
|
|
|
h += baseSize.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2012-03-17 23:56:30 +00:00
|
|
|
if (!rules()->checkStrictGeometry(!isFullScreen())) {
|
2011-01-30 14:34:42 +00:00
|
|
|
// disobey increments and aspect by explicit rule
|
|
|
|
w = w1;
|
|
|
|
h = h1;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!noframe) {
|
2014-07-22 11:11:19 +00:00
|
|
|
w += borderLeft() + borderRight();
|
|
|
|
h += borderTop() + borderBottom();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
return rules()->checkSize(QSize(w, h));
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Gets the client's normal WM hints and reconfigures itself respectively.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::getWmNormalHints()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-01-21 15:05:29 +00:00
|
|
|
const bool hadFixedAspect = m_geometryHints.hasAspect();
|
|
|
|
// roundtrip to X server
|
|
|
|
m_geometryHints.fetch();
|
|
|
|
m_geometryHints.read();
|
2009-11-15 15:48:59 +00:00
|
|
|
|
2015-01-21 15:05:29 +00:00
|
|
|
if (!hadFixedAspect && m_geometryHints.hasAspect()) {
|
|
|
|
// align to eventual new contraints
|
|
|
|
maximize(max_mode);
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isManaged()) {
|
|
|
|
// update to match restrictions
|
2007-04-29 17:35:43 +00:00
|
|
|
QSize new_size = adjustedSize();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (new_size != size() && !isFullScreen()) {
|
2013-09-11 20:50:32 +00:00
|
|
|
QRect origClientGeometry(pos() + clientPos(), clientSize());
|
2011-01-30 14:34:42 +00:00
|
|
|
resizeWithChecks(new_size);
|
|
|
|
if ((!isSpecialWindow() || isToolbar()) && !isFullScreen()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
// try to keep the window in its xinerama screen if possible,
|
|
|
|
// if that fails at least keep it visible somewhere
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect area = workspace()->clientArea(MovementArea, this);
|
2013-09-11 20:50:32 +00:00
|
|
|
if (area.contains(origClientGeometry))
|
2011-01-30 14:34:42 +00:00
|
|
|
keepInArea(area);
|
|
|
|
area = workspace()->clientArea(WorkArea, this);
|
2013-09-11 20:50:32 +00:00
|
|
|
if (area.contains(origClientGeometry))
|
2011-01-30 14:34:42 +00:00
|
|
|
keepInArea(area);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
updateAllowedActions(); // affects isResizeable()
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
QSize X11Client::minSize() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-01-21 15:05:29 +00:00
|
|
|
return rules()->checkMinSize(m_geometryHints.minSize());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
QSize X11Client::maxSize() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-01-21 15:05:29 +00:00
|
|
|
return rules()->checkMaxSize(m_geometryHints.maxSize());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
QSize X11Client::basicUnit() const
|
2011-11-02 22:05:03 +00:00
|
|
|
{
|
2015-01-21 15:05:29 +00:00
|
|
|
return m_geometryHints.resizeIncrements();
|
2011-11-02 22:05:03 +00:00
|
|
|
}
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Auxiliary function to inform the client about the current window
|
|
|
|
* configuration.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::sendSyntheticConfigureNotify()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2014-05-15 08:32:34 +00:00
|
|
|
xcb_configure_notify_event_t c;
|
|
|
|
memset(&c, 0, sizeof(c));
|
|
|
|
c.response_type = XCB_CONFIGURE_NOTIFY;
|
2007-04-29 17:35:43 +00:00
|
|
|
c.event = window();
|
|
|
|
c.window = window();
|
|
|
|
c.x = x() + clientPos().x();
|
|
|
|
c.y = y() + clientPos().y();
|
|
|
|
c.width = clientSize().width();
|
|
|
|
c.height = clientSize().height();
|
|
|
|
c.border_width = 0;
|
2014-05-15 08:32:34 +00:00
|
|
|
c.above_sibling = XCB_WINDOW_NONE;
|
2007-04-29 17:35:43 +00:00
|
|
|
c.override_redirect = 0;
|
2014-05-15 08:32:34 +00:00
|
|
|
xcb_send_event(connection(), true, c.event, XCB_EVENT_MASK_STRUCTURE_NOTIFY, reinterpret_cast<const char*>(&c));
|
|
|
|
xcb_flush(connection());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
const QPoint X11Client::calculateGravitation(bool invert, int gravity) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
int dx, dy;
|
|
|
|
dx = dy = 0;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (gravity == 0) // default (nonsense) value for the argument
|
2015-01-21 15:05:29 +00:00
|
|
|
gravity = m_geometryHints.windowGravity();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// dx, dy specify how the client window moves to make space for the frame
|
2011-01-30 14:34:42 +00:00
|
|
|
switch(gravity) {
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH_WEST: // move down right
|
2011-01-30 14:34:42 +00:00
|
|
|
default:
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = borderLeft();
|
|
|
|
dy = borderTop();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH: // move right
|
2011-01-30 14:34:42 +00:00
|
|
|
dx = 0;
|
2014-07-22 11:11:19 +00:00
|
|
|
dy = borderTop();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH_EAST: // move down left
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = -borderRight();
|
|
|
|
dy = borderTop();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_WEST: // move right
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = borderLeft();
|
2011-01-30 14:34:42 +00:00
|
|
|
dy = 0;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_CENTER:
|
2011-01-30 14:34:42 +00:00
|
|
|
break; // will be handled specially
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_STATIC: // don't move
|
2011-01-30 14:34:42 +00:00
|
|
|
dx = 0;
|
|
|
|
dy = 0;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_EAST: // move left
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = -borderRight();
|
2011-01-30 14:34:42 +00:00
|
|
|
dy = 0;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH_WEST: // move up right
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = borderLeft() ;
|
|
|
|
dy = -borderBottom();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH: // move up
|
2011-01-30 14:34:42 +00:00
|
|
|
dx = 0;
|
2014-07-22 11:11:19 +00:00
|
|
|
dy = -borderBottom();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH_EAST: // move up left
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = -borderRight();
|
|
|
|
dy = -borderBottom();
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
|
|
|
}
|
2019-09-06 14:30:26 +00:00
|
|
|
if (gravity != XCB_GRAVITY_CENTER) {
|
2011-01-30 14:34:42 +00:00
|
|
|
// translate from client movement to frame movement
|
2014-07-22 11:11:19 +00:00
|
|
|
dx -= borderLeft();
|
|
|
|
dy -= borderTop();
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
|
|
|
// center of the frame will be at the same position client center without frame would be
|
2014-07-22 11:11:19 +00:00
|
|
|
dx = - (borderLeft() + borderRight()) / 2;
|
|
|
|
dy = - (borderTop() + borderBottom()) / 2;
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!invert)
|
|
|
|
return QPoint(x() + dx, y() + dy);
|
|
|
|
else
|
|
|
|
return QPoint(x() - dx, y() - dy);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::configureRequest(int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-06 14:30:26 +00:00
|
|
|
const int configurePositionMask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y;
|
|
|
|
const int configureSizeMask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
|
|
|
|
const int configureGeometryMask = configurePositionMask | configureSizeMask;
|
|
|
|
|
2011-03-08 20:33:40 +00:00
|
|
|
// "maximized" is a user setting -> we do not allow the client to resize itself
|
|
|
|
// away from this & against the users explicit wish
|
2019-09-06 14:30:26 +00:00
|
|
|
qCDebug(KWIN_CORE) << this << bool(value_mask & configureGeometryMask) <<
|
2011-06-13 17:33:20 +00:00
|
|
|
bool(maximizeMode() & MaximizeVertical) <<
|
|
|
|
bool(maximizeMode() & MaximizeHorizontal);
|
2013-06-22 22:01:05 +00:00
|
|
|
|
|
|
|
// we want to (partially) ignore the request when the window is somehow maximized or quicktiled
|
2017-07-18 19:12:37 +00:00
|
|
|
bool ignore = !app_noborder && (quickTileMode() != QuickTileMode(QuickTileFlag::None) || maximizeMode() != MaximizeRestore);
|
2013-06-22 22:01:05 +00:00
|
|
|
// however, the user shall be able to force obedience despite and also disobedience in general
|
|
|
|
ignore = rules()->checkIgnoreGeometry(ignore);
|
|
|
|
if (!ignore) { // either we're not max'd / q'tiled or the user allowed the client to break that - so break it.
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::None);
|
2013-06-22 22:01:05 +00:00
|
|
|
max_mode = MaximizeRestore;
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2017-07-18 19:12:37 +00:00
|
|
|
} else if (!app_noborder && quickTileMode() == QuickTileMode(QuickTileFlag::None) &&
|
2013-06-22 22:01:05 +00:00
|
|
|
(maximizeMode() == MaximizeVertical || maximizeMode() == MaximizeHorizontal)) {
|
|
|
|
// ignoring can be, because either we do, or the user does explicitly not want it.
|
|
|
|
// for partially maximized windows we want to allow configures in the other dimension.
|
|
|
|
// so we've to ask the user again - to know whether we just ignored for the partial maximization.
|
|
|
|
// the problem here is, that the user can explicitly permit configure requests - even for maximized windows!
|
|
|
|
// we cannot distinguish that from passing "false" for partially maximized windows.
|
|
|
|
ignore = rules()->checkIgnoreGeometry(false);
|
|
|
|
if (!ignore) { // the user is not interested, so we fix up dimensions
|
|
|
|
if (maximizeMode() == MaximizeVertical)
|
2019-09-06 14:30:26 +00:00
|
|
|
value_mask &= ~(XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT);
|
2013-06-22 22:01:05 +00:00
|
|
|
if (maximizeMode() == MaximizeHorizontal)
|
2019-09-06 14:30:26 +00:00
|
|
|
value_mask &= ~(XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_WIDTH);
|
|
|
|
if (!(value_mask & configureGeometryMask)) {
|
2013-06-22 22:01:05 +00:00
|
|
|
ignore = true; // the modification turned the request void
|
|
|
|
}
|
|
|
|
}
|
2012-02-17 18:44:30 +00:00
|
|
|
}
|
2013-06-22 22:01:05 +00:00
|
|
|
|
|
|
|
if (ignore) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "DENIED";
|
2013-06-22 22:01:05 +00:00
|
|
|
return; // nothing to (left) to do for use - bugs #158974, #252314, #321491
|
2011-06-13 17:33:20 +00:00
|
|
|
}
|
2013-06-22 22:01:05 +00:00
|
|
|
|
2019-09-06 14:30:26 +00:00
|
|
|
qCDebug(KWIN_CORE) << "PERMITTED" << this << bool(value_mask & configureGeometryMask);
|
2010-12-20 18:18:27 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (gravity == 0) // default (nonsense) value for the argument
|
2015-01-21 15:05:29 +00:00
|
|
|
gravity = m_geometryHints.windowGravity();
|
2019-09-06 14:30:26 +00:00
|
|
|
if (value_mask & configurePositionMask) {
|
2011-01-30 14:34:42 +00:00
|
|
|
QPoint new_pos = calculateGravitation(true, gravity); // undo gravitation
|
2019-09-06 14:30:26 +00:00
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_X) {
|
2011-01-30 14:34:42 +00:00
|
|
|
new_pos.setX(rx);
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_Y) {
|
2011-01-30 14:34:42 +00:00
|
|
|
new_pos.setY(ry);
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// clever(?) workaround for applications like xv that want to set
|
|
|
|
// the location to the current location but miscalculate the
|
|
|
|
// frame size due to kwin being a double-reparenting window
|
|
|
|
// manager
|
2011-01-30 14:34:42 +00:00
|
|
|
if (new_pos.x() == x() + clientPos().x() && new_pos.y() == y() + clientPos().y()
|
2019-09-06 14:30:26 +00:00
|
|
|
&& gravity == XCB_GRAVITY_NORTH_WEST && !from_tool) {
|
2011-01-30 14:34:42 +00:00
|
|
|
new_pos.setX(x());
|
|
|
|
new_pos.setY(y());
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
int nw = clientSize().width();
|
|
|
|
int nh = clientSize().height();
|
2019-09-06 14:30:26 +00:00
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
|
2007-04-29 17:35:43 +00:00
|
|
|
nw = rw;
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
|
2007-04-29 17:35:43 +00:00
|
|
|
nh = rh;
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
QSize ns = sizeForClientSize(QSize(nw, nh)); // enforces size if needed
|
|
|
|
new_pos = rules()->checkPosition(new_pos);
|
2013-04-03 10:19:27 +00:00
|
|
|
int newScreen = screens()->number(QRect(new_pos, ns).center());
|
2012-10-19 21:37:37 +00:00
|
|
|
if (newScreen != rules()->checkScreen(newScreen))
|
|
|
|
return; // not allowed by rule
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-09-11 20:50:32 +00:00
|
|
|
QRect origClientGeometry(pos() + clientPos(), clientSize());
|
2011-01-30 14:34:42 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
|
|
|
move(new_pos);
|
|
|
|
plainResize(ns);
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(QRect(calculateGravitation(false, gravity), size()));
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect area = workspace()->clientArea(WorkArea, this);
|
|
|
|
if (!from_tool && (!isSpecialWindow() || isToolbar()) && !isFullScreen()
|
2013-09-11 20:50:32 +00:00
|
|
|
&& area.contains(origClientGeometry))
|
2011-01-30 14:34:42 +00:00
|
|
|
keepInArea(area);
|
2010-12-21 14:34:45 +00:00
|
|
|
|
|
|
|
// this is part of the kicker-xinerama-hack... it should be
|
|
|
|
// safe to remove when kicker gets proper ExtendedStrut support;
|
|
|
|
// see Workspace::updateClientArea() and
|
2019-09-24 08:48:08 +00:00
|
|
|
// X11Client::adjustedClientArea()
|
2011-01-30 14:34:42 +00:00
|
|
|
if (hasStrut())
|
|
|
|
workspace() -> updateClientArea();
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-06 14:30:26 +00:00
|
|
|
if (value_mask & configureSizeMask && !(value_mask & configurePositionMask)) { // pure resize
|
2007-04-29 17:35:43 +00:00
|
|
|
int nw = clientSize().width();
|
|
|
|
int nh = clientSize().height();
|
2019-09-06 14:30:26 +00:00
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
|
2007-04-29 17:35:43 +00:00
|
|
|
nw = rw;
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
|
|
|
if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
|
2007-04-29 17:35:43 +00:00
|
|
|
nh = rh;
|
2019-09-06 14:30:26 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
QSize ns = sizeForClientSize(QSize(nw, nh));
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (ns != size()) { // don't restore if some app sets its own size again
|
2013-09-11 20:50:32 +00:00
|
|
|
QRect origClientGeometry(pos() + clientPos(), clientSize());
|
2011-01-30 14:34:42 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
2015-01-21 15:05:29 +00:00
|
|
|
resizeWithChecks(ns, xcb_gravity_t(gravity));
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!from_tool && (!isSpecialWindow() || isToolbar()) && !isFullScreen()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
// try to keep the window in its xinerama screen if possible,
|
|
|
|
// if that fails at least keep it visible somewhere
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect area = workspace()->clientArea(MovementArea, this);
|
2013-09-11 20:50:32 +00:00
|
|
|
if (area.contains(origClientGeometry))
|
2011-01-30 14:34:42 +00:00
|
|
|
keepInArea(area);
|
|
|
|
area = workspace()->clientArea(WorkArea, this);
|
2013-09-11 20:50:32 +00:00
|
|
|
if (area.contains(origClientGeometry))
|
2011-01-30 14:34:42 +00:00
|
|
|
keepInArea(area);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2019-09-27 10:01:10 +00:00
|
|
|
geom_restore = frameGeometry();
|
2007-04-29 17:35:43 +00:00
|
|
|
// No need to send synthetic configure notify event here, either it's sent together
|
|
|
|
// with geometry change, or there's no need to send it.
|
|
|
|
// Handling of the real ConfigureRequest event forces sending it, as there it's necessary.
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::resizeWithChecks(int w, int h, xcb_gravity_t gravity, ForceGeometry_t force)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(!shade_geometry_change);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isShade()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
if (h == borderTop() + borderBottom()) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCWarning(KWIN_CORE) << "Shaded geometry passed for size:" ;
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
int newx = x();
|
|
|
|
int newy = y();
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect area = workspace()->clientArea(WorkArea, this);
|
2007-04-29 17:35:43 +00:00
|
|
|
// don't allow growing larger than workarea
|
2011-01-30 14:34:42 +00:00
|
|
|
if (w > area.width())
|
2007-04-29 17:35:43 +00:00
|
|
|
w = area.width();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (h > area.height())
|
2007-04-29 17:35:43 +00:00
|
|
|
h = area.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
QSize tmp = adjustedSize(QSize(w, h)); // checks size constraints, including min/max size
|
2007-04-29 17:35:43 +00:00
|
|
|
w = tmp.width();
|
|
|
|
h = tmp.height();
|
2015-01-21 15:05:29 +00:00
|
|
|
if (gravity == 0) {
|
|
|
|
gravity = m_geometryHints.windowGravity();
|
|
|
|
}
|
|
|
|
switch(gravity) {
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH_WEST: // top left corner doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
default:
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH: // middle of top border doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = (newx + width() / 2) - (w / 2);
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_NORTH_EAST: // top right corner doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = newx + width() - w;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_WEST: // middle of left border doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newy = (newy + height() / 2) - (h / 2);
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_CENTER: // middle point doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = (newx + width() / 2) - (w / 2);
|
|
|
|
newy = (newy + height() / 2) - (h / 2);
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_STATIC: // top left corner of _client_ window doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
// since decoration doesn't change, equal to NorthWestGravity
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_EAST: // // middle of right border doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = newx + width() - w;
|
|
|
|
newy = (newy + height() / 2) - (h / 2);
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH_WEST: // bottom left corner doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newy = newy + height() - h;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH: // middle of bottom border doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = (newx + width() / 2) - (w / 2);
|
|
|
|
newy = newy + height() - h;
|
|
|
|
break;
|
2019-09-06 14:30:26 +00:00
|
|
|
case XCB_GRAVITY_SOUTH_EAST: // bottom right corner doesn't move
|
2011-01-30 14:34:42 +00:00
|
|
|
newx = newx + width() - w;
|
|
|
|
newy = newy + height() - h;
|
|
|
|
break;
|
|
|
|
}
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(newx, newy, w, h, force);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// _NET_MOVERESIZE_WINDOW
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::NETMoveResizeWindow(int flags, int x, int y, int width, int height)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-04-29 17:35:43 +00:00
|
|
|
int gravity = flags & 0xff;
|
|
|
|
int value_mask = 0;
|
2019-09-06 14:30:26 +00:00
|
|
|
if (flags & (1 << 8)) {
|
|
|
|
value_mask |= XCB_CONFIG_WINDOW_X;
|
|
|
|
}
|
|
|
|
if (flags & (1 << 9)) {
|
|
|
|
value_mask |= XCB_CONFIG_WINDOW_Y;
|
|
|
|
}
|
|
|
|
if (flags & (1 << 10)) {
|
|
|
|
value_mask |= XCB_CONFIG_WINDOW_WIDTH;
|
|
|
|
}
|
|
|
|
if (flags & (1 << 11)) {
|
|
|
|
value_mask |= XCB_CONFIG_WINDOW_HEIGHT;
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
configureRequest(value_mask, x, y, width, height, gravity, true);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::isMovable() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-02-02 13:56:21 +00:00
|
|
|
if (!hasNETSupport() && !m_motif.move()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (isFullScreen())
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isSpecialWindow() && !isSplash() && !isToolbar()) // allow moving of splashscreens :)
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (rules()->checkPosition(invalidPoint) != invalidPoint) // forced position
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::isMovableAcrossScreens() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-02-02 13:56:21 +00:00
|
|
|
if (!hasNETSupport() && !m_motif.move()) {
|
2008-07-25 10:31:47 +00:00
|
|
|
return false;
|
2015-02-02 13:56:21 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isSpecialWindow() && !isSplash() && !isToolbar()) // allow moving of splashscreens :)
|
2008-07-25 10:31:47 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (rules()->checkPosition(invalidPoint) != invalidPoint) // forced position
|
2008-07-25 10:31:47 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-07-25 10:31:47 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::isResizable() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-02-02 13:56:21 +00:00
|
|
|
if (!hasNETSupport() && !m_motif.resize()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (isFullScreen())
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isSpecialWindow() || isSplash() || isToolbar())
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (rules()->checkSize(QSize()).isValid()) // forced size
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2015-10-16 11:10:55 +00:00
|
|
|
const Position mode = moveResizePointerMode();
|
2013-06-08 18:16:35 +00:00
|
|
|
if ((mode == PositionTop || mode == PositionTopLeft || mode == PositionTopRight ||
|
|
|
|
mode == PositionLeft || mode == PositionBottomLeft) && rules()->checkPosition(invalidPoint) != invalidPoint)
|
|
|
|
return false;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-14 08:58:12 +00:00
|
|
|
QSize min = minSize();
|
|
|
|
QSize max = maxSize();
|
2007-04-29 17:35:43 +00:00
|
|
|
return min.width() < max.width() || min.height() < max.height();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::isMaximizable() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2014-03-19 14:01:56 +00:00
|
|
|
if (!isResizable() || isToolbar()) // SELI isToolbar() ?
|
|
|
|
return false;
|
2011-12-10 19:29:01 +00:00
|
|
|
if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore && rules()->checkMaximize(MaximizeFull) != MaximizeRestore)
|
|
|
|
return true;
|
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Reimplemented to inform the client about the new window position.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-09-27 10:01:10 +00:00
|
|
|
void X11Client::setFrameGeometry(int x, int y, int w, int h, ForceGeometry_t force)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-24 08:48:08 +00:00
|
|
|
// this code is also duplicated in X11Client::plainResize()
|
2007-04-29 17:35:43 +00:00
|
|
|
// Ok, the shading geometry stuff. Generally, code doesn't care about shaded geometry,
|
|
|
|
// simply because there are too many places dealing with geometry. Those places
|
|
|
|
// ignore shaded state and use normal geometry, which they usually should get
|
|
|
|
// from adjustedSize(). Such geometry comes here, and if the window is shaded,
|
|
|
|
// the geometry is used only for client_size, since that one is not used when
|
|
|
|
// shading. Then the frame geometry is adjusted for the shaded geometry.
|
|
|
|
// This gets more complicated in the case the code does only something like
|
|
|
|
// setGeometry( geometry()) - geometry() will return the shaded frame geometry.
|
|
|
|
// Such code is wrong and should be changed to handle the case when the window is shaded,
|
2019-09-24 08:48:08 +00:00
|
|
|
// for example using X11Client::clientSize()
|
2011-01-30 14:34:42 +00:00
|
|
|
|
|
|
|
if (shade_geometry_change)
|
2007-04-29 17:35:43 +00:00
|
|
|
; // nothing
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (isShade()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
if (h == borderTop() + borderBottom()) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "Shaded geometry passed for size:";
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2014-07-22 11:11:19 +00:00
|
|
|
client_size = QSize(w - borderLeft() - borderRight(), h - borderTop() - borderBottom());
|
|
|
|
h = borderTop() + borderBottom();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2014-07-22 11:11:19 +00:00
|
|
|
client_size = QSize(w - borderLeft() - borderRight(), h - borderTop() - borderBottom());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
QRect g(x, y, w, h);
|
2015-10-13 11:15:39 +00:00
|
|
|
if (!areGeometryUpdatesBlocked() && g != rules()->checkGeometry(g)) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "forced geometry fail:" << g << ":" << rules()->checkGeometry(g);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-10-13 11:15:39 +00:00
|
|
|
if (force == NormalGeometrySet && geom == g && pendingGeometryUpdate() == PendingGeometryNone)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2007-11-28 14:33:35 +00:00
|
|
|
geom = g;
|
2015-10-13 11:15:39 +00:00
|
|
|
if (areGeometryUpdatesBlocked()) {
|
|
|
|
if (pendingGeometryUpdate() == PendingGeometryForced)
|
2007-06-19 15:40:09 +00:00
|
|
|
{} // maximum, nothing needed
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (force == ForceGeometrySet)
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryForced);
|
2007-06-19 15:40:09 +00:00
|
|
|
else
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryNormal);
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-08-02 12:30:30 +00:00
|
|
|
QSize oldClientSize = m_frame.geometry().size();
|
2015-10-15 11:11:21 +00:00
|
|
|
bool resized = (geometryBeforeUpdateBlocking().size() != geom.size() || pendingGeometryUpdate() == PendingGeometryForced);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (resized) {
|
2014-07-25 11:14:53 +00:00
|
|
|
resizeDecoration();
|
2013-09-10 06:37:49 +00:00
|
|
|
m_frame.setGeometry(x, y, w, h);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!isShade()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
QSize cs = clientSize();
|
2013-09-09 08:42:01 +00:00
|
|
|
m_wrapper.setGeometry(QRect(clientPos(), cs));
|
2013-07-31 08:11:39 +00:00
|
|
|
if (!isResize() || syncRequest.counter == XCB_NONE)
|
2013-09-10 05:45:17 +00:00
|
|
|
m_client.setGeometry(0, 0, cs.width(), cs.height());
|
2012-12-29 21:27:31 +00:00
|
|
|
// SELI - won't this be too expensive?
|
|
|
|
// THOMAS - yes, but gtk+ clients will not resize without ...
|
|
|
|
sendSyntheticConfigureNotify();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
updateShape();
|
2011-11-09 19:39:13 +00:00
|
|
|
} else {
|
2015-10-16 07:08:02 +00:00
|
|
|
if (isMoveResize()) {
|
2012-12-29 21:27:31 +00:00
|
|
|
if (compositing()) // Defer the X update until we leave this mode
|
|
|
|
needsXWindowMove = true;
|
|
|
|
else
|
2013-09-10 06:37:49 +00:00
|
|
|
m_frame.move(x, y); // sendSyntheticConfigureNotify() on finish shall be sufficient
|
2012-11-07 23:54:05 +00:00
|
|
|
} else {
|
2013-09-10 06:37:49 +00:00
|
|
|
m_frame.move(x, y);
|
2012-12-29 21:27:31 +00:00
|
|
|
sendSyntheticConfigureNotify();
|
2012-11-07 23:54:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Unconditionally move the input window: it won't affect rendering
|
2013-02-04 10:20:15 +00:00
|
|
|
m_decoInputExtent.move(QPoint(x, y) + inputPos());
|
2011-11-09 19:39:13 +00:00
|
|
|
}
|
2012-02-05 17:50:23 +00:00
|
|
|
updateWindowRules(Rules::Position|Rules::Size);
|
2011-01-30 14:34:42 +00:00
|
|
|
|
|
|
|
// keep track of old maximize mode
|
2010-01-22 02:50:33 +00:00
|
|
|
// to detect changes
|
2013-04-03 10:19:27 +00:00
|
|
|
screens()->setCurrent(this);
|
2008-08-23 09:20:42 +00:00
|
|
|
workspace()->updateStackingOrder();
|
2011-01-30 14:34:42 +00:00
|
|
|
|
2019-09-14 08:58:12 +00:00
|
|
|
// need to regenerate decoration pixmaps when
|
2010-01-22 02:50:33 +00:00
|
|
|
// - size is changed
|
2011-01-30 14:34:42 +00:00
|
|
|
if (resized) {
|
2015-08-02 12:30:30 +00:00
|
|
|
if (oldClientSize != QSize(w,h))
|
|
|
|
discardWindowPixmap();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2017-06-15 16:32:39 +00:00
|
|
|
emit geometryShapeChanged(this, geometryBeforeUpdateBlocking());
|
2015-10-15 10:50:28 +00:00
|
|
|
addRepaintDuringGeometryUpdates();
|
2015-10-15 11:11:21 +00:00
|
|
|
updateGeometryBeforeUpdateBlocking();
|
2011-12-22 18:38:52 +00:00
|
|
|
// TODO: this signal is emitted too often
|
|
|
|
emit geometryChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::plainResize(int w, int h, ForceGeometry_t force)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-24 08:48:08 +00:00
|
|
|
// this code is also duplicated in X11Client::setGeometry(), and it's also commented there
|
2011-01-30 14:34:42 +00:00
|
|
|
if (shade_geometry_change)
|
2007-04-29 17:35:43 +00:00
|
|
|
; // nothing
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (isShade()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
if (h == borderTop() + borderBottom()) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "Shaded geometry passed for size:";
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2014-07-22 11:11:19 +00:00
|
|
|
client_size = QSize(w - borderLeft() - borderRight(), h - borderTop() - borderBottom());
|
|
|
|
h = borderTop() + borderBottom();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2014-07-22 11:11:19 +00:00
|
|
|
client_size = QSize(w - borderLeft() - borderRight(), h - borderTop() - borderBottom());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
QSize s(w, h);
|
2015-10-13 11:15:39 +00:00
|
|
|
if (!areGeometryUpdatesBlocked() && s != rules()->checkSize(s)) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "forced size fail:" << s << ":" << rules()->checkSize(s);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-06-19 15:40:09 +00:00
|
|
|
// resuming geometry updates is handled only in setGeometry()
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
|
2011-01-30 14:34:42 +00:00
|
|
|
if (force == NormalGeometrySet && geom.size() == s)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
geom.setSize(s);
|
2015-10-13 11:15:39 +00:00
|
|
|
if (areGeometryUpdatesBlocked()) {
|
|
|
|
if (pendingGeometryUpdate() == PendingGeometryForced)
|
2007-06-19 15:40:09 +00:00
|
|
|
{} // maximum, nothing needed
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (force == ForceGeometrySet)
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryForced);
|
2007-06-19 15:40:09 +00:00
|
|
|
else
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryNormal);
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-08-02 12:30:30 +00:00
|
|
|
QSize oldClientSize = m_frame.geometry().size();
|
2014-07-25 11:14:53 +00:00
|
|
|
resizeDecoration();
|
2013-09-10 06:37:49 +00:00
|
|
|
m_frame.resize(w, h);
|
2007-11-28 14:33:35 +00:00
|
|
|
// resizeDecoration( s );
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!isShade()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
QSize cs = clientSize();
|
2013-09-09 08:42:01 +00:00
|
|
|
m_wrapper.setGeometry(QRect(clientPos(), cs));
|
2013-09-10 05:45:17 +00:00
|
|
|
m_client.setGeometry(0, 0, cs.width(), cs.height());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 21:19:29 +00:00
|
|
|
updateShape();
|
2011-01-30 14:34:42 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
sendSyntheticConfigureNotify();
|
2012-02-05 17:50:23 +00:00
|
|
|
updateWindowRules(Rules::Position|Rules::Size);
|
2013-04-03 10:19:27 +00:00
|
|
|
screens()->setCurrent(this);
|
2008-08-23 09:20:42 +00:00
|
|
|
workspace()->updateStackingOrder();
|
2015-08-02 12:30:30 +00:00
|
|
|
if (oldClientSize != QSize(w,h))
|
|
|
|
discardWindowPixmap();
|
2015-10-15 11:11:21 +00:00
|
|
|
emit geometryShapeChanged(this, geometryBeforeUpdateBlocking());
|
2015-10-15 10:50:28 +00:00
|
|
|
addRepaintDuringGeometryUpdates();
|
2015-10-15 11:11:21 +00:00
|
|
|
updateGeometryBeforeUpdateBlocking();
|
2011-12-22 18:38:52 +00:00
|
|
|
// TODO: this signal is emitted too often
|
|
|
|
emit geometryChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Reimplemented to inform the client about the new window position.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2015-10-15 13:28:01 +00:00
|
|
|
void AbstractClient::move(int x, int y, ForceGeometry_t force)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2007-06-19 15:40:09 +00:00
|
|
|
// resuming geometry updates is handled only in setGeometry()
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
|
2011-01-30 14:34:42 +00:00
|
|
|
QPoint p(x, y);
|
2015-10-13 11:15:39 +00:00
|
|
|
if (!areGeometryUpdatesBlocked() && p != rules()->checkPosition(p)) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCDebug(KWIN_CORE) << "forced position fail:" << p << ":" << rules()->checkPosition(p);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (force == NormalGeometrySet && geom.topLeft() == p)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
geom.moveTopLeft(p);
|
2015-10-13 11:15:39 +00:00
|
|
|
if (areGeometryUpdatesBlocked()) {
|
|
|
|
if (pendingGeometryUpdate() == PendingGeometryForced)
|
2007-06-19 15:40:09 +00:00
|
|
|
{} // maximum, nothing needed
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (force == ForceGeometrySet)
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryForced);
|
2007-06-19 15:40:09 +00:00
|
|
|
else
|
2015-10-13 11:15:39 +00:00
|
|
|
setPendingGeometryUpdate(PendingGeometryNormal);
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-10-15 13:28:01 +00:00
|
|
|
doMove(x, y);
|
2012-02-05 17:50:23 +00:00
|
|
|
updateWindowRules(Rules::Position);
|
2013-04-03 10:19:27 +00:00
|
|
|
screens()->setCurrent(this);
|
2008-08-23 09:20:42 +00:00
|
|
|
workspace()->updateStackingOrder();
|
2007-04-29 17:35:43 +00:00
|
|
|
// client itself is not damaged
|
2015-10-15 10:50:28 +00:00
|
|
|
addRepaintDuringGeometryUpdates();
|
2015-10-15 11:11:21 +00:00
|
|
|
updateGeometryBeforeUpdateBlocking();
|
2013-03-26 06:45:08 +00:00
|
|
|
emit geometryChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::doMove(int x, int y)
|
2015-10-15 13:28:01 +00:00
|
|
|
{
|
|
|
|
m_frame.move(x, y);
|
|
|
|
sendSyntheticConfigureNotify();
|
|
|
|
}
|
|
|
|
|
2015-10-13 11:15:39 +00:00
|
|
|
void AbstractClient::blockGeometryUpdates(bool block)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
if (block) {
|
2015-10-13 11:15:39 +00:00
|
|
|
if (m_blockGeometryUpdates == 0)
|
|
|
|
m_pendingGeometryUpdate = PendingGeometryNone;
|
|
|
|
++m_blockGeometryUpdates;
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2015-10-13 11:15:39 +00:00
|
|
|
if (--m_blockGeometryUpdates == 0) {
|
|
|
|
if (m_pendingGeometryUpdate != PendingGeometryNone) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isShade())
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(QRect(pos(), adjustedSize()), NormalGeometrySet);
|
2007-04-29 17:35:43 +00:00
|
|
|
else
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(frameGeometry(), NormalGeometrySet);
|
2015-10-13 11:15:39 +00:00
|
|
|
m_pendingGeometryUpdate = PendingGeometryNone;
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-13 08:22:18 +00:00
|
|
|
void AbstractClient::maximize(MaximizeMode m)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
setMaximize(m & MaximizeVertical, m & MaximizeHorizontal);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-13 08:22:18 +00:00
|
|
|
void AbstractClient::setMaximize(bool vertically, bool horizontally)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2009-09-13 17:09:44 +00:00
|
|
|
// changeMaximize() flips the state, so change from set->flip
|
2015-10-13 08:22:18 +00:00
|
|
|
const MaximizeMode oldMode = maximizeMode();
|
2007-04-29 17:35:43 +00:00
|
|
|
changeMaximize(
|
2015-10-13 08:22:18 +00:00
|
|
|
oldMode & MaximizeHorizontal ? !horizontally : horizontally,
|
2019-07-22 20:28:28 +00:00
|
|
|
oldMode & MaximizeVertical ? !vertically : vertically,
|
2011-01-30 14:34:42 +00:00
|
|
|
false);
|
2015-10-13 08:22:18 +00:00
|
|
|
const MaximizeMode newMode = maximizeMode();
|
|
|
|
if (oldMode != newMode) {
|
|
|
|
emit clientMaximizedStateChanged(this, newMode);
|
2013-06-26 17:29:52 +00:00
|
|
|
emit clientMaximizedStateChanged(this, vertically, horizontally);
|
|
|
|
}
|
2009-11-15 03:24:04 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-09-08 21:05:50 +00:00
|
|
|
static bool changeMaximizeRecursion = false;
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::changeMaximize(bool horizontal, bool vertical, bool adjust)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2011-12-10 19:29:01 +00:00
|
|
|
if (changeMaximizeRecursion)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2012-03-07 13:46:17 +00:00
|
|
|
|
2014-03-19 14:01:56 +00:00
|
|
|
if (!isResizable() || isToolbar()) // SELI isToolbar() ?
|
|
|
|
return;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-01-31 22:58:53 +00:00
|
|
|
QRect clientArea;
|
|
|
|
if (isElectricBorderMaximizing())
|
2014-03-19 13:45:27 +00:00
|
|
|
clientArea = workspace()->clientArea(MaximizeArea, Cursor::pos(), desktop());
|
2013-01-31 22:58:53 +00:00
|
|
|
else
|
|
|
|
clientArea = workspace()->clientArea(MaximizeArea, this);
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
MaximizeMode old_mode = max_mode;
|
|
|
|
// 'adjust == true' means to update the size only, e.g. after changing workspace size
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!adjust) {
|
|
|
|
if (vertical)
|
|
|
|
max_mode = MaximizeMode(max_mode ^ MaximizeVertical);
|
|
|
|
if (horizontal)
|
|
|
|
max_mode = MaximizeMode(max_mode ^ MaximizeHorizontal);
|
|
|
|
}
|
2008-07-25 10:16:09 +00:00
|
|
|
|
2013-01-31 22:58:53 +00:00
|
|
|
// if the client insist on a fix aspect ratio, we check whether the maximizing will get us
|
|
|
|
// out of screen bounds and take that as a "full maximization with aspect check" then
|
2015-01-21 15:05:29 +00:00
|
|
|
if (m_geometryHints.hasAspect() && // fixed aspect
|
2013-01-31 22:58:53 +00:00
|
|
|
(max_mode == MaximizeVertical || max_mode == MaximizeHorizontal) && // ondimensional maximization
|
|
|
|
rules()->checkStrictGeometry(true)) { // obey aspect
|
2015-01-21 15:05:29 +00:00
|
|
|
const QSize minAspect = m_geometryHints.minAspect();
|
|
|
|
const QSize maxAspect = m_geometryHints.maxAspect();
|
2013-01-31 22:58:53 +00:00
|
|
|
if (max_mode == MaximizeVertical || (old_mode & MaximizeVertical)) {
|
2015-01-21 15:05:29 +00:00
|
|
|
const double fx = minAspect.width(); // use doubles, because the values can be MAX_INT
|
|
|
|
const double fy = maxAspect.height(); // use doubles, because the values can be MAX_INT
|
2013-01-31 22:58:53 +00:00
|
|
|
if (fx*clientArea.height()/fy > clientArea.width()) // too big
|
|
|
|
max_mode = old_mode & MaximizeHorizontal ? MaximizeRestore : MaximizeFull;
|
|
|
|
} else { // max_mode == MaximizeHorizontal
|
2015-01-21 15:05:29 +00:00
|
|
|
const double fx = maxAspect.width();
|
|
|
|
const double fy = minAspect.height();
|
2013-01-31 22:58:53 +00:00
|
|
|
if (fy*clientArea.width()/fx > clientArea.height()) // too big
|
|
|
|
max_mode = old_mode & MaximizeVertical ? MaximizeRestore : MaximizeFull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
max_mode = rules()->checkMaximize(max_mode);
|
|
|
|
if (!adjust && max_mode == old_mode)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2008-01-17 15:44:21 +00:00
|
|
|
// maximing one way and unmaximizing the other way shouldn't happen,
|
|
|
|
// so restore first and then maximize the other way
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((old_mode == MaximizeVertical && max_mode == MaximizeHorizontal)
|
|
|
|
|| (old_mode == MaximizeHorizontal && max_mode == MaximizeVertical)) {
|
|
|
|
changeMaximize(false, false, false); // restore
|
|
|
|
}
|
2008-07-25 10:16:09 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
// save sizes for restoring, if maximalizing
|
2012-03-12 02:05:35 +00:00
|
|
|
QSize sz;
|
|
|
|
if (isShade())
|
|
|
|
sz = sizeForClientSize(clientSize());
|
|
|
|
else
|
|
|
|
sz = size();
|
2012-04-11 16:18:50 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
|
2012-04-11 16:18:50 +00:00
|
|
|
if (!adjust && !(old_mode & MaximizeVertical)) {
|
|
|
|
geom_restore.setTop(y());
|
|
|
|
geom_restore.setHeight(sz.height());
|
|
|
|
}
|
|
|
|
if (!adjust && !(old_mode & MaximizeHorizontal)) {
|
|
|
|
geom_restore.setLeft(x());
|
|
|
|
geom_restore.setWidth(sz.width());
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2015-02-03 23:50:17 +00:00
|
|
|
// call into decoration update borders
|
2015-12-03 12:24:44 +00:00
|
|
|
if (isDecorated() && decoration()->client() && !(options->borderlessMaximizedWindows() && max_mode == KWin::MaximizeFull)) {
|
2015-02-03 23:50:17 +00:00
|
|
|
changeMaximizeRecursion = true;
|
2015-12-03 12:24:44 +00:00
|
|
|
const auto c = decoration()->client().data();
|
2015-02-03 23:50:17 +00:00
|
|
|
if ((max_mode & MaximizeVertical) != (old_mode & MaximizeVertical)) {
|
|
|
|
emit c->maximizedVerticallyChanged(max_mode & MaximizeVertical);
|
|
|
|
}
|
|
|
|
if ((max_mode & MaximizeHorizontal) != (old_mode & MaximizeHorizontal)) {
|
|
|
|
emit c->maximizedHorizontallyChanged(max_mode & MaximizeHorizontal);
|
|
|
|
}
|
|
|
|
if ((max_mode == MaximizeFull) != (old_mode == MaximizeFull)) {
|
|
|
|
emit c->maximizedChanged(max_mode & MaximizeFull);
|
|
|
|
}
|
|
|
|
changeMaximizeRecursion = false;
|
|
|
|
}
|
|
|
|
|
2012-03-07 13:46:17 +00:00
|
|
|
if (options->borderlessMaximizedWindows()) {
|
|
|
|
// triggers a maximize change.
|
2012-04-11 16:18:50 +00:00
|
|
|
// The next setNoBorder interation will exit since there's no change but the first recursion pullutes the restore geometry
|
2012-03-07 13:46:17 +00:00
|
|
|
changeMaximizeRecursion = true;
|
2016-02-27 10:22:46 +00:00
|
|
|
setNoBorder(rules()->checkNoBorder(app_noborder || (m_motif.hasDecoration() && m_motif.noBorder()) || max_mode == MaximizeFull));
|
2012-03-07 13:46:17 +00:00
|
|
|
changeMaximizeRecursion = false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2015-12-03 12:24:44 +00:00
|
|
|
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2009-10-14 09:33:00 +00:00
|
|
|
// Conditional quick tiling exit points
|
2017-07-18 19:12:37 +00:00
|
|
|
if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (old_mode == MaximizeFull &&
|
|
|
|
!clientArea.contains(geom_restore.center())) {
|
|
|
|
// Not restoring on the same screen
|
2009-10-14 09:33:00 +00:00
|
|
|
// TODO: The following doesn't work for some reason
|
2017-07-18 19:12:37 +00:00
|
|
|
//quick_tile_mode = QuickTileFlag::None; // And exit quick tile mode manually
|
2011-01-30 14:34:42 +00:00
|
|
|
} else if ((old_mode == MaximizeVertical && max_mode == MaximizeRestore) ||
|
|
|
|
(old_mode == MaximizeFull && max_mode == MaximizeHorizontal)) {
|
|
|
|
// Modifying geometry of a tiled window
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry
|
2009-10-14 09:33:00 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-10-14 09:33:00 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
switch(max_mode) {
|
|
|
|
|
|
|
|
case MaximizeVertical: {
|
|
|
|
if (old_mode & MaximizeHorizontal) { // actually restoring from MaximizeFull
|
|
|
|
if (geom_restore.width() == 0 || !clientArea.contains(geom_restore.center())) {
|
|
|
|
// needs placement
|
|
|
|
plainResize(adjustedSize(QSize(width() * 2 / 3, clientArea.height()), SizemodeFixedH), geom_mode);
|
2012-11-22 12:33:23 +00:00
|
|
|
Placement::self()->placeSmart(this, clientArea);
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(QRect(QPoint(geom_restore.x(), clientArea.top()),
|
|
|
|
adjustedSize(QSize(geom_restore.width(), clientArea.height()), SizemodeFixedH)), geom_mode);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
} else {
|
2013-02-04 20:21:18 +00:00
|
|
|
QRect r(x(), clientArea.top(), width(), clientArea.height());
|
|
|
|
r.setTopLeft(rules()->checkPosition(r.topLeft()));
|
|
|
|
r.setSize(adjustedSize(r.size(), SizemodeFixedH));
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(r, geom_mode);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
info->setState(NET::MaxVert, NET::Max);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MaximizeHorizontal: {
|
|
|
|
if (old_mode & MaximizeVertical) { // actually restoring from MaximizeFull
|
|
|
|
if (geom_restore.height() == 0 || !clientArea.contains(geom_restore.center())) {
|
|
|
|
// needs placement
|
|
|
|
plainResize(adjustedSize(QSize(clientArea.width(), height() * 2 / 3), SizemodeFixedW), geom_mode);
|
2012-11-22 12:33:23 +00:00
|
|
|
Placement::self()->placeSmart(this, clientArea);
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(QRect(QPoint(clientArea.left(), geom_restore.y()),
|
|
|
|
adjustedSize(QSize(clientArea.width(), geom_restore.height()), SizemodeFixedW)), geom_mode);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
} else {
|
2013-02-04 20:21:18 +00:00
|
|
|
QRect r(clientArea.left(), y(), clientArea.width(), height());
|
|
|
|
r.setTopLeft(rules()->checkPosition(r.topLeft()));
|
|
|
|
r.setSize(adjustedSize(r.size(), SizemodeFixedW));
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(r, geom_mode);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
info->setState(NET::MaxHoriz, NET::Max);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MaximizeRestore: {
|
2019-09-27 10:01:10 +00:00
|
|
|
QRect restore = frameGeometry();
|
2011-01-30 14:34:42 +00:00
|
|
|
// when only partially maximized, geom_restore may not have the other dimension remembered
|
|
|
|
if (old_mode & MaximizeVertical) {
|
|
|
|
restore.setTop(geom_restore.top());
|
|
|
|
restore.setBottom(geom_restore.bottom());
|
|
|
|
}
|
|
|
|
if (old_mode & MaximizeHorizontal) {
|
|
|
|
restore.setLeft(geom_restore.left());
|
|
|
|
restore.setRight(geom_restore.right());
|
|
|
|
}
|
|
|
|
if (!restore.isValid()) {
|
|
|
|
QSize s = QSize(clientArea.width() * 2 / 3, clientArea.height() * 2 / 3);
|
|
|
|
if (geom_restore.width() > 0)
|
|
|
|
s.setWidth(geom_restore.width());
|
|
|
|
if (geom_restore.height() > 0)
|
|
|
|
s.setHeight(geom_restore.height());
|
|
|
|
plainResize(adjustedSize(s));
|
2012-11-22 12:33:23 +00:00
|
|
|
Placement::self()->placeSmart(this, clientArea);
|
2019-09-27 10:01:10 +00:00
|
|
|
restore = frameGeometry();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (geom_restore.width() > 0)
|
|
|
|
restore.moveLeft(geom_restore.x());
|
|
|
|
if (geom_restore.height() > 0)
|
|
|
|
restore.moveTop(geom_restore.y());
|
2012-04-24 18:17:09 +00:00
|
|
|
geom_restore = restore; // relevant for mouse pos calculation, bug #298646
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-01-21 15:05:29 +00:00
|
|
|
if (m_geometryHints.hasAspect()) {
|
2013-01-31 22:58:53 +00:00
|
|
|
restore.setSize(adjustedSize(restore.size(), SizemodeAny));
|
|
|
|
}
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(restore, geom_mode);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!clientArea.contains(geom_restore.center())) // Not restoring to the same screen
|
2012-11-22 12:33:23 +00:00
|
|
|
Placement::self()->place(this, clientArea);
|
2019-09-14 21:17:53 +00:00
|
|
|
info->setState(NET::States(), NET::Max);
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::None);
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MaximizeFull: {
|
2013-02-04 20:21:18 +00:00
|
|
|
QRect r(clientArea);
|
|
|
|
r.setTopLeft(rules()->checkPosition(r.topLeft()));
|
|
|
|
r.setSize(adjustedSize(r.size(), SizemodeMax));
|
2011-08-09 20:43:43 +00:00
|
|
|
if (r.size() != clientArea.size()) { // to avoid off-by-one errors...
|
2015-05-26 20:34:31 +00:00
|
|
|
if (isElectricBorderMaximizing() && r.width() < clientArea.width()) {
|
|
|
|
r.moveLeft(qMax(clientArea.left(), Cursor::pos().x() - r.width()/2));
|
|
|
|
r.moveRight(qMin(clientArea.right(), r.right()));
|
|
|
|
} else {
|
2011-08-09 20:43:43 +00:00
|
|
|
r.moveCenter(clientArea.center());
|
2015-02-06 22:46:14 +00:00
|
|
|
const bool closeHeight = r.height() > 97*clientArea.height()/100;
|
|
|
|
const bool closeWidth = r.width() > 97*clientArea.width() /100;
|
|
|
|
const bool overHeight = r.height() > clientArea.height();
|
|
|
|
const bool overWidth = r.width() > clientArea.width();
|
|
|
|
if (closeWidth || closeHeight) {
|
|
|
|
Position titlePos = titlebarPosition();
|
|
|
|
const QRect screenArea = workspace()->clientArea(ScreenArea, clientArea.center(), desktop());
|
|
|
|
if (closeHeight) {
|
|
|
|
bool tryBottom = titlePos == PositionBottom;
|
|
|
|
if ((overHeight && titlePos == PositionTop) ||
|
|
|
|
screenArea.top() == clientArea.top())
|
|
|
|
r.setTop(clientArea.top());
|
|
|
|
else
|
|
|
|
tryBottom = true;
|
|
|
|
if (tryBottom &&
|
|
|
|
(overHeight || screenArea.bottom() == clientArea.bottom()))
|
|
|
|
r.setBottom(clientArea.bottom());
|
|
|
|
}
|
|
|
|
if (closeWidth) {
|
|
|
|
bool tryLeft = titlePos == PositionLeft;
|
|
|
|
if ((overWidth && titlePos == PositionRight) ||
|
|
|
|
screenArea.right() == clientArea.right())
|
|
|
|
r.setRight(clientArea.right());
|
|
|
|
else
|
|
|
|
tryLeft = true;
|
|
|
|
if (tryLeft && (overWidth || screenArea.left() == clientArea.left()))
|
|
|
|
r.setLeft(clientArea.left());
|
|
|
|
}
|
|
|
|
}
|
2015-05-26 20:34:31 +00:00
|
|
|
}
|
2013-02-04 20:21:18 +00:00
|
|
|
r.moveTopLeft(rules()->checkPosition(r.topLeft()));
|
2011-08-09 20:43:43 +00:00
|
|
|
}
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(r, geom_mode);
|
2013-03-14 20:54:40 +00:00
|
|
|
if (options->electricBorderMaximize() && r.top() == clientArea.top())
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::Maximize);
|
2013-03-14 20:54:40 +00:00
|
|
|
else
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::None);
|
2011-01-30 14:34:42 +00:00
|
|
|
info->setState(NET::Max, NET::Max);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
updateAllowedActions();
|
2012-02-05 17:50:23 +00:00
|
|
|
updateWindowRules(Rules::MaximizeVert|Rules::MaximizeHoriz|Rules::Position|Rules::Size);
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::userCanSetFullScreen() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-01-10 15:01:42 +00:00
|
|
|
if (!isFullScreenable()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2019-01-10 12:16:01 +00:00
|
|
|
}
|
2013-09-10 19:19:58 +00:00
|
|
|
return isNormalWindow() || isDialog();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::setFullScreen(bool set, bool user)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-01-11 15:13:33 +00:00
|
|
|
set = rules()->checkFullScreen(set);
|
|
|
|
|
2019-01-10 12:16:01 +00:00
|
|
|
const bool wasFullscreen = isFullScreen();
|
2019-01-11 15:13:33 +00:00
|
|
|
if (wasFullscreen == set) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2019-01-10 12:16:01 +00:00
|
|
|
}
|
|
|
|
if (user && !userCanSetFullScreen()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2019-01-10 12:16:01 +00:00
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
setShade(ShadeNone);
|
2019-01-10 12:16:01 +00:00
|
|
|
|
|
|
|
if (wasFullscreen) {
|
2015-01-28 23:14:47 +00:00
|
|
|
workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
|
2019-01-10 12:16:01 +00:00
|
|
|
} else {
|
2019-09-27 10:01:10 +00:00
|
|
|
geom_fs_restore = frameGeometry();
|
2019-01-10 12:16:01 +00:00
|
|
|
}
|
|
|
|
|
2014-03-26 17:06:03 +00:00
|
|
|
if (set) {
|
2019-01-11 15:13:33 +00:00
|
|
|
m_fullscreenMode = FullScreenNormal;
|
2011-01-30 14:34:42 +00:00
|
|
|
workspace()->raiseClient(this);
|
2019-01-11 15:13:33 +00:00
|
|
|
} else {
|
|
|
|
m_fullscreenMode = FullScreenNone;
|
2014-03-26 17:06:03 +00:00
|
|
|
}
|
2019-01-10 12:16:01 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
StackingUpdatesBlocker blocker1(workspace());
|
|
|
|
GeometryUpdatesBlocker blocker2(this);
|
2019-01-11 15:13:33 +00:00
|
|
|
|
|
|
|
// active fullscreens get different layer
|
|
|
|
workspace()->updateClientLayer(this);
|
2019-01-10 12:16:01 +00:00
|
|
|
|
2019-09-14 21:17:53 +00:00
|
|
|
info->setState(isFullScreen() ? NET::FullScreen : NET::States(), NET::FullScreen);
|
2011-01-30 14:34:42 +00:00
|
|
|
updateDecoration(false, false);
|
2019-01-10 12:16:01 +00:00
|
|
|
|
2019-01-11 15:13:33 +00:00
|
|
|
if (set) {
|
2019-01-10 12:16:01 +00:00
|
|
|
if (info->fullscreenMonitors().isSet()) {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(fullscreenMonitorsArea(info->fullscreenMonitors()));
|
2019-01-10 12:16:01 +00:00
|
|
|
} else {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(workspace()->clientArea(FullScreenArea, this));
|
2019-01-10 12:16:01 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-01-11 15:13:33 +00:00
|
|
|
Q_ASSERT(!geom_fs_restore.isNull());
|
|
|
|
const int currentScreen = screen();
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(QRect(geom_fs_restore.topLeft(), adjustedSize(geom_fs_restore.size())));
|
2019-01-11 15:13:33 +00:00
|
|
|
if(currentScreen != screen()) {
|
|
|
|
workspace()->sendClientToScreen(this, currentScreen);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2019-01-10 12:16:01 +00:00
|
|
|
updateWindowRules(Rules::Fullscreen | Rules::Position | Rules::Size);
|
2019-01-11 15:13:33 +00:00
|
|
|
emit clientFullScreenSet(this, set, user);
|
|
|
|
emit fullScreenChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2008-11-17 08:03:39 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::updateFullscreenMonitors(NETFullscreenMonitors topology)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-04-03 10:19:27 +00:00
|
|
|
int nscreens = screens()->count();
|
2008-11-17 08:03:39 +00:00
|
|
|
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "incoming request with top: " << topology.top << " bottom: " << topology.bottom
|
2008-11-17 08:03:39 +00:00
|
|
|
// << " left: " << topology.left << " right: " << topology.right
|
|
|
|
// << ", we have: " << nscreens << " screens.";
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (topology.top >= nscreens ||
|
|
|
|
topology.bottom >= nscreens ||
|
|
|
|
topology.left >= nscreens ||
|
|
|
|
topology.right >= nscreens) {
|
2014-12-05 10:42:15 +00:00
|
|
|
qCWarning(KWIN_CORE) << "fullscreenMonitors update failed. request higher than number of screens.";
|
2011-01-30 14:34:42 +00:00
|
|
|
return;
|
2008-11-17 08:03:39 +00:00
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
info->setFullscreenMonitors(topology);
|
|
|
|
if (isFullScreen())
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(fullscreenMonitorsArea(topology));
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
|
2019-02-02 18:17:44 +00:00
|
|
|
/**
|
|
|
|
* Calculates the bounding rectangle defined by the 4 monitor indices indicating the
|
|
|
|
* top, bottom, left, and right edges of the window when the fullscreen state is enabled.
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-09-24 08:48:08 +00:00
|
|
|
QRect X11Client::fullscreenMonitorsArea(NETFullscreenMonitors requestedTopology) const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2008-11-17 08:03:39 +00:00
|
|
|
QRect top, bottom, left, right, total;
|
|
|
|
|
2013-04-03 10:19:27 +00:00
|
|
|
top = screens()->geometry(requestedTopology.top);
|
|
|
|
bottom = screens()->geometry(requestedTopology.bottom);
|
|
|
|
left = screens()->geometry(requestedTopology.left);
|
|
|
|
right = screens()->geometry(requestedTopology.right);
|
2011-01-30 14:34:42 +00:00
|
|
|
total = top.united(bottom.united(left.united(right)));
|
2008-11-17 08:03:39 +00:00
|
|
|
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "top: " << top << " bottom: " << bottom
|
2008-11-17 08:03:39 +00:00
|
|
|
// << " left: " << left << " right: " << right;
|
2013-11-01 11:29:05 +00:00
|
|
|
// qDebug() << "returning rect: " << total;
|
2008-11-17 08:03:39 +00:00
|
|
|
return total;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-11-17 08:03:39 +00:00
|
|
|
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
static GeometryTip* geometryTip = nullptr;
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::positionGeometryTip()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(isMove() || isResize());
|
2007-04-29 17:35:43 +00:00
|
|
|
// Position and Size display
|
2011-01-30 14:34:42 +00:00
|
|
|
if (effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::GeometryTip))
|
2010-11-10 19:21:56 +00:00
|
|
|
return; // some effect paints this for us
|
2011-01-30 14:34:42 +00:00
|
|
|
if (options->showGeometryTip()) {
|
|
|
|
if (!geometryTip) {
|
2015-01-21 15:05:29 +00:00
|
|
|
geometryTip = new GeometryTip(&m_geometryHints);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect wgeom(moveResizeGeometry()); // position of the frame, size of the window itself
|
2011-01-30 14:34:42 +00:00
|
|
|
wgeom.setWidth(wgeom.width() - (width() - clientSize().width()));
|
|
|
|
wgeom.setHeight(wgeom.height() - (height() - clientSize().height()));
|
|
|
|
if (isShade())
|
|
|
|
wgeom.setHeight(0);
|
|
|
|
geometryTip->setGeometry(wgeom);
|
|
|
|
if (!geometryTip->isVisible())
|
2007-04-29 17:35:43 +00:00
|
|
|
geometryTip->show();
|
2008-06-20 16:21:03 +00:00
|
|
|
geometryTip->raise();
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2012-06-13 17:38:27 +00:00
|
|
|
|
2015-10-22 16:16:21 +00:00
|
|
|
bool AbstractClient::startMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(!isMoveResize());
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
Q_ASSERT(QWidget::keyboardGrabber() == nullptr);
|
|
|
|
Q_ASSERT(QWidget::mouseGrabber() == nullptr);
|
2007-05-22 15:46:42 +00:00
|
|
|
stopDelayedMoveResize();
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
if (QApplication::activePopupWidget() != nullptr)
|
2007-04-29 17:35:43 +00:00
|
|
|
return false; // popups have grab
|
2014-03-26 16:20:16 +00:00
|
|
|
if (isFullScreen() && (screens()->count() < 2 || !isMovableAcrossScreens()))
|
|
|
|
return false;
|
2015-10-22 16:16:21 +00:00
|
|
|
if (!doStartMoveResize()) {
|
2007-04-29 17:35:43 +00:00
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-03-07 21:31:44 +00:00
|
|
|
|
2016-03-11 11:47:17 +00:00
|
|
|
invalidateDecorationDoubleClickTimer();
|
|
|
|
|
2015-10-16 07:08:02 +00:00
|
|
|
setMoveResize(true);
|
2019-04-18 12:28:11 +00:00
|
|
|
workspace()->setMoveResizeClient(this);
|
2012-03-19 21:45:50 +00:00
|
|
|
|
2015-10-16 11:10:55 +00:00
|
|
|
const Position mode = moveResizePointerMode();
|
2013-03-14 20:54:40 +00:00
|
|
|
if (mode != PositionCenter) { // means "isResize()" but moveResizeMode = true is set below
|
|
|
|
if (maximizeMode() == MaximizeFull) { // partial is cond. reset in finishMoveResize
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry()); // "restore" to current geometry
|
2013-03-14 20:54:40 +00:00
|
|
|
setMaximize(false, false);
|
2012-11-01 19:54:26 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-03-07 21:31:44 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet
|
2011-01-30 14:34:42 +00:00
|
|
|
// Exit quick tile mode when the user attempts to resize a tiled window
|
2017-07-18 19:12:37 +00:00
|
|
|
updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry());
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2015-10-22 15:08:17 +00:00
|
|
|
updateHaveResizeEffect();
|
2015-10-16 07:57:53 +00:00
|
|
|
updateInitialMoveResizeGeometry();
|
2007-04-29 17:35:43 +00:00
|
|
|
checkUnrestrictedMoveResize();
|
2011-03-13 11:41:30 +00:00
|
|
|
emit clientStartUserMovedResized(this);
|
2013-01-25 09:15:00 +00:00
|
|
|
if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
|
|
|
|
ScreenEdges::self()->reserveDesktopSwitching(true, Qt::Vertical|Qt::Horizontal);
|
2011-01-30 14:34:42 +00:00
|
|
|
return true;
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::doStartMoveResize()
|
2015-10-22 16:16:21 +00:00
|
|
|
{
|
|
|
|
bool has_grab = false;
|
|
|
|
// This reportedly improves smoothness of the moveresize operation,
|
|
|
|
// something with Enter/LeaveNotify events, looks like XFree performance problem or something *shrug*
|
2019-03-25 18:11:15 +00:00
|
|
|
// (https://lists.kde.org/?t=107302193400001&r=1&w=2)
|
2015-10-22 16:16:21 +00:00
|
|
|
QRect r = workspace()->clientArea(FullArea, this);
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_moveResizeGrabWindow.create(r, XCB_WINDOW_CLASS_INPUT_ONLY, 0, nullptr, rootWindow());
|
2015-10-22 16:16:21 +00:00
|
|
|
m_moveResizeGrabWindow.map();
|
|
|
|
m_moveResizeGrabWindow.raise();
|
|
|
|
updateXTime();
|
|
|
|
const xcb_grab_pointer_cookie_t cookie = xcb_grab_pointer_unchecked(connection(), false, m_moveResizeGrabWindow,
|
|
|
|
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION |
|
|
|
|
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
|
|
|
|
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, m_moveResizeGrabWindow, Cursor::x11Cursor(cursor()), xTime());
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
ScopedCPointer<xcb_grab_pointer_reply_t> pointerGrab(xcb_grab_pointer_reply(connection(), cookie, nullptr));
|
2015-10-22 16:16:21 +00:00
|
|
|
if (!pointerGrab.isNull() && pointerGrab->status == XCB_GRAB_STATUS_SUCCESS) {
|
|
|
|
has_grab = true;
|
|
|
|
}
|
2015-12-06 22:17:33 +00:00
|
|
|
if (!has_grab && grabXKeyboard(frameId()))
|
2015-10-22 16:16:21 +00:00
|
|
|
has_grab = move_resize_has_keyboard_grab = true;
|
|
|
|
if (!has_grab) { // at least one grab is necessary in order to be able to finish move/resize
|
|
|
|
m_moveResizeGrabWindow.reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-22 14:01:51 +00:00
|
|
|
void AbstractClient::finishMoveResize(bool cancel)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2018-01-28 09:33:26 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
2012-05-09 19:33:23 +00:00
|
|
|
const bool wasResize = isResize(); // store across leaveMoveResize
|
|
|
|
leaveMoveResize();
|
|
|
|
|
2012-07-13 07:53:21 +00:00
|
|
|
if (cancel)
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(initialMoveResizeGeometry());
|
2012-07-13 07:53:21 +00:00
|
|
|
else {
|
2015-10-16 09:13:41 +00:00
|
|
|
const QRect &moveResizeGeom = moveResizeGeometry();
|
2012-07-13 07:53:21 +00:00
|
|
|
if (wasResize) {
|
|
|
|
const bool restoreH = maximizeMode() == MaximizeHorizontal &&
|
2015-10-16 07:57:53 +00:00
|
|
|
moveResizeGeom.width() != initialMoveResizeGeometry().width();
|
2012-07-13 07:53:21 +00:00
|
|
|
const bool restoreV = maximizeMode() == MaximizeVertical &&
|
2015-10-16 07:57:53 +00:00
|
|
|
moveResizeGeom.height() != initialMoveResizeGeometry().height();
|
2013-04-14 07:44:36 +00:00
|
|
|
if (restoreH || restoreV) {
|
|
|
|
changeMaximize(restoreV, restoreH, false);
|
|
|
|
}
|
2012-05-09 19:33:23 +00:00
|
|
|
}
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(moveResizeGeom);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-04-15 18:33:01 +00:00
|
|
|
checkScreen(); // needs to be done because clientFinishUserMovedResized has not yet re-activated online alignment
|
2015-10-16 13:53:28 +00:00
|
|
|
if (screen() != moveResizeStartScreen()) {
|
2013-04-15 18:33:01 +00:00
|
|
|
workspace()->sendClientToScreen(this, screen()); // checks rule validity
|
2012-08-24 16:48:50 +00:00
|
|
|
if (maximizeMode() != MaximizeRestore)
|
|
|
|
checkWorkspacePosition();
|
|
|
|
}
|
2010-04-25 16:43:14 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isElectricBorderMaximizing()) {
|
2015-10-12 07:56:54 +00:00
|
|
|
setQuickTileMode(electricBorderMode());
|
2015-10-12 08:12:07 +00:00
|
|
|
setElectricBorderMaximizing(false);
|
2012-04-11 16:18:50 +00:00
|
|
|
} else if (!cancel) {
|
2015-10-22 14:01:51 +00:00
|
|
|
QRect geom_restore = geometryRestore();
|
2012-05-09 19:33:23 +00:00
|
|
|
if (!(maximizeMode() & MaximizeHorizontal)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
geom_restore.setX(frameGeometry().x());
|
|
|
|
geom_restore.setWidth(frameGeometry().width());
|
2012-05-09 19:33:23 +00:00
|
|
|
}
|
|
|
|
if (!(maximizeMode() & MaximizeVertical)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
geom_restore.setY(frameGeometry().y());
|
|
|
|
geom_restore.setHeight(frameGeometry().height());
|
2012-05-09 19:33:23 +00:00
|
|
|
}
|
2015-10-22 14:01:51 +00:00
|
|
|
setGeometryRestore(geom_restore);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
// FRAME update();
|
2010-04-25 16:43:14 +00:00
|
|
|
|
2011-03-13 11:41:30 +00:00
|
|
|
emit clientFinishUserMovedResized(this);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::leaveMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-11-07 23:54:05 +00:00
|
|
|
if (needsXWindowMove) {
|
|
|
|
// Do the deferred move
|
2013-09-10 06:37:49 +00:00
|
|
|
m_frame.move(geom.topLeft());
|
2012-11-07 23:54:05 +00:00
|
|
|
needsXWindowMove = false;
|
|
|
|
}
|
2012-12-29 21:27:31 +00:00
|
|
|
if (!isResize())
|
|
|
|
sendSyntheticConfigureNotify(); // tell the client about it's new final position
|
2011-01-30 14:34:42 +00:00
|
|
|
if (geometryTip) {
|
2007-04-29 17:35:43 +00:00
|
|
|
geometryTip->hide();
|
|
|
|
delete geometryTip;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
geometryTip = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (move_resize_has_keyboard_grab)
|
2007-04-29 17:35:43 +00:00
|
|
|
ungrabXKeyboard();
|
|
|
|
move_resize_has_keyboard_grab = false;
|
2013-09-10 09:34:34 +00:00
|
|
|
xcb_ungrab_pointer(connection(), xTime());
|
2013-05-02 17:04:43 +00:00
|
|
|
m_moveResizeGrabWindow.reset();
|
2013-07-31 08:11:39 +00:00
|
|
|
if (syncRequest.counter == XCB_NONE) // don't forget to sanitize since the timeout will no more fire
|
2012-10-28 12:53:08 +00:00
|
|
|
syncRequest.isPending = false;
|
2011-08-13 14:39:58 +00:00
|
|
|
delete syncRequest.timeout;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
syncRequest.timeout = nullptr;
|
2015-10-22 13:58:24 +00:00
|
|
|
AbstractClient::leaveMoveResize();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// This function checks if it actually makes sense to perform a restricted move/resize.
|
|
|
|
// If e.g. the titlebar is already outside of the workarea, there's no point in performing
|
|
|
|
// a restricted move resize, because then e.g. resize would also move the window (#74555).
|
|
|
|
// NOTE: Most of it is duplicated from handleMoveResize().
|
2015-10-16 11:18:59 +00:00
|
|
|
void AbstractClient::checkUnrestrictedMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-16 07:23:46 +00:00
|
|
|
if (isUnrestrictedMoveResize())
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2015-10-16 09:13:41 +00:00
|
|
|
const QRect &moveResizeGeom = moveResizeGeometry();
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect desktopArea = workspace()->clientArea(WorkArea, moveResizeGeom.center(), desktop());
|
2007-04-29 17:35:43 +00:00
|
|
|
int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
|
2008-07-25 10:16:09 +00:00
|
|
|
// restricted move/resize - keep at least part of the titlebar always visible
|
2007-04-29 17:35:43 +00:00
|
|
|
// how much must remain visible when moved away in that direction
|
2014-07-22 11:11:19 +00:00
|
|
|
left_marge = qMin(100 + borderRight(), moveResizeGeom.width());
|
|
|
|
right_marge = qMin(100 + borderLeft(), moveResizeGeom.width());
|
2007-04-29 17:35:43 +00:00
|
|
|
// width/height change with opaque resizing, use the initial ones
|
2015-10-16 07:57:53 +00:00
|
|
|
titlebar_marge = initialMoveResizeGeometry().height();
|
2014-07-22 11:11:19 +00:00
|
|
|
top_marge = borderBottom();
|
|
|
|
bottom_marge = borderTop();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (isResize()) {
|
|
|
|
if (moveResizeGeom.bottom() < desktopArea.top() + top_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (moveResizeGeom.right() < desktopArea.left() + left_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (moveResizeGeom.left() > desktopArea.right() - right_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
|
|
|
if (!isUnrestrictedMoveResize() && moveResizeGeom.top() < desktopArea.top()) // titlebar mustn't go out
|
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (isMove()) {
|
2012-04-16 23:24:28 +00:00
|
|
|
if (moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2007-04-29 17:35:43 +00:00
|
|
|
// no need to check top_marge, titlebar_marge already handles it
|
2012-04-16 23:24:28 +00:00
|
|
|
if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge + 1) // titlebar mustn't go out
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (moveResizeGeom.right() < desktopArea.left() + left_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (moveResizeGeom.left() > desktopArea.right() - right_marge)
|
2015-10-16 07:23:46 +00:00
|
|
|
setUnrestrictedMoveResize(true);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2007-05-22 15:46:42 +00:00
|
|
|
// When the user pressed mouse on the titlebar, don't activate move immediatelly,
|
|
|
|
// since it may be just a click. Activate instead after a delay. Move used to be
|
|
|
|
// activated only after moving by several pixels, but that looks bad.
|
2015-10-22 15:27:05 +00:00
|
|
|
void AbstractClient::startDelayedMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-22 15:27:05 +00:00
|
|
|
Q_ASSERT(!m_moveResize.delayedTimer);
|
|
|
|
m_moveResize.delayedTimer = new QTimer(this);
|
|
|
|
m_moveResize.delayedTimer->setSingleShot(true);
|
|
|
|
connect(m_moveResize.delayedTimer, &QTimer::timeout, this,
|
2014-04-28 14:44:47 +00:00
|
|
|
[this]() {
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(isMoveResizePointerButtonDown());
|
2014-04-28 14:44:47 +00:00
|
|
|
if (!startMoveResize()) {
|
2015-10-16 12:58:43 +00:00
|
|
|
setMoveResizePointerButtonDown(false);
|
2014-04-28 14:44:47 +00:00
|
|
|
}
|
|
|
|
updateCursor();
|
|
|
|
stopDelayedMoveResize();
|
|
|
|
}
|
|
|
|
);
|
2015-10-22 15:27:05 +00:00
|
|
|
m_moveResize.delayedTimer->start(QApplication::startDragTime());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-22 15:46:42 +00:00
|
|
|
|
2015-10-22 15:27:05 +00:00
|
|
|
void AbstractClient::stopDelayedMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-22 15:27:05 +00:00
|
|
|
delete m_moveResize.delayedTimer;
|
|
|
|
m_moveResize.delayedTimer = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-22 15:46:42 +00:00
|
|
|
|
2015-10-23 11:33:18 +00:00
|
|
|
void AbstractClient::handleMoveResize(const QPoint &local, const QPoint &global)
|
2015-06-05 03:06:20 +00:00
|
|
|
{
|
2019-09-27 10:01:10 +00:00
|
|
|
const QRect oldGeo = frameGeometry();
|
2015-06-05 03:06:20 +00:00
|
|
|
handleMoveResize(local.x(), local.y(), global.x(), global.y());
|
|
|
|
if (!isFullScreen() && isMove()) {
|
2019-09-27 10:01:10 +00:00
|
|
|
if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != frameGeometry()) {
|
2015-06-05 03:06:20 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
2017-07-18 19:12:37 +00:00
|
|
|
setQuickTileMode(QuickTileFlag::None);
|
2015-10-23 11:33:18 +00:00
|
|
|
const QRect &geom_restore = geometryRestore();
|
2015-10-16 07:46:33 +00:00
|
|
|
setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()),
|
|
|
|
double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height())));
|
2015-06-05 03:06:20 +00:00
|
|
|
if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore)
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(geom_restore);
|
2015-06-05 03:06:20 +00:00
|
|
|
handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position
|
2017-07-18 19:12:37 +00:00
|
|
|
} else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) {
|
2015-06-05 03:06:20 +00:00
|
|
|
checkQuickTilingMaximizationZones(global.x(), global.y());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
bool X11Client::isWaitingForMoveResizeSync() const
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-23 11:33:18 +00:00
|
|
|
return syncRequest.isPending && isResize();
|
|
|
|
}
|
|
|
|
|
|
|
|
void AbstractClient::handleMoveResize(int x, int y, int x_root, int y_root)
|
|
|
|
{
|
|
|
|
if (isWaitingForMoveResizeSync())
|
2011-08-13 14:39:58 +00:00
|
|
|
return; // we're still waiting for the client or the timeout
|
|
|
|
|
2015-10-16 11:10:55 +00:00
|
|
|
const Position mode = moveResizePointerMode();
|
2011-01-30 14:34:42 +00:00
|
|
|
if ((mode == PositionCenter && !isMovableAcrossScreens())
|
|
|
|
|| (mode != PositionCenter && (isShade() || !isResizable())))
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
|
|
|
|
2015-10-16 07:08:02 +00:00
|
|
|
if (!isMoveResize()) {
|
2015-10-16 07:46:33 +00:00
|
|
|
QPoint p(QPoint(x/* - padding_left*/, y/* - padding_top*/) - moveOffset());
|
2013-09-04 14:33:51 +00:00
|
|
|
if (p.manhattanLength() >= QApplication::startDragDistance()) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!startMoveResize()) {
|
2015-10-16 12:58:43 +00:00
|
|
|
setMoveResizePointerButtonDown(false);
|
2007-05-22 15:46:42 +00:00
|
|
|
updateCursor();
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
updateCursor();
|
|
|
|
} else
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// ShadeHover or ShadeActive, ShadeNormal was already avoided above
|
2015-10-23 11:33:18 +00:00
|
|
|
if (mode != PositionCenter && shadeMode() != ShadeNone)
|
2011-01-30 14:34:42 +00:00
|
|
|
setShade(ShadeNone);
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
QPoint globalPos(x_root, y_root);
|
2007-04-29 17:35:43 +00:00
|
|
|
// these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
|
|
|
|
// the bottomleft corner should be at is at (topleft.x(), bottomright().y())
|
2015-10-16 07:46:33 +00:00
|
|
|
QPoint topleft = globalPos - moveOffset();
|
|
|
|
QPoint bottomright = globalPos + invertedMoveOffset();
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect previousMoveResizeGeom = moveResizeGeometry();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
// TODO move whole group when moving its leader or when the leader is not mapped?
|
|
|
|
|
2015-09-27 08:41:01 +00:00
|
|
|
auto titleBarRect = [this](bool &transposed, int &requiredPixels) -> QRect {
|
2015-10-16 09:13:41 +00:00
|
|
|
const QRect &moveResizeGeom = moveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
QRect r(moveResizeGeom);
|
|
|
|
r.moveTopLeft(QPoint(0,0));
|
|
|
|
switch (titlebarPosition()) {
|
|
|
|
default:
|
2011-01-30 14:34:42 +00:00
|
|
|
case PositionTop:
|
2015-09-27 08:41:01 +00:00
|
|
|
r.setHeight(borderTop());
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
|
|
|
case PositionLeft:
|
2015-09-27 08:41:01 +00:00
|
|
|
r.setWidth(borderLeft());
|
|
|
|
transposed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2015-09-27 08:41:01 +00:00
|
|
|
case PositionBottom:
|
|
|
|
r.setTop(r.bottom() - borderBottom());
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
2015-09-27 08:41:01 +00:00
|
|
|
case PositionRight:
|
|
|
|
r.setLeft(r.right() - borderRight());
|
|
|
|
transposed = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-09-27 08:41:01 +00:00
|
|
|
// When doing a restricted move we must always keep 100px of the titlebar
|
|
|
|
// visible to allow the user to be able to move it again.
|
|
|
|
requiredPixels = qMin(100 * (transposed ? r.width() : r.height()),
|
|
|
|
moveResizeGeom.width() * moveResizeGeom.height());
|
|
|
|
return r;
|
|
|
|
};
|
|
|
|
|
|
|
|
bool update = false;
|
|
|
|
if (isResize()) {
|
2015-10-16 07:57:53 +00:00
|
|
|
QRect orig = initialMoveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
Sizemode sizemode = SizemodeAny;
|
2015-10-16 11:10:55 +00:00
|
|
|
auto calculateMoveResizeGeom = [this, &topleft, &bottomright, &orig, &sizemode, &mode]() {
|
2015-09-27 08:41:01 +00:00
|
|
|
switch(mode) {
|
|
|
|
case PositionTopLeft:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(topleft, orig.bottomRight()));
|
2015-09-27 08:41:01 +00:00
|
|
|
break;
|
|
|
|
case PositionBottomRight:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(orig.topLeft(), bottomright));
|
2015-09-27 08:41:01 +00:00
|
|
|
break;
|
|
|
|
case PositionBottomLeft:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.y()), QPoint(orig.right(), bottomright.y())));
|
2015-09-27 08:41:01 +00:00
|
|
|
break;
|
|
|
|
case PositionTopRight:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(QPoint(orig.x(), topleft.y()), QPoint(bottomright.x(), orig.bottom())));
|
2015-09-27 08:41:01 +00:00
|
|
|
break;
|
|
|
|
case PositionTop:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(QPoint(orig.left(), topleft.y()), orig.bottomRight()));
|
2015-09-27 08:41:01 +00:00
|
|
|
sizemode = SizemodeFixedH; // try not to affect height
|
|
|
|
break;
|
|
|
|
case PositionBottom:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(orig.right(), bottomright.y())));
|
2015-09-27 08:41:01 +00:00
|
|
|
sizemode = SizemodeFixedH;
|
|
|
|
break;
|
|
|
|
case PositionLeft:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.top()), orig.bottomRight()));
|
2015-09-27 08:41:01 +00:00
|
|
|
sizemode = SizemodeFixedW;
|
|
|
|
break;
|
|
|
|
case PositionRight:
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(bottomright.x(), orig.bottom())));
|
2015-09-27 08:41:01 +00:00
|
|
|
sizemode = SizemodeFixedW;
|
|
|
|
break;
|
|
|
|
case PositionCenter:
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// first resize (without checking constrains), then snap, then check bounds, then check constrains
|
|
|
|
calculateMoveResizeGeom();
|
2007-04-29 17:35:43 +00:00
|
|
|
// adjust new size to snap to other windows/borders
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(workspace()->adjustClientSize(this, moveResizeGeometry(), mode));
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2015-10-16 07:23:46 +00:00
|
|
|
if (!isUnrestrictedMoveResize()) {
|
2009-03-18 02:34:07 +00:00
|
|
|
// Make sure the titlebar isn't behind a restricted area. We don't need to restrict
|
|
|
|
// the other directions. If not visible enough, move the window to the closest valid
|
2015-09-27 08:41:01 +00:00
|
|
|
// point. We bruteforce this by slowly moving the window back to its previous position
|
|
|
|
QRegion availableArea(workspace()->clientArea(FullArea, -1, 0)); // On the screen
|
|
|
|
availableArea -= workspace()->restrictedMoveArea(desktop()); // Strut areas
|
|
|
|
bool transposed = false;
|
|
|
|
int requiredPixels;
|
|
|
|
QRect bTitleRect = titleBarRect(transposed, requiredPixels);
|
|
|
|
int lastVisiblePixels = -1;
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect lastTry = moveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
bool titleFailed = false;
|
2011-01-30 14:34:42 +00:00
|
|
|
for (;;) {
|
2015-10-16 09:13:41 +00:00
|
|
|
const QRect titleRect(bTitleRect.translated(moveResizeGeometry().topLeft()));
|
2009-03-18 02:34:07 +00:00
|
|
|
int visiblePixels = 0;
|
2015-09-27 08:41:01 +00:00
|
|
|
int realVisiblePixels = 0;
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &rect : availableArea) {
|
2015-09-27 08:41:01 +00:00
|
|
|
const QRect r = rect & titleRect;
|
|
|
|
realVisiblePixels += r.width() * r.height();
|
|
|
|
if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
|
|
|
|
(!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
|
|
|
|
visiblePixels += r.width() * r.height();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (visiblePixels >= requiredPixels)
|
2009-03-18 02:34:07 +00:00
|
|
|
break; // We have reached a valid position
|
|
|
|
|
2015-09-27 08:41:01 +00:00
|
|
|
if (realVisiblePixels <= lastVisiblePixels) {
|
|
|
|
if (titleFailed && realVisiblePixels < lastVisiblePixels)
|
|
|
|
break; // we won't become better
|
|
|
|
else {
|
|
|
|
if (!titleFailed)
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(lastTry);
|
2015-09-27 08:41:01 +00:00
|
|
|
titleFailed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lastVisiblePixels = realVisiblePixels;
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect moveResizeGeom = moveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
lastTry = moveResizeGeom;
|
|
|
|
|
2009-03-18 02:34:07 +00:00
|
|
|
// Not visible enough, move the window to the closest valid point. We bruteforce
|
|
|
|
// this by slowly moving the window back to its previous position.
|
2015-09-27 08:41:01 +00:00
|
|
|
// The geometry changes at up to two edges, the one with the title (if) shall take
|
|
|
|
// precedence. The opposing edge has no impact on visiblePixels and only one of
|
|
|
|
// the adjacent can alter at a time, ie. it's enough to ignore adjacent edges
|
|
|
|
// if the title edge altered
|
|
|
|
bool leftChanged = previousMoveResizeGeom.left() != moveResizeGeom.left();
|
|
|
|
bool rightChanged = previousMoveResizeGeom.right() != moveResizeGeom.right();
|
|
|
|
bool topChanged = previousMoveResizeGeom.top() != moveResizeGeom.top();
|
|
|
|
bool btmChanged = previousMoveResizeGeom.bottom() != moveResizeGeom.bottom();
|
|
|
|
auto fixChangedState = [titleFailed](bool &major, bool &counter, bool &ad1, bool &ad2) {
|
|
|
|
counter = false;
|
|
|
|
if (titleFailed)
|
|
|
|
major = false;
|
|
|
|
if (major)
|
|
|
|
ad1 = ad2 = false;
|
|
|
|
};
|
|
|
|
switch (titlebarPosition()) {
|
|
|
|
default:
|
|
|
|
case PositionTop:
|
|
|
|
fixChangedState(topChanged, btmChanged, leftChanged, rightChanged);
|
|
|
|
break;
|
|
|
|
case PositionLeft:
|
|
|
|
fixChangedState(leftChanged, rightChanged, topChanged, btmChanged);
|
|
|
|
break;
|
|
|
|
case PositionBottom:
|
|
|
|
fixChangedState(btmChanged, topChanged, leftChanged, rightChanged);
|
|
|
|
break;
|
|
|
|
case PositionRight:
|
|
|
|
fixChangedState(rightChanged, leftChanged, topChanged, btmChanged);
|
|
|
|
break;
|
2009-02-17 15:50:00 +00:00
|
|
|
}
|
2015-09-27 08:41:01 +00:00
|
|
|
if (topChanged)
|
|
|
|
moveResizeGeom.setTop(moveResizeGeom.y() + sign(previousMoveResizeGeom.y() - moveResizeGeom.y()));
|
|
|
|
else if (leftChanged)
|
|
|
|
moveResizeGeom.setLeft(moveResizeGeom.x() + sign(previousMoveResizeGeom.x() - moveResizeGeom.x()));
|
|
|
|
else if (btmChanged)
|
|
|
|
moveResizeGeom.setBottom(moveResizeGeom.bottom() + sign(previousMoveResizeGeom.bottom() - moveResizeGeom.bottom()));
|
|
|
|
else if (rightChanged)
|
|
|
|
moveResizeGeom.setRight(moveResizeGeom.right() + sign(previousMoveResizeGeom.right() - moveResizeGeom.right()));
|
|
|
|
else
|
|
|
|
break; // no position changed - that's certainly not good
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(moveResizeGeom);
|
2009-06-26 09:06:48 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2009-06-26 09:06:48 +00:00
|
|
|
// Always obey size hints, even when in "unrestricted" mode
|
2015-10-16 09:13:41 +00:00
|
|
|
QSize size = adjustedSize(moveResizeGeometry().size(), sizemode);
|
2009-06-26 09:06:48 +00:00
|
|
|
// the new topleft and bottomright corners (after checking size constrains), if they'll be needed
|
2015-10-16 09:13:41 +00:00
|
|
|
topleft = QPoint(moveResizeGeometry().right() - size.width() + 1, moveResizeGeometry().bottom() - size.height() + 1);
|
|
|
|
bottomright = QPoint(moveResizeGeometry().left() + size.width() - 1, moveResizeGeometry().top() + size.height() - 1);
|
|
|
|
orig = moveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
|
|
|
|
// if aspect ratios are specified, both dimensions may change.
|
|
|
|
// Therefore grow to the right/bottom if needed.
|
|
|
|
// TODO it should probably obey gravity rather than always using right/bottom ?
|
|
|
|
if (sizemode == SizemodeFixedH)
|
|
|
|
orig.setRight(bottomright.x());
|
|
|
|
else if (sizemode == SizemodeFixedW)
|
|
|
|
orig.setBottom(bottomright.y());
|
|
|
|
|
|
|
|
calculateMoveResizeGeom();
|
2009-06-26 09:06:48 +00:00
|
|
|
|
2015-10-16 09:13:41 +00:00
|
|
|
if (moveResizeGeometry().size() != previousMoveResizeGeom.size())
|
2007-04-29 17:35:43 +00:00
|
|
|
update = true;
|
2011-01-30 14:34:42 +00:00
|
|
|
} else if (isMove()) {
|
2019-08-31 14:28:37 +00:00
|
|
|
Q_ASSERT(mode == PositionCenter);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!isMovable()) { // isMovableAcrossScreens() must have been true to get here
|
|
|
|
// Special moving of maximized windows on Xinerama screens
|
2013-04-03 10:19:27 +00:00
|
|
|
int screen = screens()->number(globalPos);
|
2011-08-09 20:43:43 +00:00
|
|
|
if (isFullScreen())
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(workspace()->clientArea(FullScreenArea, screen, 0));
|
2011-08-09 20:43:43 +00:00
|
|
|
else {
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect moveResizeGeom = workspace()->clientArea(MaximizeArea, screen, 0);
|
2011-08-09 20:43:43 +00:00
|
|
|
QSize adjSize = adjustedSize(moveResizeGeom.size(), SizemodeMax);
|
|
|
|
if (adjSize != moveResizeGeom.size()) {
|
|
|
|
QRect r(moveResizeGeom);
|
|
|
|
moveResizeGeom.setSize(adjSize);
|
|
|
|
moveResizeGeom.moveCenter(r.center());
|
|
|
|
}
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(moveResizeGeom);
|
2011-08-09 20:43:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
} else {
|
2008-07-25 10:31:47 +00:00
|
|
|
// first move, then snap, then check bounds
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect moveResizeGeom = moveResizeGeometry();
|
2011-01-30 14:34:42 +00:00
|
|
|
moveResizeGeom.moveTopLeft(topleft);
|
|
|
|
moveResizeGeom.moveTopLeft(workspace()->adjustClientPosition(this, moveResizeGeom.topLeft(),
|
2015-10-16 07:23:46 +00:00
|
|
|
isUnrestrictedMoveResize()));
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(moveResizeGeom);
|
2009-02-17 15:50:00 +00:00
|
|
|
|
2015-10-16 07:23:46 +00:00
|
|
|
if (!isUnrestrictedMoveResize()) {
|
2012-06-13 17:38:27 +00:00
|
|
|
const QRegion strut = workspace()->restrictedMoveArea(desktop()); // Strut areas
|
2015-09-27 08:41:01 +00:00
|
|
|
QRegion availableArea(workspace()->clientArea(FullArea, -1, 0)); // On the screen
|
|
|
|
availableArea -= strut; // Strut areas
|
|
|
|
bool transposed = false;
|
|
|
|
int requiredPixels;
|
|
|
|
QRect bTitleRect = titleBarRect(transposed, requiredPixels);
|
2011-01-30 14:34:42 +00:00
|
|
|
for (;;) {
|
2015-10-16 09:13:41 +00:00
|
|
|
QRect moveResizeGeom = moveResizeGeometry();
|
2015-09-27 08:41:01 +00:00
|
|
|
const QRect titleRect(bTitleRect.translated(moveResizeGeom.topLeft()));
|
2009-03-18 02:34:07 +00:00
|
|
|
int visiblePixels = 0;
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &rect : availableArea) {
|
2015-09-27 08:41:01 +00:00
|
|
|
const QRect r = rect & titleRect;
|
|
|
|
if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
|
|
|
|
(!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
|
|
|
|
visiblePixels += r.width() * r.height();
|
|
|
|
}
|
|
|
|
if (visiblePixels >= requiredPixels)
|
2009-03-18 02:34:07 +00:00
|
|
|
break; // We have reached a valid position
|
|
|
|
|
2012-06-13 17:38:27 +00:00
|
|
|
// (esp.) if there're more screens with different struts (panels) it the titlebar
|
|
|
|
// will be movable outside the movearea (covering one of the panels) until it
|
|
|
|
// crosses the panel "too much" (not enough visiblePixels) and then stucks because
|
|
|
|
// it's usually only pushed by 1px to either direction
|
|
|
|
// so we first check whether we intersect suc strut and move the window below it
|
|
|
|
// immediately (it's still possible to hit the visiblePixels >= titlebarArea break
|
|
|
|
// by moving the window slightly downwards, but it won't stuck)
|
|
|
|
// see bug #274466
|
|
|
|
// and bug #301805 for why we can't just match the titlearea against the screen
|
2013-04-03 10:19:27 +00:00
|
|
|
if (screens()->count() > 1) { // optimization
|
2012-06-13 17:38:27 +00:00
|
|
|
// TODO: could be useful on partial screen struts (half-width panels etc.)
|
|
|
|
int newTitleTop = -1;
|
2019-07-09 20:08:47 +00:00
|
|
|
for (const QRect &r : strut) {
|
2012-06-13 17:38:27 +00:00
|
|
|
if (r.top() == 0 && r.width() > r.height() && // "top panel"
|
|
|
|
r.intersects(moveResizeGeom) && moveResizeGeom.top() < r.bottom()) {
|
2014-02-13 23:14:53 +00:00
|
|
|
newTitleTop = r.bottom() + 1;
|
2012-06-13 17:38:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (newTitleTop > -1) {
|
|
|
|
moveResizeGeom.moveTop(newTitleTop); // invalid position, possibly on screen change
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(moveResizeGeom);
|
2012-06-13 17:38:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-18 14:22:34 +00:00
|
|
|
int dx = sign(previousMoveResizeGeom.x() - moveResizeGeom.x()),
|
|
|
|
dy = sign(previousMoveResizeGeom.y() - moveResizeGeom.y());
|
|
|
|
if (visiblePixels && dx) // means there's no full width cap -> favor horizontally
|
|
|
|
dy = 0;
|
|
|
|
else if (dy)
|
|
|
|
dx = 0;
|
|
|
|
|
|
|
|
// Move it back
|
|
|
|
moveResizeGeom.translate(dx, dy);
|
2015-10-16 09:13:41 +00:00
|
|
|
setMoveResizeGeometry(moveResizeGeom);
|
2013-07-18 14:22:34 +00:00
|
|
|
|
2012-06-13 17:38:27 +00:00
|
|
|
if (moveResizeGeom == previousMoveResizeGeom) {
|
2009-03-18 02:34:07 +00:00
|
|
|
break; // Prevent lockup
|
2012-06-13 17:38:27 +00:00
|
|
|
}
|
2009-02-17 15:50:00 +00:00
|
|
|
}
|
2008-07-25 10:31:47 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2015-10-16 09:13:41 +00:00
|
|
|
if (moveResizeGeometry().topLeft() != previousMoveResizeGeom.topLeft())
|
2011-01-30 14:34:42 +00:00
|
|
|
update = true;
|
|
|
|
} else
|
2008-09-17 11:44:51 +00:00
|
|
|
abort();
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-08-13 14:39:58 +00:00
|
|
|
if (!update)
|
|
|
|
return;
|
2007-06-25 08:51:44 +00:00
|
|
|
|
2015-10-22 15:08:17 +00:00
|
|
|
if (isResize() && !haveResizeEffect()) {
|
2015-10-23 11:33:18 +00:00
|
|
|
doResizeSync();
|
2011-08-13 14:39:58 +00:00
|
|
|
} else
|
2007-06-25 08:51:44 +00:00
|
|
|
performMoveResize();
|
2010-04-25 16:43:14 +00:00
|
|
|
|
2013-01-25 09:15:00 +00:00
|
|
|
if (isMove()) {
|
|
|
|
ScreenEdges::self()->check(globalPos, QDateTime::fromMSecsSinceEpoch(xTime()));
|
2007-06-25 08:51:44 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-06-25 08:51:44 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::doResizeSync()
|
2015-10-23 11:33:18 +00:00
|
|
|
{
|
|
|
|
if (!syncRequest.timeout) {
|
|
|
|
syncRequest.timeout = new QTimer(this);
|
2019-09-24 08:48:08 +00:00
|
|
|
connect(syncRequest.timeout, &QTimer::timeout, this, &X11Client::performMoveResize);
|
2015-10-23 11:33:18 +00:00
|
|
|
syncRequest.timeout->setSingleShot(true);
|
|
|
|
}
|
|
|
|
if (syncRequest.counter != XCB_NONE) {
|
|
|
|
syncRequest.timeout->start(250);
|
|
|
|
sendSyncRequest();
|
|
|
|
} else { // for clients not supporting the XSYNC protocol, we
|
|
|
|
syncRequest.isPending = true; // limit the resizes to 30Hz to take pointless load from X11
|
|
|
|
syncRequest.timeout->start(33); // and the client, the mouse is still moved at full speed
|
|
|
|
} // and no human can control faster resizes anyway
|
|
|
|
const QRect &moveResizeGeom = moveResizeGeometry();
|
|
|
|
m_client.setGeometry(0, 0, moveResizeGeom.width() - (borderLeft() + borderRight()), moveResizeGeom.height() - (borderTop() + borderBottom()));
|
|
|
|
}
|
|
|
|
|
2015-10-23 11:05:55 +00:00
|
|
|
void AbstractClient::performMoveResize()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-16 09:13:41 +00:00
|
|
|
const QRect &moveResizeGeom = moveResizeGeometry();
|
2015-10-22 15:08:17 +00:00
|
|
|
if (isMove() || (isResize() && !haveResizeEffect())) {
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(moveResizeGeom);
|
2011-12-09 19:44:06 +00:00
|
|
|
}
|
2015-10-23 11:05:55 +00:00
|
|
|
doPerformMoveResize();
|
2012-10-28 12:53:08 +00:00
|
|
|
if (isResize())
|
2011-08-13 14:39:58 +00:00
|
|
|
addRepaintFull();
|
2011-05-21 19:15:06 +00:00
|
|
|
positionGeometryTip();
|
2011-03-13 11:41:30 +00:00
|
|
|
emit clientStepUserMovedResized(this, moveResizeGeom);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
void X11Client::doPerformMoveResize()
|
2015-10-23 11:05:55 +00:00
|
|
|
{
|
|
|
|
if (syncRequest.counter == XCB_NONE) // client w/o XSYNC support. allow the next resize event
|
|
|
|
syncRequest.isPending = false; // NEVER do this for clients with a valid counter
|
|
|
|
// (leads to sync request races in some clients)
|
|
|
|
}
|
|
|
|
|
2015-10-12 07:56:54 +00:00
|
|
|
void AbstractClient::setElectricBorderMode(QuickTileMode mode)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
|
2011-03-07 21:31:44 +00:00
|
|
|
// sanitize the mode, ie. simplify "invalid" combinations
|
2017-07-18 19:12:37 +00:00
|
|
|
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
|
|
|
|
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
|
|
|
|
if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
|
|
|
|
mode &= ~QuickTileMode(QuickTileFlag::Vertical);
|
2011-03-07 21:31:44 +00:00
|
|
|
}
|
2015-10-12 07:56:54 +00:00
|
|
|
m_electricMode = mode;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-08 20:01:08 +00:00
|
|
|
|
2015-10-12 08:12:07 +00:00
|
|
|
void AbstractClient::setElectricBorderMaximizing(bool maximizing)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2015-10-12 08:12:07 +00:00
|
|
|
m_electricMaximizing = maximizing;
|
2011-01-30 14:34:42 +00:00
|
|
|
if (maximizing)
|
2017-04-25 14:38:52 +00:00
|
|
|
outline()->show(electricBorderMaximizeGeometry(Cursor::pos(), desktop()), moveResizeGeometry());
|
2009-09-08 20:01:08 +00:00
|
|
|
else
|
2013-04-25 06:14:34 +00:00
|
|
|
outline()->hide();
|
2013-04-25 07:40:13 +00:00
|
|
|
elevate(maximizing);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-08 20:01:08 +00:00
|
|
|
|
2015-10-12 08:21:01 +00:00
|
|
|
QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2017-07-18 19:12:37 +00:00
|
|
|
if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (maximizeMode() == MaximizeFull)
|
2011-03-07 21:31:44 +00:00
|
|
|
return geometryRestore();
|
2011-01-30 14:34:42 +00:00
|
|
|
else
|
2011-03-07 21:31:44 +00:00
|
|
|
return workspace()->clientArea(MaximizeArea, pos, desktop);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-03-07 21:31:44 +00:00
|
|
|
|
|
|
|
QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop);
|
2017-07-18 19:12:37 +00:00
|
|
|
if (electricBorderMode() & QuickTileFlag::Left)
|
2011-08-10 21:54:28 +00:00
|
|
|
ret.setRight(ret.left()+ret.width()/2 - 1);
|
2017-07-18 19:12:37 +00:00
|
|
|
else if (electricBorderMode() & QuickTileFlag::Right)
|
2011-08-10 21:54:28 +00:00
|
|
|
ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1);
|
2017-07-18 19:12:37 +00:00
|
|
|
if (electricBorderMode() & QuickTileFlag::Top)
|
2011-08-10 21:54:28 +00:00
|
|
|
ret.setBottom(ret.top()+ret.height()/2 - 1);
|
2017-07-18 19:12:37 +00:00
|
|
|
else if (electricBorderMode() & QuickTileFlag::Bottom)
|
2011-08-10 21:54:28 +00:00
|
|
|
ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1);
|
2011-03-07 21:31:44 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2009-09-08 20:01:08 +00:00
|
|
|
|
2015-10-13 14:08:57 +00:00
|
|
|
void AbstractClient::setQuickTileMode(QuickTileMode mode, bool keyboard)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2019-09-05 06:50:10 +00:00
|
|
|
// Only allow quick tile on a regular window.
|
|
|
|
if (!isResizable()) {
|
2011-01-30 14:34:42 +00:00
|
|
|
return;
|
2019-09-05 06:50:10 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2015-01-28 23:14:47 +00:00
|
|
|
workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
|
2015-01-28 23:14:47 +00:00
|
|
|
|
2014-01-24 21:31:46 +00:00
|
|
|
GeometryUpdatesBlocker blocker(this);
|
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
|
|
|
|
m_quickTileMode = int(QuickTileFlag::None);
|
2013-12-23 01:28:54 +00:00
|
|
|
if (maximizeMode() == MaximizeFull) {
|
2011-03-07 21:31:44 +00:00
|
|
|
setMaximize(false, false);
|
2013-12-23 01:28:54 +00:00
|
|
|
} else {
|
2015-10-13 11:56:07 +00:00
|
|
|
QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore
|
2017-07-18 19:12:37 +00:00
|
|
|
m_quickTileMode = int(QuickTileFlag::Maximize);
|
2011-03-07 21:31:44 +00:00
|
|
|
setMaximize(true, true);
|
2013-03-14 20:54:40 +00:00
|
|
|
QRect clientArea = workspace()->clientArea(MaximizeArea, this);
|
2019-09-27 10:01:10 +00:00
|
|
|
if (frameGeometry().top() != clientArea.top()) {
|
|
|
|
QRect r(frameGeometry());
|
2013-03-14 20:54:40 +00:00
|
|
|
r.moveTop(clientArea.top());
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(r);
|
2013-03-14 20:54:40 +00:00
|
|
|
}
|
2015-10-13 11:56:07 +00:00
|
|
|
setGeometryRestore(prev_geom_restore);
|
2011-03-07 21:31:44 +00:00
|
|
|
}
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2011-03-07 21:31:44 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// sanitize the mode, ie. simplify "invalid" combinations
|
2017-07-18 19:12:37 +00:00
|
|
|
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
|
|
|
|
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
|
|
|
|
if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
|
|
|
|
mode &= ~QuickTileMode(QuickTileFlag::Vertical);
|
2011-03-07 21:31:44 +00:00
|
|
|
|
|
|
|
setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
|
|
|
|
|
2009-09-13 17:09:44 +00:00
|
|
|
// restore from maximized so that it is possible to tile maximized windows with one hit or by dragging
|
2015-03-22 15:02:52 +00:00
|
|
|
if (maximizeMode() != MaximizeRestore) {
|
2012-03-15 23:15:13 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode != QuickTileMode(QuickTileFlag::None)) {
|
2013-02-17 00:56:01 +00:00
|
|
|
// decorations may turn off some borders when tiled
|
2015-10-13 09:14:41 +00:00
|
|
|
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
|
2017-07-18 19:12:37 +00:00
|
|
|
m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused
|
2017-11-22 19:57:22 +00:00
|
|
|
|
|
|
|
setMaximize(false, false);
|
|
|
|
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(electricBorderMaximizeGeometry(keyboard ? frameGeometry().center() : Cursor::pos(), desktop()), geom_mode);
|
2017-11-22 19:57:22 +00:00
|
|
|
// Store the mode change
|
|
|
|
m_quickTileMode = mode;
|
|
|
|
} else {
|
|
|
|
m_quickTileMode = mode;
|
|
|
|
setMaximize(false, false);
|
2013-02-17 00:56:01 +00:00
|
|
|
}
|
2016-09-16 12:27:50 +00:00
|
|
|
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2010-01-09 09:49:52 +00:00
|
|
|
|
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode != QuickTileMode(QuickTileFlag::None)) {
|
2019-09-27 10:01:10 +00:00
|
|
|
QPoint whichScreen = keyboard ? frameGeometry().center() : Cursor::pos();
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2009-12-23 01:36:44 +00:00
|
|
|
// If trying to tile to the side that the window is already tiled to move the window to the next
|
2017-07-18 19:12:37 +00:00
|
|
|
// screen if it exists, otherwise toggle the mode (set QuickTileFlag::None)
|
2015-10-13 12:18:27 +00:00
|
|
|
if (quickTileMode() == mode) {
|
2013-04-03 10:19:27 +00:00
|
|
|
const int numScreens = screens()->count();
|
2009-12-23 01:36:44 +00:00
|
|
|
const int curScreen = screen();
|
|
|
|
int nextScreen = curScreen;
|
2010-01-03 17:26:27 +00:00
|
|
|
QVarLengthArray<QRect> screens(numScreens);
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int i = 0; i < numScreens; ++i) // Cache
|
2013-04-03 10:19:27 +00:00
|
|
|
screens[i] = Screens::self()->geometry(i);
|
2011-01-30 14:34:42 +00:00
|
|
|
for (int i = 0; i < numScreens; ++i) {
|
2013-12-23 01:28:54 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (i == curScreen)
|
2009-12-23 01:36:44 +00:00
|
|
|
continue;
|
2013-12-23 01:28:54 +00:00
|
|
|
|
|
|
|
if (screens[i].bottom() <= screens[curScreen].top() || screens[i].top() >= screens[curScreen].bottom())
|
|
|
|
continue; // not in horizontal line
|
|
|
|
|
|
|
|
const int x = screens[i].center().x();
|
2017-07-18 19:12:37 +00:00
|
|
|
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) {
|
2013-12-23 01:28:54 +00:00
|
|
|
if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x()))
|
|
|
|
continue; // not left of current or more left then found next
|
2017-07-18 19:12:37 +00:00
|
|
|
} else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) {
|
2013-12-23 01:28:54 +00:00
|
|
|
if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x()))
|
|
|
|
continue; // not right of current or more right then found next
|
|
|
|
}
|
|
|
|
|
|
|
|
nextScreen = i;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2013-12-23 01:28:54 +00:00
|
|
|
|
|
|
|
if (nextScreen == curScreen) {
|
2017-07-18 19:12:37 +00:00
|
|
|
mode = QuickTileFlag::None; // No other screens, toggle tiling
|
2013-12-23 01:28:54 +00:00
|
|
|
} else {
|
|
|
|
// Move to other screen
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft()));
|
2013-12-23 01:28:54 +00:00
|
|
|
whichScreen = screens[nextScreen].center();
|
|
|
|
|
|
|
|
// Swap sides
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode & QuickTileFlag::Horizontal) {
|
|
|
|
mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical);
|
2017-07-15 06:55:49 +00:00
|
|
|
}
|
2013-12-23 01:28:54 +00:00
|
|
|
}
|
|
|
|
setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
|
2017-07-18 19:12:37 +00:00
|
|
|
} else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
|
2009-12-23 01:36:44 +00:00
|
|
|
// Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile.
|
|
|
|
// Store geometry first, so we can go out of this tile later.
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry());
|
2012-03-15 23:15:13 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode != QuickTileMode(QuickTileFlag::None)) {
|
2015-10-13 14:08:57 +00:00
|
|
|
m_quickTileMode = mode;
|
2013-02-17 00:56:01 +00:00
|
|
|
// decorations may turn off some borders when tiled
|
2015-10-13 09:14:41 +00:00
|
|
|
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
|
2013-02-17 00:56:01 +00:00
|
|
|
// Temporary, so the maximize code doesn't get all confused
|
2017-07-18 19:12:37 +00:00
|
|
|
m_quickTileMode = int(QuickTileFlag::None);
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode);
|
2013-02-17 00:56:01 +00:00
|
|
|
}
|
2012-03-15 23:15:13 +00:00
|
|
|
|
2009-09-13 17:09:44 +00:00
|
|
|
// Store the mode change
|
2015-10-13 14:08:57 +00:00
|
|
|
m_quickTileMode = mode;
|
2009-09-13 17:09:44 +00:00
|
|
|
}
|
2013-12-23 01:28:54 +00:00
|
|
|
|
2017-07-18 19:12:37 +00:00
|
|
|
if (mode == QuickTileMode(QuickTileFlag::None)) {
|
|
|
|
m_quickTileMode = int(QuickTileFlag::None);
|
2013-12-23 01:28:54 +00:00
|
|
|
// Untiling, so just restore geometry, and we're done.
|
2015-10-13 11:56:07 +00:00
|
|
|
if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry());
|
2013-12-23 01:28:54 +00:00
|
|
|
// decorations may turn off some borders when tiled
|
2015-10-13 09:14:41 +00:00
|
|
|
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(geometryRestore(), geom_mode);
|
2013-12-23 01:28:54 +00:00
|
|
|
checkWorkspacePosition(); // Just in case it's a different screen
|
|
|
|
}
|
2014-07-25 09:19:54 +00:00
|
|
|
emit quickTileModeChanged();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2015-10-14 11:37:46 +00:00
|
|
|
void AbstractClient::sendToScreen(int newScreen)
|
2013-11-17 16:37:46 +00:00
|
|
|
{
|
|
|
|
newScreen = rules()->checkScreen(newScreen);
|
|
|
|
if (isActive()) {
|
|
|
|
screens()->setCurrent(newScreen);
|
|
|
|
// might impact the layer of a fullscreen window
|
2015-10-14 11:37:46 +00:00
|
|
|
foreach (AbstractClient *cc, workspace()->allClientList()) {
|
2013-11-17 16:37:46 +00:00
|
|
|
if (cc->isFullScreen() && cc->screen() == newScreen) {
|
|
|
|
cc->updateLayer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (screen() == newScreen) // Don't use isOnScreen(), that's true even when only partially
|
|
|
|
return;
|
|
|
|
|
|
|
|
GeometryUpdatesBlocker blocker(this);
|
|
|
|
|
|
|
|
// operating on the maximized / quicktiled window would leave the old geom_restore behind,
|
|
|
|
// so we clear the state first
|
|
|
|
MaximizeMode maxMode = maximizeMode();
|
2015-10-13 12:18:27 +00:00
|
|
|
QuickTileMode qtMode = quickTileMode();
|
2014-02-06 17:36:11 +00:00
|
|
|
if (maxMode != MaximizeRestore)
|
|
|
|
maximize(MaximizeRestore);
|
2017-07-18 19:12:37 +00:00
|
|
|
if (qtMode != QuickTileMode(QuickTileFlag::None))
|
|
|
|
setQuickTileMode(QuickTileFlag::None, true);
|
2013-11-17 16:37:46 +00:00
|
|
|
|
|
|
|
QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this);
|
|
|
|
QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop());
|
2014-02-06 17:36:11 +00:00
|
|
|
|
|
|
|
// the window can have its center so that the position correction moves the new center onto
|
|
|
|
// the old screen, what will tile it where it is. Ie. the screen is not changed
|
|
|
|
// this happens esp. with electric border quicktiling
|
2017-07-18 19:12:37 +00:00
|
|
|
if (qtMode != QuickTileMode(QuickTileFlag::None))
|
2014-02-06 17:36:11 +00:00
|
|
|
keepInArea(oldScreenArea);
|
|
|
|
|
2019-09-27 10:01:10 +00:00
|
|
|
QRect oldGeom = frameGeometry();
|
2013-11-17 16:37:46 +00:00
|
|
|
QRect newGeom = oldGeom;
|
|
|
|
// move the window to have the same relative position to the center of the screen
|
|
|
|
// (i.e. one near the middle of the right edge will also end up near the middle of the right edge)
|
|
|
|
QPoint center = newGeom.center() - oldScreenArea.center();
|
|
|
|
center.setX(center.x() * screenArea.width() / oldScreenArea.width());
|
|
|
|
center.setY(center.y() * screenArea.height() / oldScreenArea.height());
|
|
|
|
center += screenArea.center();
|
|
|
|
newGeom.moveCenter(center);
|
2019-09-27 10:01:10 +00:00
|
|
|
setFrameGeometry(newGeom);
|
2013-11-17 16:37:46 +00:00
|
|
|
|
|
|
|
// If the window was inside the old screen area, explicitly make sure its inside also the new screen area.
|
|
|
|
// Calling checkWorkspacePosition() should ensure that, but when moving to a small screen the window could
|
|
|
|
// be big enough to overlap outside of the new screen area, making struts from other screens come into effect,
|
|
|
|
// which could alter the resulting geometry.
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
if (oldScreenArea.contains(oldGeom)) {
|
2013-11-17 16:37:46 +00:00
|
|
|
keepInArea(screenArea);
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// align geom_restore - checkWorkspacePosition operates on it
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry());
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
|
2013-11-17 16:37:46 +00:00
|
|
|
checkWorkspacePosition(oldGeom);
|
|
|
|
|
fix sendToScreen/checkWorkspaceGeometry
Prime target is to preserve the in-screen
condition of client AND window.i[1]
Atm. when the client is fully in sight
(but the window is not) - regardless of snapping
or screen change - a workspace update (screen change,
resolution change, adding/removing a strutting panel)
would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen smaller
than the window, the window is shrinked to the dimensions of that
screen and now randomly touches eg. left AND right edge. When
moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 122517
FIXED-IN: 5.4
Prime target is to preserve the in-screen condition
of client AND window.[1]
Atm. when the client is fully in sight (but the window is not) -
regardless of snapping or screen change - a workspace update
(screen change, resolution change, adding/removing a strutting
panel) would allow the client to partiall escape screen bounds.
This is changed so that if the client is fully in sight,
it's kept fully in sight (but not the decoration)
If the entire window was fully in sight, it's also kept
(as is right now)
The code handles inner screen edges (if the client was in sight,
the entire window will be if we'd bleed to the other screen)
[1] I'd say that handling the client is more relevant,
but foresee more complaints if the window wasn't handled anymore ;-)
During that, i stumbled across some other issues.
- when a window centered on one screen is moved to a screen
smaller than the window, the window is shrinked to the dimensions
of that screen and now randomly touches eg. left AND right edge.
When moved back, the right and bottom edge were preferred
(to the window was "moved" into the lower right corner).
It's now kept centered.
- geom_restore was saved before keeping the window in the new
screen area (causing accidental drops on screen changes)
BUG: 330968
REVIEW: 116029
FIXED-IN: 5.3
2015-02-06 21:48:12 +00:00
|
|
|
// re-align geom_restore to constrained geometry
|
2019-09-27 10:01:10 +00:00
|
|
|
setGeometryRestore(frameGeometry());
|
2013-11-17 16:37:46 +00:00
|
|
|
|
|
|
|
// finally reset special states
|
2017-07-18 19:12:37 +00:00
|
|
|
// NOTICE that MaximizeRestore/QuickTileFlag::None checks are required.
|
|
|
|
// eg. setting QuickTileFlag::None would break maximization
|
2013-11-17 16:37:46 +00:00
|
|
|
if (maxMode != MaximizeRestore)
|
|
|
|
maximize(maxMode);
|
2017-07-18 19:12:37 +00:00
|
|
|
if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode())
|
2014-02-06 17:36:11 +00:00
|
|
|
setQuickTileMode(qtMode, true);
|
2013-11-17 16:37:46 +00:00
|
|
|
|
2015-09-14 07:27:48 +00:00
|
|
|
auto tso = workspace()->ensureStackingOrder(transients());
|
|
|
|
for (auto it = tso.constBegin(), end = tso.constEnd(); it != end; ++it)
|
2013-11-17 16:37:46 +00:00
|
|
|
(*it)->sendToScreen(newScreen);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-09-13 17:09:44 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|