2009-04-15 23:31:20 +04:00
|
|
|
/********************************************************************
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 2009 Michael Zanetti <michael_zanetti@gmx.net>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
#include "slideback.h"
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
SlideBackEffect::SlideBackEffect()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
m_tabboxActive = 0;
|
|
|
|
m_justMapped = m_upmostWindow = NULL;
|
|
|
|
connect(effects, SIGNAL(windowAdded(KWin::EffectWindow*)), SLOT(slotWindowAdded(KWin::EffectWindow*)));
|
|
|
|
connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), SLOT(slotWindowDeleted(KWin::EffectWindow*)));
|
|
|
|
connect(effects, SIGNAL(windowUnminimized(KWin::EffectWindow*)), SLOT(slotWindowUnminimized(KWin::EffectWindow*)));
|
|
|
|
connect(effects, SIGNAL(tabBoxAdded(int)), SLOT(slotTabBoxAdded()));
|
2013-02-21 01:40:57 +04:00
|
|
|
connect(effects, SIGNAL(stackingOrderChanged()), SLOT(slotStackingOrderChanged()));
|
2013-01-31 00:50:09 +04:00
|
|
|
connect(effects, SIGNAL(tabBoxClosed()), SLOT(slotTabBoxClosed()));
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool windowsShareDesktop(EffectWindow *w1, EffectWindow *w2)
|
|
|
|
{
|
2010-11-14 21:03:36 +03:00
|
|
|
return w1->isOnAllDesktops() || w2->isOnAllDesktops() || w1->desktop() == w2->desktop();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
|
|
|
|
void SlideBackEffect::slotStackingOrderChanged()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
if (effects->activeFullScreenEffect() || m_tabboxActive) {
|
|
|
|
oldStackingOrder = effects->stackingOrder();
|
|
|
|
usableOldStackingOrder = usableWindows(oldStackingOrder);
|
2009-04-15 23:31:20 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
EffectWindowList newStackingOrder = effects->stackingOrder(),
|
|
|
|
usableNewStackingOrder = usableWindows(newStackingOrder);
|
|
|
|
if (usableNewStackingOrder == usableOldStackingOrder || usableNewStackingOrder.isEmpty()) {
|
|
|
|
oldStackingOrder = newStackingOrder;
|
|
|
|
usableOldStackingOrder = usableNewStackingOrder;
|
2009-04-15 23:31:20 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-07-06 15:13:48 +04:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
m_upmostWindow = usableNewStackingOrder.last();
|
2009-07-06 15:13:48 +04:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
if (m_upmostWindow == m_justMapped ) // a window was added, got on top, stacking changed. Nothing impressive
|
|
|
|
m_justMapped = 0;
|
2013-02-21 01:40:57 +04:00
|
|
|
else if (!usableOldStackingOrder.isEmpty() && m_upmostWindow != usableOldStackingOrder.last())
|
2013-01-31 00:50:09 +04:00
|
|
|
windowRaised(m_upmostWindow);
|
|
|
|
|
|
|
|
oldStackingOrder = newStackingOrder;
|
|
|
|
usableOldStackingOrder = usableNewStackingOrder;
|
2011-01-30 17:34:42 +03:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void SlideBackEffect::windowRaised(EffectWindow *w)
|
|
|
|
{
|
2009-04-15 23:31:20 +04:00
|
|
|
// Determine all windows on top of the activated one
|
|
|
|
bool currentFound = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * tmp, oldStackingOrder) {
|
|
|
|
if (!currentFound) {
|
|
|
|
if (tmp == w) {
|
2009-04-15 23:31:20 +04:00
|
|
|
currentFound = true;
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
|
|
|
if (isWindowUsable(tmp) && windowsShareDesktop(tmp, w)) {
|
2009-04-15 23:31:20 +04:00
|
|
|
// Do we have to move it?
|
2011-01-30 17:34:42 +03:00
|
|
|
if (intersects(w, tmp->geometry())) {
|
2009-04-22 16:49:28 +04:00
|
|
|
QRect slideRect;
|
2011-01-30 17:34:42 +03:00
|
|
|
slideRect = getSlideDestination(getModalGroupGeometry(w), tmp->geometry());
|
|
|
|
effects->setElevatedWindow(tmp, true);
|
|
|
|
elevatedList.append(tmp);
|
|
|
|
motionManager.manage(tmp);
|
|
|
|
motionManager.moveWindow(tmp, slideRect);
|
|
|
|
destinationList.insert(tmp, slideRect);
|
|
|
|
coveringWindows.append(tmp);
|
|
|
|
} else {
|
2009-04-15 23:31:20 +04:00
|
|
|
//Does it intersect with a moved (elevated) window and do we have to elevate it too?
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * elevatedWindow, elevatedList) {
|
|
|
|
if (tmp->geometry().intersects(elevatedWindow->geometry())) {
|
|
|
|
effects->setElevatedWindow(tmp, true);
|
|
|
|
elevatedList.append(tmp);
|
2009-04-15 23:31:20 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (tmp->isDock() || tmp->keepAbove()) {
|
|
|
|
effects->setElevatedWindow(tmp, true);
|
|
|
|
elevatedList.append(tmp);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
// If a window is minimized it could happen that the panels stay elevated without any windows sliding.
|
|
|
|
// clear all elevation settings
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!motionManager.managingWindows()) {
|
|
|
|
foreach (EffectWindow * tmp, elevatedList) {
|
|
|
|
effects->setElevatedWindow(tmp, false);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
QRect SlideBackEffect::getSlideDestination(const QRect &windowUnderGeometry, const QRect &windowOverGeometry)
|
|
|
|
{
|
2009-04-21 01:19:14 +04:00
|
|
|
// Determine the shortest way:
|
|
|
|
int leftSlide = windowUnderGeometry.left() - windowOverGeometry.right() - 20;
|
|
|
|
int rightSlide = windowUnderGeometry.right() - windowOverGeometry.left() + 20;
|
|
|
|
int upSlide = windowUnderGeometry.top() - windowOverGeometry.bottom() - 20;
|
|
|
|
int downSlide = windowUnderGeometry.bottom() - windowOverGeometry.top() + 20;
|
|
|
|
|
|
|
|
int horizSlide = leftSlide;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (qAbs(horizSlide) > qAbs(rightSlide)) {
|
2009-04-21 01:19:14 +04:00
|
|
|
horizSlide = rightSlide;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-21 01:19:14 +04:00
|
|
|
int vertSlide = upSlide;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (qAbs(vertSlide) > qAbs(downSlide)) {
|
|
|
|
vertSlide = downSlide;
|
|
|
|
}
|
2009-04-21 01:19:14 +04:00
|
|
|
|
|
|
|
QRect slideRect = windowOverGeometry;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (qAbs(horizSlide) < qAbs(vertSlide)) {
|
|
|
|
slideRect.moveLeft(slideRect.x() + horizSlide);
|
|
|
|
} else {
|
|
|
|
slideRect.moveTop(slideRect.y() + vertSlide);
|
2009-04-21 01:19:14 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
return slideRect;
|
|
|
|
}
|
2009-04-21 01:19:14 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void SlideBackEffect::prePaintScreen(ScreenPrePaintData &data, int time)
|
|
|
|
{
|
|
|
|
if (motionManager.managingWindows()) {
|
|
|
|
motionManager.calculate(time);
|
2009-04-15 23:31:20 +04:00
|
|
|
data.mask |= Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
effects->prePaintScreen(data, time);
|
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
|
|
|
void SlideBackEffect::postPaintScreen()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
|
|
|
if (motionManager.areWindowsMoving()) {
|
2009-04-15 23:31:20 +04:00
|
|
|
effects->addRepaintFull();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
effects->postPaintScreen();
|
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void SlideBackEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
|
|
|
|
{
|
|
|
|
if (motionManager.isManaging(w)) {
|
2009-05-19 17:52:50 +04:00
|
|
|
data.setTransformed();
|
|
|
|
}
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
effects->prePaintWindow(w, data, time);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SlideBackEffect::paintWindow(EffectWindow *w, int mask, QRegion region, WindowPaintData &data)
|
|
|
|
{
|
|
|
|
if (motionManager.isManaging(w)) {
|
|
|
|
motionManager.apply(w, data);
|
|
|
|
}
|
2011-07-03 21:52:14 +04:00
|
|
|
foreach (const QRegion &r, clippedRegions) {
|
|
|
|
region = region.intersected(r);
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
effects->paintWindow(w, mask, region, data);
|
|
|
|
for (int i = clippedRegions.count() - 1; i > -1; --i)
|
|
|
|
PaintClipper::pop(clippedRegions.at(i));
|
|
|
|
clippedRegions.clear();
|
|
|
|
}
|
2009-05-19 17:52:50 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void SlideBackEffect::postPaintWindow(EffectWindow* w)
|
|
|
|
{
|
|
|
|
if (motionManager.isManaging(w)) {
|
|
|
|
if (destinationList.contains(w)) {
|
2011-06-20 23:56:56 +04:00
|
|
|
if (!motionManager.isWindowMoving(w)) { // has window reched its destination?
|
2013-01-31 00:50:09 +04:00
|
|
|
// If we are still intersecting with the upmostWindow it is moving. slide to somewhere else
|
2009-04-21 01:19:14 +04:00
|
|
|
// restore the stacking order of all windows not intersecting any more except panels
|
2011-01-30 17:34:42 +03:00
|
|
|
if (coveringWindows.contains(w)) {
|
2009-04-22 15:24:19 +04:00
|
|
|
EffectWindowList tmpList;
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * tmp, elevatedList) {
|
2009-04-27 16:57:52 +04:00
|
|
|
QRect elevatedGeometry = tmp->geometry();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (motionManager.isManaging(tmp)) {
|
|
|
|
elevatedGeometry = motionManager.transformedGeometry(tmp).toAlignedRect();
|
|
|
|
}
|
2013-01-31 00:50:09 +04:00
|
|
|
if (m_upmostWindow && !tmp->isDock() && !tmp->keepAbove() && m_upmostWindow->geometry().intersects(elevatedGeometry)) {
|
2009-04-22 16:49:28 +04:00
|
|
|
QRect newDestination;
|
2013-01-31 00:50:09 +04:00
|
|
|
newDestination = getSlideDestination(getModalGroupGeometry(m_upmostWindow), elevatedGeometry);
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!motionManager.isManaging(tmp)) {
|
|
|
|
motionManager.manage(tmp);
|
2009-04-21 01:19:14 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
motionManager.moveWindow(tmp, newDestination);
|
|
|
|
destinationList[tmp] = newDestination;
|
|
|
|
} else {
|
|
|
|
if (!tmp->isDock()) {
|
2009-04-22 15:24:19 +04:00
|
|
|
bool keepElevated = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * elevatedWindow, tmpList) {
|
|
|
|
if (tmp->geometry().intersects(elevatedWindow->geometry())) {
|
2009-04-22 15:24:19 +04:00
|
|
|
keepElevated = true;
|
|
|
|
}
|
2009-04-21 01:19:14 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!keepElevated) {
|
|
|
|
effects->setElevatedWindow(tmp, false);
|
|
|
|
elevatedList.removeAll(tmp);
|
|
|
|
}
|
2009-04-21 01:19:14 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
tmpList.append(tmp);
|
2009-04-21 01:19:14 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
2009-04-21 01:19:14 +04:00
|
|
|
// Move the window back where it belongs
|
2011-01-30 17:34:42 +03:00
|
|
|
motionManager.moveWindow(w, w->geometry());
|
|
|
|
destinationList.remove(w);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
2009-04-15 23:31:20 +04:00
|
|
|
// is window back at its original position?
|
2011-06-20 23:56:56 +04:00
|
|
|
if (!motionManager.isWindowMoving(w)) {
|
2011-01-30 17:34:42 +03:00
|
|
|
motionManager.unmanage(w);
|
2009-07-24 13:03:10 +04:00
|
|
|
effects->addRepaintFull();
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (coveringWindows.contains(w)) {
|
2009-04-15 23:31:20 +04:00
|
|
|
// It could happen that there is no aciveWindow() here if the user clicks the close-button on an inactive window.
|
|
|
|
// Just skip... the window will be removed in windowDeleted() later
|
2013-01-31 00:50:09 +04:00
|
|
|
if (m_upmostWindow && !intersects(m_upmostWindow, motionManager.transformedGeometry(w).toAlignedRect())) {
|
2011-01-30 17:34:42 +03:00
|
|
|
coveringWindows.removeAll(w);
|
|
|
|
if (coveringWindows.isEmpty()) {
|
2009-04-15 23:31:20 +04:00
|
|
|
// Restore correct stacking order
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * tmp, elevatedList) {
|
|
|
|
effects->setElevatedWindow(tmp, false);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
elevatedList.clear();
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
effects->postPaintWindow(w);
|
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-02-27 12:47:42 +03:00
|
|
|
void SlideBackEffect::slotWindowDeleted(EffectWindow* w)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
if (w == m_upmostWindow)
|
|
|
|
m_upmostWindow = 0;
|
|
|
|
if (w == m_justMapped)
|
|
|
|
m_justMapped = 0;
|
2011-01-30 17:34:42 +03:00
|
|
|
usableOldStackingOrder.removeAll(w);
|
|
|
|
oldStackingOrder.removeAll(w);
|
|
|
|
coveringWindows.removeAll(w);
|
|
|
|
elevatedList.removeAll(w);
|
|
|
|
if (motionManager.isManaging(w)) {
|
|
|
|
motionManager.unmanage(w);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-02-26 00:06:02 +03:00
|
|
|
void SlideBackEffect::slotWindowAdded(EffectWindow *w)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
m_justMapped = w;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-03-06 13:08:19 +03:00
|
|
|
void SlideBackEffect::slotWindowUnminimized(EffectWindow* w)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2009-07-06 15:13:48 +04:00
|
|
|
// SlideBack should not be triggered on an unminimized window. For this we need to store the last unminimized window.
|
2013-01-31 00:50:09 +04:00
|
|
|
m_justMapped = w;
|
2015-11-22 12:37:21 +03:00
|
|
|
// the stackingOrderChanged() signal came before the window turned an effect window
|
|
|
|
// usually this is no problem as the change shall not be caught anyway, but
|
|
|
|
// the window may have changed its stack position, bug #353745
|
|
|
|
slotStackingOrderChanged();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
void SlideBackEffect::slotTabBoxAdded()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
++m_tabboxActive;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2013-01-31 00:50:09 +04:00
|
|
|
void SlideBackEffect::slotTabBoxClosed()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2013-01-31 00:50:09 +04:00
|
|
|
m_tabboxActive = qMax(m_tabboxActive-1, 0);
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
bool SlideBackEffect::isWindowUsable(EffectWindow* w)
|
|
|
|
{
|
|
|
|
return w && (w->isNormalWindow() || w->isDialog()) && !w->keepAbove() && !w->isDeleted() && !w->isMinimized()
|
2012-01-12 10:42:55 +04:00
|
|
|
&& w->isCurrentTab();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
bool SlideBackEffect::intersects(EffectWindow* windowUnder, const QRect &windowOverGeometry)
|
|
|
|
{
|
|
|
|
QRect windowUnderGeometry = getModalGroupGeometry(windowUnder);
|
|
|
|
return windowUnderGeometry.intersects(windowOverGeometry);
|
|
|
|
}
|
2009-04-22 16:49:28 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
EffectWindowList SlideBackEffect::usableWindows(const EffectWindowList & allWindows)
|
|
|
|
{
|
2009-04-15 23:31:20 +04:00
|
|
|
EffectWindowList retList;
|
2011-01-30 17:34:42 +03:00
|
|
|
foreach (EffectWindow * tmp, allWindows) {
|
|
|
|
if (isWindowUsable(tmp)) {
|
|
|
|
retList.append(tmp);
|
2009-04-15 23:31:20 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
return retList;
|
|
|
|
}
|
2009-04-15 23:31:20 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
QRect SlideBackEffect::getModalGroupGeometry(EffectWindow *w)
|
|
|
|
{
|
2009-09-14 18:22:31 +04:00
|
|
|
QRect modalGroupGeometry = w->geometry();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (w->isModal()) {
|
|
|
|
foreach (EffectWindow * modalWindow, w->mainWindows()) {
|
|
|
|
modalGroupGeometry = modalGroupGeometry.united(getModalGroupGeometry(modalWindow));
|
2009-09-14 18:22:31 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
return modalGroupGeometry;
|
|
|
|
}
|
2009-09-14 18:22:31 +04:00
|
|
|
|
2011-08-27 13:21:31 +04:00
|
|
|
bool SlideBackEffect::isActive() const
|
|
|
|
{
|
|
|
|
return motionManager.managingWindows();
|
|
|
|
}
|
|
|
|
|
2009-04-15 23:31:20 +04:00
|
|
|
} //Namespace
|