2007-11-27 22:40:25 +03:00
|
|
|
/********************************************************************
|
2007-04-29 21:35:43 +04:00
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
|
|
|
|
Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
|
2007-11-27 22:40:25 +03: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 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// This file contains things relevant to handling incoming events.
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
#include "client.h"
|
|
|
|
|
|
|
|
#include <kstartupinfo.h>
|
|
|
|
|
2013-04-04 18:14:12 +04:00
|
|
|
#ifdef KWIN_BUILD_ACTIVITIES
|
|
|
|
#include "activities.h"
|
|
|
|
#endif
|
2013-02-19 14:25:46 +04:00
|
|
|
#include "cursor.h"
|
2013-12-02 01:12:25 +04:00
|
|
|
#include "decorations.h"
|
2007-04-29 21:35:43 +04:00
|
|
|
#include <QX11Info>
|
|
|
|
#include "rules.h"
|
|
|
|
#include "group.h"
|
2013-04-26 12:41:24 +04:00
|
|
|
#include "netinfo.h"
|
2013-04-03 14:19:27 +04:00
|
|
|
#include "screens.h"
|
2013-04-26 13:52:15 +04:00
|
|
|
#include "workspace.h"
|
2012-12-21 18:11:31 +04:00
|
|
|
#include "xcbutils.h"
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2013-08-20 11:48:14 +04:00
|
|
|
#include <xcb/shape.h>
|
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
/**
|
|
|
|
* Manages the clients. This means handling the very first maprequest:
|
|
|
|
* reparenting, initial geometry, initial state, placement, etc.
|
|
|
|
* Returns false if KWin is not going to manage this window.
|
2007-04-29 21:35:43 +04:00
|
|
|
*/
|
2013-05-03 12:20:05 +04:00
|
|
|
bool Client::manage(xcb_window_t w, bool isMapped)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
|
|
|
StackingUpdatesBlocker stacking_blocker(workspace());
|
2010-11-14 11:45:55 +03:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
grabXServer();
|
|
|
|
|
2014-04-25 15:42:52 +04:00
|
|
|
Xcb::WindowAttributes attr(w);
|
|
|
|
Xcb::WindowGeometry windowGeometry(w);
|
|
|
|
if (attr.isNull() || windowGeometry.isNull()) {
|
2007-04-29 21:35:43 +04:00
|
|
|
ungrabXServer();
|
|
|
|
return false;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// From this place on, manage() must not return false
|
2007-04-29 21:35:43 +04:00
|
|
|
block_geometry_updates = 1;
|
2008-12-18 18:01:25 +03:00
|
|
|
pending_geometry_update = PendingGeometryForced; // Force update when finishing with geometry changes
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2014-04-25 15:42:52 +04:00
|
|
|
embedClient(w, attr->visual, attr->colormap, windowGeometry->depth);
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2014-04-25 15:42:52 +04:00
|
|
|
m_visual = attr->visual;
|
|
|
|
bit_depth = windowGeometry->depth;
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// SELI TODO: Order all these things in some sane manner
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
bool init_minimize = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
XWMHints* hints = XGetWMHints(display(), w);
|
|
|
|
if (hints && (hints->flags & StateHint) && hints->initial_state == IconicState)
|
2007-04-29 21:35:43 +04:00
|
|
|
init_minimize = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (hints)
|
|
|
|
XFree(hints);
|
|
|
|
if (isMapped)
|
2008-12-18 18:01:25 +03:00
|
|
|
init_minimize = false; // If it's already mapped, ignore hint
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2014-03-04 13:48:23 +04:00
|
|
|
const NET::Properties properties =
|
2007-04-29 21:35:43 +04:00
|
|
|
NET::WMDesktop |
|
|
|
|
NET::WMState |
|
|
|
|
NET::WMWindowType |
|
|
|
|
NET::WMStrut |
|
|
|
|
NET::WMName |
|
|
|
|
NET::WMIconGeometry |
|
|
|
|
NET::WMIcon |
|
|
|
|
NET::WMPid |
|
2014-02-03 12:37:08 +04:00
|
|
|
NET::WMIconName;
|
2014-03-04 13:48:23 +04:00
|
|
|
const NET::Properties2 properties2 =
|
2014-04-14 17:32:45 +04:00
|
|
|
NET::WM2BlockCompositing |
|
2014-04-11 10:06:26 +04:00
|
|
|
NET::WM2WindowClass |
|
2014-04-10 13:12:48 +04:00
|
|
|
NET::WM2WindowRole |
|
2007-04-29 21:35:43 +04:00
|
|
|
NET::WM2UserTime |
|
|
|
|
NET::WM2StartupId |
|
|
|
|
NET::WM2ExtendedStrut |
|
|
|
|
NET::WM2Opacity |
|
2008-11-17 11:03:39 +03:00
|
|
|
NET::WM2FullscreenMonitors |
|
2014-02-03 12:37:08 +04:00
|
|
|
NET::WM2FrameOverlap;
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2014-03-04 13:48:23 +04:00
|
|
|
info = new WinInfo(this, m_client, rootWindow(), properties, properties2);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2014-04-25 15:42:52 +04:00
|
|
|
m_colormap = attr->colormap;
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
getResourceClass();
|
|
|
|
getWmClientLeader();
|
|
|
|
getWmClientMachine();
|
2007-06-25 12:51:44 +04:00
|
|
|
getSyncCounter();
|
2008-12-18 18:01:25 +03:00
|
|
|
// First only read the caption text, so that setupWindowRules() can use it for matching,
|
2007-04-29 21:35:43 +04:00
|
|
|
// and only then really set the caption using setCaption(), which checks for duplicates etc.
|
|
|
|
// and also relies on rules already existing
|
|
|
|
cap_normal = readName();
|
2011-01-30 17:34:42 +03:00
|
|
|
setupWindowRules(false);
|
|
|
|
setCaption(cap_normal, true);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2012-12-21 18:11:31 +04:00
|
|
|
if (Xcb::Extensions::self()->isShapeAvailable())
|
2013-08-20 11:48:14 +04:00
|
|
|
xcb_shape_select_input(connection(), window(), true);
|
2011-01-30 17:34:42 +03:00
|
|
|
detectShape(window());
|
2007-04-29 21:35:43 +04:00
|
|
|
detectNoBorder();
|
|
|
|
fetchIconicName();
|
2008-12-18 18:01:25 +03:00
|
|
|
getWMHints(); // Needs to be done before readTransient() because of reading the group
|
2011-01-30 17:34:42 +03:00
|
|
|
modal = (info->state() & NET::Modal) != 0; // Needs to be valid before handling groups
|
2007-04-29 21:35:43 +04:00
|
|
|
readTransient();
|
|
|
|
getIcons();
|
|
|
|
getWindowProtocols();
|
2008-12-18 18:01:25 +03:00
|
|
|
getWmNormalHints(); // Get xSizeHint
|
2007-04-29 21:35:43 +04:00
|
|
|
getMotifHints();
|
2011-10-22 13:02:49 +04:00
|
|
|
getWmOpaqueRegion();
|
2014-01-24 15:34:16 +04:00
|
|
|
getSkipCloseAnimation();
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// TODO: Try to obey all state information from info->state()
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
original_skip_taskbar = skip_taskbar = (info->state() & NET::SkipTaskbar) != 0;
|
|
|
|
skip_pager = (info->state() & NET::SkipPager) != 0;
|
2011-12-01 16:15:11 +04:00
|
|
|
updateFirstInTabBox();
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-08-12 15:02:58 +04:00
|
|
|
setupCompositing();
|
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
KStartupInfoId asn_id;
|
|
|
|
KStartupInfoData asn_data;
|
2011-01-30 17:34:42 +03:00
|
|
|
bool asn_valid = workspace()->checkStartupNotification(window(), asn_id, asn_data);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-11-09 23:39:13 +04:00
|
|
|
// Make sure that the input window is created before we update the stacking order
|
|
|
|
updateInputWindow();
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
workspace()->updateClientLayer(this);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
SessionInfo* session = workspace()->takeSessionInfo(this);
|
|
|
|
if (session) {
|
2008-03-23 03:12:11 +03:00
|
|
|
init_minimize = session->minimized;
|
|
|
|
noborder = session->noBorder;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
setShortcut(rules()->checkShortcut(session ? session->shortcut : QString(), true));
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
init_minimize = rules()->checkMinimize(init_minimize, !isMapped);
|
|
|
|
noborder = rules()->checkNoBorder(noborder, !isMapped);
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2010-09-24 16:03:22 +04:00
|
|
|
checkActivities();
|
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// Initial desktop placement
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session) {
|
2007-04-29 21:35:43 +04:00
|
|
|
desk = session->desktop;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session->onAllDesktops)
|
2007-04-29 21:35:43 +04:00
|
|
|
desk = NET::OnAllDesktops;
|
2010-10-02 21:04:24 +04:00
|
|
|
setOnActivities(session->activities);
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
2008-12-18 18:01:25 +03:00
|
|
|
// If this window is transient, ensure that it is opened on the
|
2007-04-29 21:35:43 +04:00
|
|
|
// same window as its parent. this is necessary when an application
|
|
|
|
// starts up on a different desktop than is currently displayed
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isTransient()) {
|
2007-04-29 21:35:43 +04:00
|
|
|
ClientList mainclients = mainClients();
|
|
|
|
bool on_current = false;
|
2010-08-19 16:07:44 +04:00
|
|
|
bool on_all = false;
|
2007-04-29 21:35:43 +04:00
|
|
|
Client* maincl = NULL;
|
2008-12-18 18:01:25 +03:00
|
|
|
// This is slightly duplicated from Placement::placeOnMainWindow()
|
2011-01-30 17:34:42 +03:00
|
|
|
for (ClientList::ConstIterator it = mainclients.constBegin();
|
|
|
|
it != mainclients.constEnd();
|
|
|
|
++it) {
|
|
|
|
if (mainclients.count() > 1 && (*it)->isSpecialWindow())
|
2008-12-18 18:01:25 +03:00
|
|
|
continue; // Don't consider toolbars etc when placing
|
2007-04-29 21:35:43 +04:00
|
|
|
maincl = *it;
|
2011-01-30 17:34:42 +03:00
|
|
|
if ((*it)->isOnCurrentDesktop())
|
2007-04-29 21:35:43 +04:00
|
|
|
on_current = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if ((*it)->isOnAllDesktops())
|
2010-08-19 16:07:44 +04:00
|
|
|
on_all = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (on_all)
|
2010-08-19 16:07:44 +04:00
|
|
|
desk = NET::OnAllDesktops;
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (on_current)
|
2012-11-16 11:23:47 +04:00
|
|
|
desk = VirtualDesktopManager::self()->current();
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (maincl != NULL)
|
2007-04-29 21:35:43 +04:00
|
|
|
desk = maincl->desktop();
|
2010-09-26 20:44:07 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (maincl)
|
2010-09-26 20:44:07 +04:00
|
|
|
setOnActivities(maincl->activities());
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (info->desktop())
|
2008-12-18 18:01:25 +03:00
|
|
|
desk = info->desktop(); // Window had the initial desktop property, force it
|
2011-01-30 17:34:42 +03:00
|
|
|
if (desktop() == 0 && asn_valid && asn_data.desktop() != 0)
|
2007-04-29 21:35:43 +04:00
|
|
|
desk = asn_data.desktop();
|
2013-04-04 18:14:12 +04:00
|
|
|
#ifdef KWIN_BUILD_ACTIVITIES
|
2010-12-16 23:14:22 +03:00
|
|
|
if (!isMapped && !noborder && isNormalWindow() && !activitiesDefined) {
|
2010-11-12 02:37:50 +03:00
|
|
|
//a new, regular window, when we're not recovering from a crash,
|
|
|
|
//and it hasn't got an activity. let's try giving it the current one.
|
|
|
|
//TODO: decide whether to keep this before the 4.6 release
|
2010-11-14 13:35:16 +03:00
|
|
|
//TODO: if we are keeping it (at least as an option), replace noborder checking
|
|
|
|
//with a public API for setting windows to be on all activities.
|
|
|
|
//something like KWindowSystem::setOnAllActivities or
|
|
|
|
//KActivityConsumer::setOnAllActivities
|
2013-04-04 18:14:12 +04:00
|
|
|
setOnActivity(Activities::self()->current(), true);
|
2010-11-12 02:37:50 +03:00
|
|
|
}
|
2013-04-04 18:14:12 +04:00
|
|
|
#endif
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2012-05-17 18:32:06 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (desk == 0) // Assume window wants to be visible on the current desktop
|
2013-01-08 14:04:07 +04:00
|
|
|
desk = isDesktop() ? static_cast<int>(NET::OnAllDesktops) : VirtualDesktopManager::self()->current();
|
2011-01-30 17:34:42 +03:00
|
|
|
desk = rules()->checkDesktop(desk, !isMapped);
|
|
|
|
if (desk != NET::OnAllDesktops) // Do range check
|
2012-11-16 11:23:47 +04:00
|
|
|
desk = qBound(1, desk, static_cast<int>(VirtualDesktopManager::self()->count()));
|
2011-01-30 17:34:42 +03:00
|
|
|
info->setDesktop(desk);
|
|
|
|
workspace()->updateOnAllDesktopsOfTransients(this); // SELI TODO
|
2008-12-18 18:01:25 +03:00
|
|
|
//onAllDesktopsChange(); // Decoration doesn't exist here yet
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2012-05-17 18:32:06 +04:00
|
|
|
QString activitiesList;
|
|
|
|
activitiesList = rules()->checkActivity(activitiesList, !isMapped);
|
|
|
|
if (!activitiesList.isEmpty())
|
2013-07-23 09:02:52 +04:00
|
|
|
setOnActivities(activitiesList.split(QStringLiteral(",")));
|
2012-05-17 18:32:06 +04:00
|
|
|
|
2014-04-25 15:42:52 +04:00
|
|
|
QRect geom(windowGeometry.rect());
|
2007-04-29 21:35:43 +04:00
|
|
|
bool placementDone = false;
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session)
|
2007-04-29 21:35:43 +04:00
|
|
|
geom = session->geometry;
|
|
|
|
|
|
|
|
QRect area;
|
|
|
|
bool partial_keep_in_area = isMapped || session;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isMapped || session)
|
|
|
|
area = workspace()->clientArea(FullArea, geom.center(), desktop());
|
2012-01-22 14:04:55 +04:00
|
|
|
else {
|
2013-04-03 14:19:27 +04:00
|
|
|
int screen = asn_data.xinerama() == -1 ? screens()->current() : asn_data.xinerama();
|
2012-08-24 20:48:50 +04:00
|
|
|
screen = rules()->checkScreen(screen, !isMapped);
|
2013-04-03 14:19:27 +04:00
|
|
|
area = workspace()->clientArea(PlacementArea, screens()->geometry(screen).center(), desktop());
|
2012-01-22 14:04:55 +04:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (int type = checkFullScreenHack(geom)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
fullscreen_mode = FullScreenHack;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (rules()->checkStrictGeometry(false)) {
|
2008-12-18 18:01:25 +03:00
|
|
|
geom = type == 2 // 1 = It's xinerama-aware fullscreen hack, 2 = It's full area
|
2011-01-30 17:34:42 +03:00
|
|
|
? workspace()->clientArea(FullArea, geom.center(), desktop())
|
|
|
|
: workspace()->clientArea(ScreenArea, geom.center(), desktop());
|
|
|
|
} else
|
|
|
|
geom = workspace()->clientArea(FullScreenArea, geom.center(), desktop());
|
2007-04-29 21:35:43 +04:00
|
|
|
placementDone = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isDesktop())
|
2008-12-18 18:01:25 +03:00
|
|
|
// KWin doesn't manage desktop windows
|
2008-05-02 20:39:49 +04:00
|
|
|
placementDone = true;
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
bool usePosition = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isMapped || session || placementDone)
|
2008-12-18 18:01:25 +03:00
|
|
|
placementDone = true; // Use geometry
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (isTransient() && !isUtility() && !isDialog() && !isSplash())
|
2007-04-29 21:35:43 +04:00
|
|
|
usePosition = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (isTransient() && !hasNETSupport())
|
2007-04-29 21:35:43 +04:00
|
|
|
usePosition = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (isDialog() && hasNETSupport()) {
|
|
|
|
// If the dialog is actually non-NETWM transient window, don't try to apply placement to it,
|
|
|
|
// it breaks with too many things (xmms, display)
|
|
|
|
if (mainClients().count() >= 1) {
|
2007-04-29 21:35:43 +04:00
|
|
|
#if 1
|
2007-07-19 20:38:46 +04:00
|
|
|
// #78082 - Ok, it seems there are after all some cases when an application has a good
|
2007-04-29 21:35:43 +04:00
|
|
|
// reason to specify a position for its dialog. Too bad other WMs have never bothered
|
|
|
|
// with placement for dialogs, so apps always specify positions for their dialogs,
|
|
|
|
// including such silly positions like always centered on the screen or under mouse.
|
2007-07-19 20:38:46 +04:00
|
|
|
// Using ignoring requested position in window-specific settings helps, and now
|
|
|
|
// there's also _NET_WM_FULL_PLACEMENT.
|
2007-04-29 21:35:43 +04:00
|
|
|
usePosition = true;
|
|
|
|
#else
|
2008-12-18 18:01:25 +03:00
|
|
|
; // Force using placement policy
|
2007-04-29 21:35:43 +04:00
|
|
|
#endif
|
2011-01-30 17:34:42 +03:00
|
|
|
} else
|
2007-04-29 21:35:43 +04:00
|
|
|
usePosition = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
} else if (isSplash())
|
2008-12-18 18:01:25 +03:00
|
|
|
; // Force using placement policy
|
2007-04-29 21:35:43 +04:00
|
|
|
else
|
|
|
|
usePosition = true;
|
2013-03-24 22:13:00 +04:00
|
|
|
if (!rules()->checkIgnoreGeometry(!usePosition, true)) {
|
2012-03-14 11:03:42 +04:00
|
|
|
if (((xSizeHint.flags & PPosition)) ||
|
2011-01-30 17:34:42 +03:00
|
|
|
(xSizeHint.flags & USPosition)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
placementDone = true;
|
2008-12-18 18:01:25 +03:00
|
|
|
// Disobey xinerama placement option for now (#70943)
|
2011-01-30 17:34:42 +03:00
|
|
|
area = workspace()->clientArea(PlacementArea, geom.center(), desktop());
|
2007-04-29 21:35:43 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
//if ( true ) // Size is always obeyed for now, only with constraints applied
|
|
|
|
// if (( xSizeHint.flags & USSize ) || ( xSizeHint.flags & PSize ))
|
2008-12-18 18:01:25 +03:00
|
|
|
// {
|
|
|
|
// // Keep in mind that we now actually have a size :-)
|
|
|
|
// }
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (xSizeHint.flags & PMaxSize)
|
|
|
|
geom.setSize(geom.size().boundedTo(
|
|
|
|
rules()->checkMaxSize(QSize(xSizeHint.max_width, xSizeHint.max_height))));
|
|
|
|
if (xSizeHint.flags & PMinSize)
|
|
|
|
geom.setSize(geom.size().expandedTo(
|
|
|
|
rules()->checkMinSize(QSize(xSizeHint.min_width, xSizeHint.min_height))));
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isMovable() && (geom.x() > area.right() || geom.y() > area.bottom()))
|
2008-12-18 18:01:25 +03:00
|
|
|
placementDone = false; // Weird, do not trust.
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (placementDone)
|
|
|
|
move(geom.x(), geom.y()); // Before gravitating
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2009-11-15 06:24:04 +03:00
|
|
|
// Create client group if the window will have a decoration
|
2009-11-16 16:31:02 +03:00
|
|
|
bool dontKeepInArea = false;
|
2012-01-12 10:42:55 +04:00
|
|
|
setTabGroup(NULL);
|
2013-12-02 01:12:25 +04:00
|
|
|
if (!noBorder() && DecorationPlugin::self()->supportsTabbing()) {
|
2012-02-20 13:25:13 +04:00
|
|
|
const bool autogrouping = rules()->checkAutogrouping(options->isAutogroupSimilarWindows());
|
|
|
|
const bool autogroupInFg = rules()->checkAutogroupInForeground(options->isAutogroupInForeground());
|
2009-11-15 06:24:04 +03:00
|
|
|
// Automatically add to previous groups on session restore
|
2012-06-08 22:39:27 +04:00
|
|
|
if (session && session->tabGroupClient && !workspace()->hasClient(session->tabGroupClient))
|
|
|
|
session->tabGroupClient = NULL;
|
2012-01-12 10:42:55 +04:00
|
|
|
if (session && session->tabGroupClient && session->tabGroupClient != this) {
|
|
|
|
tabBehind(session->tabGroupClient, autogroupInFg);
|
|
|
|
} else if (isMapped && autogrouping) {
|
2009-11-15 06:24:04 +03:00
|
|
|
// If the window is already mapped (Restarted KWin) add any windows that already have the
|
|
|
|
// same geometry to the same client group. (May incorrectly handle maximized windows)
|
2012-01-12 10:42:55 +04:00
|
|
|
foreach (Client *other, workspace()->clientList()) {
|
|
|
|
if (other->maximizeMode() != MaximizeFull &&
|
|
|
|
geom == QRect(other->pos(), other->clientSize()) &&
|
|
|
|
desk == other->desktop() && activities() == other->activities()) {
|
|
|
|
|
|
|
|
tabBehind(other, autogroupInFg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2012-01-12 10:42:55 +04:00
|
|
|
}
|
2012-06-18 23:19:11 +04:00
|
|
|
if (!(tab_group || isMapped || session)) {
|
2011-01-30 17:34:42 +03:00
|
|
|
// Attempt to automatically group similar windows
|
2012-01-12 10:42:55 +04:00
|
|
|
Client* similar = findAutogroupCandidate();
|
|
|
|
if (similar && !similar->noBorder()) {
|
|
|
|
if (autogroupInFg) {
|
|
|
|
similar->setDesktop(desk); // can happen when grouping by id. ...
|
|
|
|
similar->setMinimized(false); // ... or anyway - still group, but "here" and visible
|
|
|
|
}
|
|
|
|
if (!similar->isMinimized()) { // do not attempt to tab in background of a hidden group
|
|
|
|
geom = QRect(similar->pos() + similar->clientPos(), similar->clientSize());
|
|
|
|
updateDecoration(false);
|
|
|
|
if (tabBehind(similar, autogroupInFg)) {
|
|
|
|
// Don't move entire group
|
|
|
|
geom = QRect(similar->pos() + similar->clientPos(), similar->clientSize());
|
|
|
|
placementDone = true;
|
|
|
|
dontKeepInArea = true;
|
|
|
|
}
|
|
|
|
}
|
2009-11-16 13:09:03 +03:00
|
|
|
}
|
2009-11-15 06:24:04 +03:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-11-15 06:24:04 +03:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
updateDecoration(false); // Also gravitates
|
2008-12-18 18:01:25 +03:00
|
|
|
// TODO: Is CentralGravity right here, when resizing is done after gravitating?
|
2011-01-30 17:34:42 +03:00
|
|
|
plainResize(rules()->checkSize(sizeForClientSize(geom.size()), !isMapped));
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
QPoint forced_pos = rules()->checkPosition(invalidPoint, !isMapped);
|
|
|
|
if (forced_pos != invalidPoint) {
|
|
|
|
move(forced_pos);
|
2007-04-29 21:35:43 +04:00
|
|
|
placementDone = true;
|
2008-12-18 18:01:25 +03:00
|
|
|
// Don't keep inside workarea if the window has specially configured position
|
2007-04-29 21:35:43 +04:00
|
|
|
partial_keep_in_area = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
area = workspace()->clientArea(FullArea, geom.center(), desktop());
|
|
|
|
}
|
|
|
|
if (!placementDone) {
|
|
|
|
// Placement needs to be after setting size
|
2012-11-22 16:33:23 +04:00
|
|
|
Placement::self()->place(this, area);
|
2013-08-15 13:53:02 +04:00
|
|
|
dontKeepInArea = true;
|
2007-04-29 21:35:43 +04:00
|
|
|
placementDone = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-11-13 00:39:06 +04:00
|
|
|
// bugs #285967, #286146, #183694
|
|
|
|
// geometry() now includes the requested size and the decoration and is at the correct screen/position (hopefully)
|
|
|
|
// Maximization for oversized windows must happen NOW.
|
|
|
|
// If we effectively pass keepInArea(), the window will resizeWithChecks() - i.e. constrained
|
|
|
|
// to the combo of all screen MINUS all struts on the edges
|
|
|
|
// If only one screen struts, this will affect screens as a side-effect, the window is artificailly shrinked
|
|
|
|
// below the screen size and as result no more maximized what breaks KMainWindow's stupid width+1, height+1 hack
|
|
|
|
// TODO: get KMainWindow a correct state storage what will allow to store the restore size as well.
|
|
|
|
|
|
|
|
if (!session) { // has a better handling of this
|
|
|
|
geom_restore = geometry(); // Remember restore geometry
|
|
|
|
if (isMaximizable() && (width() >= area.width() || height() >= area.height())) {
|
|
|
|
// Window is too large for the screen, maximize in the
|
|
|
|
// directions necessary
|
2013-02-01 22:44:06 +04:00
|
|
|
const QSize ss = workspace()->clientArea(ScreenArea, area.center(), desktop()).size();
|
|
|
|
const QSize fs = workspace()->clientArea(FullArea, geom.center(), desktop()).size();
|
|
|
|
const QSize cs = clientSize();
|
|
|
|
int pseudo_max = Client::MaximizeRestore;
|
|
|
|
if (width() >= area.width())
|
|
|
|
pseudo_max |= Client::MaximizeHorizontal;
|
|
|
|
if (height() >= area.height())
|
|
|
|
pseudo_max |= Client::MaximizeVertical;
|
|
|
|
|
|
|
|
// heuristics:
|
|
|
|
// if decorated client is smaller than the entire screen, the user might want to move it around (multiscreen)
|
|
|
|
// in this case, if the decorated client is bigger than the screen (+1), we don't take this as an
|
|
|
|
// attempt for maximization, but just constrain the size (the window simply wants to be bigger)
|
|
|
|
// NOTICE
|
|
|
|
// i intended a second check on cs < area.size() ("the managed client ("minus border") is smaller
|
|
|
|
// than the workspace") but gtk / gimp seems to store it's size including the decoration,
|
|
|
|
// thus a former maximized window wil become non-maximized
|
|
|
|
if (width() < fs.width() && (cs.width() > ss.width()+1))
|
|
|
|
pseudo_max &= ~Client::MaximizeHorizontal;
|
|
|
|
if (height() < fs.height() && (cs.height() > ss.height()+1))
|
|
|
|
pseudo_max &= ~Client::MaximizeVertical;
|
|
|
|
|
|
|
|
if (pseudo_max != Client::MaximizeRestore) {
|
|
|
|
maximize((MaximizeMode)pseudo_max);
|
|
|
|
// from now on, care about maxmode, since the maximization call will override mode for fix aspects
|
2013-08-15 13:53:02 +04:00
|
|
|
dontKeepInArea |= (max_mode == Client::MaximizeFull);
|
2013-02-01 22:44:06 +04:00
|
|
|
geom_restore = QRect(); // Use placement when unmaximizing ...
|
|
|
|
if (!(max_mode & Client::MaximizeVertical)) {
|
|
|
|
geom_restore.setY(y()); // ...but only for horizontal direction
|
|
|
|
geom_restore.setHeight(height());
|
|
|
|
}
|
|
|
|
if (!(max_mode & Client::MaximizeHorizontal)) {
|
|
|
|
geom_restore.setX(x()); // ...but only for vertical direction
|
|
|
|
geom_restore.setWidth(width());
|
|
|
|
}
|
2011-11-13 00:39:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if ((!isSpecialWindow() || isToolbar()) && isMovable() && !dontKeepInArea)
|
|
|
|
keepInArea(area, partial_keep_in_area);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2007-12-17 19:30:36 +03:00
|
|
|
updateShape();
|
2008-12-18 18:01:25 +03:00
|
|
|
|
|
|
|
// CT: Extra check for stupid jdk 1.3.1. But should make sense in general
|
2007-04-29 21:35:43 +04:00
|
|
|
// if client has initial state set to Iconic and is transient with a parent
|
|
|
|
// window that is not Iconic, set init_state to Normal
|
2011-01-30 17:34:42 +03:00
|
|
|
if (init_minimize && isTransient()) {
|
2007-04-29 21:35:43 +04:00
|
|
|
ClientList mainclients = mainClients();
|
2011-01-30 17:34:42 +03:00
|
|
|
for (ClientList::ConstIterator it = mainclients.constBegin();
|
|
|
|
it != mainclients.constEnd();
|
|
|
|
++it)
|
|
|
|
if ((*it)->isShown(true))
|
2008-12-18 18:01:25 +03:00
|
|
|
init_minimize = false; // SELI TODO: Even e.g. for NET::Utility?
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2008-12-18 18:01:25 +03:00
|
|
|
// If a dialog is shown for minimized window, minimize it too
|
2014-02-22 18:55:56 +04:00
|
|
|
if (!init_minimize && isTransient() && mainClients().count() > 0 && !workspace()->sessionSaving()) {
|
2008-03-18 17:56:57 +03:00
|
|
|
bool visible_parent = false;
|
2008-12-18 18:01:25 +03:00
|
|
|
// Use allMainClients(), to include also main clients of group transients
|
2008-04-18 19:50:12 +04:00
|
|
|
// that have been optimized out in Client::checkGroupTransients()
|
|
|
|
ClientList mainclients = allMainClients();
|
2011-01-30 17:34:42 +03:00
|
|
|
for (ClientList::ConstIterator it = mainclients.constBegin();
|
|
|
|
it != mainclients.constEnd();
|
|
|
|
++it)
|
|
|
|
if ((*it)->isShown(true))
|
2008-03-18 17:56:57 +03:00
|
|
|
visible_parent = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!visible_parent) {
|
2008-03-18 17:56:57 +03:00
|
|
|
init_minimize = true;
|
|
|
|
demandAttention();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (init_minimize)
|
|
|
|
minimize(true); // No animation
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// Other settings from the previous session
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session) {
|
2008-12-18 18:01:25 +03:00
|
|
|
// Session restored windows are not considered to be new windows WRT rules,
|
|
|
|
// I.e. obey only forcing rules
|
2011-01-30 17:34:42 +03:00
|
|
|
setKeepAbove(session->keepAbove);
|
|
|
|
setKeepBelow(session->keepBelow);
|
|
|
|
setSkipTaskbar(session->skipTaskbar, true);
|
|
|
|
setSkipPager(session->skipPager);
|
|
|
|
setSkipSwitcher(session->skipSwitcher);
|
|
|
|
setShade(session->shaded ? ShadeNormal : ShadeNone);
|
|
|
|
setOpacity(session->opacity);
|
2012-04-11 20:18:50 +04:00
|
|
|
geom_restore = session->restore;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session->maximized != MaximizeRestore) {
|
|
|
|
maximize(MaximizeMode(session->maximized));
|
|
|
|
}
|
|
|
|
if (session->fullscreen == FullScreenHack)
|
2008-12-18 18:01:25 +03:00
|
|
|
; // Nothing, this should be already set again above
|
2011-01-30 17:34:42 +03:00
|
|
|
else if (session->fullscreen != FullScreenNone) {
|
|
|
|
setFullScreen(true, false);
|
2007-04-29 21:35:43 +04:00
|
|
|
geom_fs_restore = session->fsrestore;
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
2008-12-18 18:01:25 +03:00
|
|
|
// Window may want to be maximized
|
2007-04-29 21:35:43 +04:00
|
|
|
// done after checking that the window isn't larger than the workarea, so that
|
|
|
|
// the restore geometry from the checks above takes precedence, and window
|
|
|
|
// isn't restored larger than the workarea
|
2008-12-18 18:01:25 +03:00
|
|
|
MaximizeMode maxmode = static_cast<MaximizeMode>(
|
2011-01-30 17:34:42 +03:00
|
|
|
((info->state() & NET::MaxVert) ? MaximizeVertical : 0) |
|
|
|
|
((info->state() & NET::MaxHoriz) ? MaximizeHorizontal : 0));
|
|
|
|
MaximizeMode forced_maxmode = rules()->checkMaximize(maxmode, !isMapped);
|
2008-12-18 18:01:25 +03:00
|
|
|
|
|
|
|
// Either hints were set to maximize, or is forced to maximize,
|
2007-04-29 21:35:43 +04:00
|
|
|
// or is forced to non-maximize and hints were set to maximize
|
2011-01-30 17:34:42 +03:00
|
|
|
if (forced_maxmode != MaximizeRestore || maxmode != MaximizeRestore)
|
|
|
|
maximize(forced_maxmode);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// Read other initial states
|
2011-01-30 17:34:42 +03:00
|
|
|
setShade(rules()->checkShade(info->state() & NET::Shaded ? ShadeNormal : ShadeNone, !isMapped));
|
|
|
|
setKeepAbove(rules()->checkKeepAbove(info->state() & NET::KeepAbove, !isMapped));
|
|
|
|
setKeepBelow(rules()->checkKeepBelow(info->state() & NET::KeepBelow, !isMapped));
|
|
|
|
setSkipTaskbar(rules()->checkSkipTaskbar(info->state() & NET::SkipTaskbar, !isMapped), true);
|
|
|
|
setSkipPager(rules()->checkSkipPager(info->state() & NET::SkipPager, !isMapped));
|
|
|
|
setSkipSwitcher(rules()->checkSkipSwitcher(false, !isMapped));
|
|
|
|
if (info->state() & NET::DemandsAttention)
|
2007-04-29 21:35:43 +04:00
|
|
|
demandAttention();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (info->state() & NET::Modal)
|
|
|
|
setModal(true);
|
|
|
|
if (fullscreen_mode != FullScreenHack && isFullScreenable())
|
|
|
|
setFullScreen(rules()->checkFullScreen(info->state() & NET::FullScreen, !isMapped), false);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
updateAllowedActions(true);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// Set initial user time directly
|
2013-05-03 13:29:50 +04:00
|
|
|
m_userTime = readUserTimeMapTimestamp(asn_valid ? &asn_id : NULL, asn_valid ? &asn_data : NULL, session);
|
|
|
|
group()->updateUserTime(m_userTime); // And do what Client::updateUserTime() does
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// This should avoid flicker, because real restacking is done
|
2007-04-29 21:35:43 +04:00
|
|
|
// only after manage() finishes because of blocking, but the window is shown sooner
|
2013-09-10 11:11:19 +04:00
|
|
|
m_frame.lower();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session && session->stackingOrder != -1) {
|
2007-04-29 21:35:43 +04:00
|
|
|
sm_stacking_order = session->stackingOrder;
|
2011-01-30 17:34:42 +03:00
|
|
|
workspace()->restoreSessionStackingOrder(this);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (compositing())
|
2008-12-18 18:01:25 +03:00
|
|
|
// Sending ConfigureNotify is done when setting mapping state below,
|
|
|
|
// Getting the first sync response means window is ready for compositing
|
|
|
|
sendSyncRequest();
|
2011-08-13 18:39:58 +04:00
|
|
|
else
|
|
|
|
ready_for_painting = true; // set to true in case compositing is turned on later. bug #160393
|
2007-06-25 12:51:44 +04:00
|
|
|
|
2013-03-01 11:49:04 +04:00
|
|
|
if (isShown(true)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
bool allow;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session)
|
2008-12-18 18:01:25 +03:00
|
|
|
allow = session->active &&
|
2011-01-30 17:34:42 +03:00
|
|
|
(!workspace()->wasUserInteraction() || workspace()->activeClient() == NULL ||
|
|
|
|
workspace()->activeClient()->isDesktop());
|
2007-04-29 21:35:43 +04:00
|
|
|
else
|
2011-01-30 17:34:42 +03:00
|
|
|
allow = workspace()->allowClientActivation(this, userTime(), false);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2010-12-16 23:14:22 +03:00
|
|
|
if (!(isMapped || session)) {
|
|
|
|
if (workspace()->sessionSaving()) {
|
|
|
|
/*
|
|
|
|
* If we get a new window during session saving, we assume it's some 'save file?' dialog
|
|
|
|
* which the user really needs to see (to know why logout's stalled).
|
|
|
|
*
|
|
|
|
* Given the current session management protocol, I can't see a nicer way of doing this.
|
|
|
|
* Someday I'd like to see a protocol that tells the windowmanager who's doing SessionInteract.
|
|
|
|
*/
|
|
|
|
needsSessionInteract = true;
|
|
|
|
//show the parent too
|
|
|
|
ClientList mainclients = mainClients();
|
2011-01-30 17:34:42 +03:00
|
|
|
for (ClientList::ConstIterator it = mainclients.constBegin();
|
|
|
|
it != mainclients.constEnd(); ++it) {
|
2010-12-16 23:14:22 +03:00
|
|
|
(*it)->setSessionInteract(true);
|
2014-02-22 18:55:56 +04:00
|
|
|
(*it)->unminimize();
|
2010-12-16 23:14:22 +03:00
|
|
|
}
|
|
|
|
} else if (allow) {
|
|
|
|
// also force if activation is allowed
|
2013-09-08 01:35:06 +04:00
|
|
|
if (!isOnCurrentDesktop() && options->focusPolicyIsReasonable()) {
|
2012-11-16 11:23:47 +04:00
|
|
|
VirtualDesktopManager::self()->setCurrent(desktop());
|
2010-12-16 23:14:22 +03:00
|
|
|
}
|
|
|
|
/*if (!isOnCurrentActivity()) {
|
|
|
|
workspace()->setCurrentActivity( activities().first() );
|
|
|
|
} FIXME no such method*/
|
|
|
|
}
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2012-08-26 18:16:38 +04:00
|
|
|
resetShowingDesktop(options->isShowDesktopIsMinimizeAll());
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isOnCurrentDesktop() && !isMapped && !allow && (!session || session->stackingOrder < 0))
|
|
|
|
workspace()->restackClientUnderActive(this);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
updateVisibility();
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!isMapped) {
|
|
|
|
if (allow && isOnCurrentDesktop()) {
|
|
|
|
if (!isSpecialWindow())
|
|
|
|
if (options->focusPolicyIsReasonable() && wantsTabFocus())
|
|
|
|
workspace()->requestFocus(this);
|
|
|
|
} else if (!session && !isSpecialWindow())
|
2008-12-18 18:01:25 +03:00
|
|
|
demandAttention();
|
2007-04-29 21:35:43 +04:00
|
|
|
}
|
2013-03-01 11:49:04 +04:00
|
|
|
} else
|
2007-04-29 21:35:43 +04:00
|
|
|
updateVisibility();
|
2011-01-30 17:34:42 +03:00
|
|
|
assert(mapping_state != Withdrawn);
|
2012-06-20 01:12:37 +04:00
|
|
|
m_managed = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
blockGeometryUpdates(false);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2013-05-03 13:29:50 +04:00
|
|
|
if (m_userTime == XCB_TIME_CURRENT_TIME || m_userTime == -1U) {
|
2011-01-30 17:34:42 +03:00
|
|
|
// No known user time, set something old
|
2013-05-03 13:29:50 +04:00
|
|
|
m_userTime = xTime() - 1000000;
|
|
|
|
if (m_userTime == XCB_TIME_CURRENT_TIME || m_userTime == -1U) // Let's be paranoid
|
|
|
|
m_userTime = xTime() - 1000000 + 10;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
//sendSyntheticConfigureNotify(); // Done when setting mapping state
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
delete session;
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
ungrabXServer();
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
client_rules.discardTemporary();
|
2008-12-18 18:01:25 +03:00
|
|
|
applyWindowRules(); // Just in case
|
2013-04-26 16:40:35 +04:00
|
|
|
RuleBook::self()->discardUsed(this, false); // Remove ApplyNow rules
|
2012-02-05 21:50:23 +04:00
|
|
|
updateWindowRules(Rules::All); // Was blocked while !isManaged()
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2014-04-14 17:32:45 +04:00
|
|
|
setBlockingCompositing(info->isBlockingCompositing());
|
2013-10-14 09:17:07 +04:00
|
|
|
updateColorScheme();
|
2014-02-20 15:39:23 +04:00
|
|
|
updateShowOnScreenEdge();
|
2011-03-20 17:42:05 +03:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// TODO: there's a small problem here - isManaged() depends on the mapping state,
|
|
|
|
// but this client is not yet in Workspace's client list at this point, will
|
|
|
|
// be only done in addClient()
|
2012-01-21 13:51:22 +04:00
|
|
|
emit clientManaging(this);
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2008-12-18 18:01:25 +03:00
|
|
|
// Called only from manage()
|
2014-04-25 15:42:52 +04:00
|
|
|
void Client::embedClient(xcb_window_t w, xcb_visualid_t visualid, xcb_colormap_t colormap, uint8_t depth)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-05-02 20:43:49 +04:00
|
|
|
assert(m_client == XCB_WINDOW_NONE);
|
2013-05-03 12:58:46 +04:00
|
|
|
assert(frameId() == XCB_WINDOW_NONE);
|
2013-05-02 20:26:05 +04:00
|
|
|
assert(m_wrapper == XCB_WINDOW_NONE);
|
2013-09-10 09:27:39 +04:00
|
|
|
m_client.reset(w, false);
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2012-03-28 18:50:44 +04:00
|
|
|
const uint32_t zero_value = 0;
|
|
|
|
|
|
|
|
xcb_connection_t *conn = connection();
|
|
|
|
|
|
|
|
// We don't want the window to be destroyed when we quit
|
2013-05-02 20:43:49 +04:00
|
|
|
xcb_change_save_set(conn, XCB_SET_MODE_INSERT, m_client);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
2013-09-10 09:38:21 +04:00
|
|
|
m_client.selectInput(zero_value);
|
|
|
|
m_client.unmap();
|
2013-09-10 11:51:31 +04:00
|
|
|
m_client.setBorderWidth(zero_value);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
|
|
|
// Note: These values must match the order in the xcb_cw_t enum
|
|
|
|
const uint32_t cw_values[] = {
|
|
|
|
0, // back_pixmap
|
|
|
|
0, // border_pixel
|
2014-04-25 15:42:52 +04:00
|
|
|
colormap, // colormap
|
2013-02-19 14:25:46 +04:00
|
|
|
Cursor::x11Cursor(Qt::ArrowCursor)
|
2012-03-28 18:50:44 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
const uint32_t cw_mask = XCB_CW_BACK_PIXMAP | XCB_CW_BORDER_PIXEL |
|
|
|
|
XCB_CW_COLORMAP | XCB_CW_CURSOR;
|
|
|
|
|
|
|
|
const uint32_t common_event_mask = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
|
|
|
|
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
|
|
|
|
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
|
|
|
|
XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_POINTER_MOTION |
|
|
|
|
XCB_EVENT_MASK_KEYMAP_STATE |
|
|
|
|
XCB_EVENT_MASK_FOCUS_CHANGE |
|
|
|
|
XCB_EVENT_MASK_EXPOSURE |
|
|
|
|
XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
|
|
|
|
|
|
|
|
const uint32_t frame_event_mask = common_event_mask | XCB_EVENT_MASK_PROPERTY_CHANGE;
|
|
|
|
const uint32_t wrapper_event_mask = common_event_mask | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY;
|
|
|
|
|
|
|
|
const uint32_t client_event_mask = XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_PROPERTY_CHANGE |
|
|
|
|
XCB_EVENT_MASK_COLOR_MAP_CHANGE |
|
|
|
|
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
|
|
|
|
XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
|
|
|
|
|
|
|
|
// Create the frame window
|
|
|
|
xcb_window_t frame = xcb_generate_id(conn);
|
2014-04-25 15:42:52 +04:00
|
|
|
xcb_create_window(conn, depth, frame, rootWindow(), 0, 0, 1, 1, 0,
|
2012-03-28 18:50:44 +04:00
|
|
|
XCB_WINDOW_CLASS_INPUT_OUTPUT, visualid, cw_mask, cw_values);
|
2013-09-10 10:13:33 +04:00
|
|
|
m_frame.reset(frame);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
2013-09-10 10:13:33 +04:00
|
|
|
setWindowHandles(m_client);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
|
|
|
// Create the wrapper window
|
2013-05-02 20:26:05 +04:00
|
|
|
xcb_window_t wrapperId = xcb_generate_id(conn);
|
2014-04-25 15:42:52 +04:00
|
|
|
xcb_create_window(conn, depth, wrapperId, frame, 0, 0, 1, 1, 0,
|
2012-03-28 18:50:44 +04:00
|
|
|
XCB_WINDOW_CLASS_INPUT_OUTPUT, visualid, cw_mask, cw_values);
|
2013-05-02 20:26:05 +04:00
|
|
|
m_wrapper.reset(wrapperId);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
2013-09-10 11:20:12 +04:00
|
|
|
m_client.reparent(m_wrapper);
|
2012-03-28 18:50:44 +04:00
|
|
|
|
|
|
|
// We could specify the event masks when we create the windows, but the original
|
|
|
|
// Xlib code didn't. Let's preserve that behavior here for now so we don't end up
|
|
|
|
// receiving any unexpected events from the wrapper creation or the reparenting.
|
2013-09-10 11:22:36 +04:00
|
|
|
m_frame.selectInput(frame_event_mask);
|
|
|
|
m_wrapper.selectInput(wrapper_event_mask);
|
2013-09-10 09:38:21 +04:00
|
|
|
m_client.selectInput(client_event_mask);
|
2008-12-18 18:01:25 +03:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
updateMouseGrab();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2012-01-12 10:42:55 +04:00
|
|
|
// To accept "mainwindow#1" to "mainwindow#2"
|
|
|
|
static QByteArray truncatedWindowRole(QByteArray a)
|
|
|
|
{
|
|
|
|
int i = a.indexOf('#');
|
|
|
|
if (i == -1)
|
|
|
|
return a;
|
|
|
|
QByteArray b(a);
|
|
|
|
b.truncate(i);
|
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
|
|
|
Client* Client::findAutogroupCandidate() const
|
|
|
|
{
|
|
|
|
// Attempt to find a similar window to the input. If we find multiple possibilities that are in
|
|
|
|
// different groups then ignore all of them. This function is for automatic window grouping.
|
|
|
|
Client *found = NULL;
|
|
|
|
|
|
|
|
// See if the window has a group ID to match with
|
|
|
|
QString wGId = rules()->checkAutogroupById(QString());
|
|
|
|
if (!wGId.isEmpty()) {
|
|
|
|
foreach (Client *c, workspace()->clientList()) {
|
|
|
|
if (activities() != c->activities())
|
|
|
|
continue; // don't cross activities
|
|
|
|
if (wGId == c->rules()->checkAutogroupById(QString())) {
|
|
|
|
if (found && found->tabGroup() != c->tabGroup()) { // We've found two, ignore both
|
|
|
|
found = NULL;
|
|
|
|
break; // Continue to the next test
|
|
|
|
}
|
|
|
|
found = c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is a transient window don't take a guess
|
|
|
|
if (isTransient())
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// If we don't have an ID take a guess
|
2012-02-20 13:25:13 +04:00
|
|
|
if (rules()->checkAutogrouping(options->isAutogroupSimilarWindows())) {
|
2012-01-12 10:42:55 +04:00
|
|
|
QByteArray wRole = truncatedWindowRole(windowRole());
|
|
|
|
foreach (Client *c, workspace()->clientList()) {
|
|
|
|
if (desktop() != c->desktop() || activities() != c->activities())
|
|
|
|
continue;
|
|
|
|
QByteArray wRoleB = truncatedWindowRole(c->windowRole());
|
|
|
|
if (resourceClass() == c->resourceClass() && // Same resource class
|
|
|
|
wRole == wRoleB && // Same window role
|
|
|
|
c->isNormalWindow()) { // Normal window TODO: Can modal windows be "normal"?
|
|
|
|
if (found && found->tabGroup() != c->tabGroup()) // We've found two, ignore both
|
|
|
|
return NULL;
|
|
|
|
found = c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
} // namespace
|