1820 lines
52 KiB
C++
1820 lines
52 KiB
C++
/********************************************************************
|
|
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>
|
|
Copyright (C) 2009 Martin Gräßlin <kde@martin-graesslin.com>
|
|
|
|
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/>.
|
|
*********************************************************************/
|
|
|
|
//#define QT_CLEAN_NAMESPACE
|
|
#include "tabbox.h"
|
|
#include <QTextStream>
|
|
#include "workspace.h"
|
|
#include "effects.h"
|
|
#include "client.h"
|
|
#include <QStyleOptionGraphicsItem>
|
|
#include <QPainter>
|
|
#include <QTimeLine>
|
|
#include <kglobal.h>
|
|
#include <fixx11h.h>
|
|
#include <kconfig.h>
|
|
#include <klocale.h>
|
|
#include <QAction>
|
|
#include <stdarg.h>
|
|
#include <kdebug.h>
|
|
#include <kglobalsettings.h>
|
|
#include <kiconeffect.h>
|
|
#include <X11/keysym.h>
|
|
#include <X11/keysymdef.h>
|
|
#include <QX11Info>
|
|
#include <kactioncollection.h>
|
|
#include <kkeyserver.h>
|
|
#include <kconfiggroup.h>
|
|
#include <KDE/Plasma/Theme>
|
|
#include <KGlobalSettings>
|
|
|
|
// specify externals before namespace
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
extern QPixmap* kwin_get_menu_pix_hack();
|
|
|
|
TabBox::TabBox( Workspace *ws )
|
|
: QGraphicsView()
|
|
, wspace(ws)
|
|
, client(0)
|
|
, display_refcount( 0 )
|
|
, selectionItem( 0 )
|
|
{
|
|
scene = new QGraphicsScene( this );
|
|
setWindowFlags( Qt::X11BypassWindowManagerHint );
|
|
setScene( scene );
|
|
setFrameStyle( QFrame::NoFrame );
|
|
viewport()->setAutoFillBackground( false );
|
|
setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
|
|
setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
|
|
setAttribute( Qt::WA_TranslucentBackground );
|
|
frame.setImagePath( "dialogs/background" );
|
|
frame.setCacheAllRenderedFrames( true );
|
|
frame.setEnabledBorders( Plasma::FrameSvg::AllBorders );
|
|
item_frame.setImagePath( "widgets/viewitem" );
|
|
item_frame.setElementPrefix( "hover" );
|
|
item_frame.setCacheAllRenderedFrames( true );
|
|
item_frame.setEnabledBorders( Plasma::FrameSvg::AllBorders );
|
|
|
|
showMiniIcon = false;
|
|
|
|
no_tasks = i18n("*** No Windows ***");
|
|
m = TabBoxDesktopMode; // init variables
|
|
reconfigure();
|
|
reset();
|
|
connect(&delayedShowTimer, SIGNAL(timeout()), this, SLOT(show()));
|
|
XSetWindowAttributes attr;
|
|
attr.override_redirect = 1;
|
|
outline_left = XCreateWindow( QX11Info::display(), QX11Info::appRootWindow(), 0, 0, 1, 1, 0,
|
|
CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
|
|
outline_right = XCreateWindow( QX11Info::display(), QX11Info::appRootWindow(), 0, 0, 1, 1, 0,
|
|
CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
|
|
outline_top = XCreateWindow( QX11Info::display(), QX11Info::appRootWindow(), 0, 0, 1, 1, 0,
|
|
CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
|
|
outline_bottom = XCreateWindow( QX11Info::display(), QX11Info::appRootWindow(), 0, 0, 1, 1, 0,
|
|
CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
|
|
}
|
|
|
|
TabBox::~TabBox()
|
|
{
|
|
XDestroyWindow( QX11Info::display(), outline_left );
|
|
XDestroyWindow( QX11Info::display(), outline_right );
|
|
XDestroyWindow( QX11Info::display(), outline_top );
|
|
XDestroyWindow( QX11Info::display(), outline_bottom );
|
|
}
|
|
|
|
|
|
/*!
|
|
Sets the current mode to \a mode, either TabBoxDesktopListMode or TabBoxWindowsMode
|
|
|
|
\sa mode()
|
|
*/
|
|
void TabBox::setMode( TabBoxMode mode )
|
|
{
|
|
m = mode;
|
|
}
|
|
|
|
|
|
/*!
|
|
Create list of clients on specified desktop, starting with client c
|
|
*/
|
|
void TabBox::createClientList(ClientList &list, int desktop /*-1 = all*/, Client *c, bool chain)
|
|
{
|
|
ClientList::size_type idx = 0;
|
|
|
|
list.clear();
|
|
|
|
Client* start = c;
|
|
|
|
if ( chain )
|
|
c = workspace()->nextClientFocusChain(c);
|
|
else
|
|
c = workspace()->stackingOrder().first();
|
|
|
|
Client* stop = c;
|
|
|
|
while ( c )
|
|
{
|
|
Client* add = NULL;
|
|
if ( ((desktop == -1) || c->isOnDesktop(desktop))
|
|
&& c->wantsTabFocus() )
|
|
{ // don't add windows that have modal dialogs
|
|
Client* modal = c->findModal();
|
|
if( modal == NULL || modal == c )
|
|
add = c;
|
|
else if( !list.contains( modal ))
|
|
add = modal;
|
|
else
|
|
{
|
|
// nothing
|
|
}
|
|
}
|
|
if( options->separateScreenFocus && options->xineramaEnabled )
|
|
{
|
|
if( c->screen() != workspace()->activeScreen())
|
|
add = NULL;
|
|
}
|
|
if( add != NULL )
|
|
{
|
|
if ( start == add )
|
|
{
|
|
list.removeAll( add );
|
|
list.prepend( add );
|
|
}
|
|
else
|
|
list += add;
|
|
}
|
|
if ( chain )
|
|
c = workspace()->nextClientFocusChain( c );
|
|
else
|
|
{
|
|
if ( idx >= (workspace()->stackingOrder().size()-1) )
|
|
c = 0;
|
|
else
|
|
c = workspace()->stackingOrder()[++idx];
|
|
}
|
|
|
|
if ( c == stop )
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Create list of desktops, starting with desktop start
|
|
*/
|
|
void TabBox::createDesktopList(QList< int > &list, int start, SortOrder order)
|
|
{
|
|
list.clear();
|
|
|
|
int iDesktop = start;
|
|
|
|
for( int i = 1; i <= workspace()->numberOfDesktops(); i++ )
|
|
{
|
|
list.append( iDesktop );
|
|
if ( order == StaticOrder )
|
|
{
|
|
iDesktop = workspace()->nextDesktopStatic( iDesktop );
|
|
}
|
|
else
|
|
{ // MostRecentlyUsedOrder
|
|
iDesktop = workspace()->nextDesktopFocusChain( iDesktop );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Resets the tab box to display the active client in TabBoxWindowsMode, or the
|
|
current desktop in TabBoxDesktopListMode
|
|
*/
|
|
void TabBox::reset( bool partial_reset )
|
|
{
|
|
int w, h, cw = 0, wmax = 0;
|
|
qreal left, top, right, bottom;
|
|
frame.getMargins( left, top, right, bottom );
|
|
|
|
QRect r = workspace()->screenGeometry( workspace()->activeScreen());
|
|
|
|
// calculate height of 1 line
|
|
// fontheight + 2 pixel above + 2 pixel below, or 32x32 icon + 4 pixel above + below
|
|
lineHeight = top + bottom + qMax(QFontMetrics( KGlobalSettings::smallestReadableFont() ).height(), 32 );
|
|
|
|
if ( mode() == TabBoxWindowsMode )
|
|
{
|
|
Client* starting_client = 0;
|
|
if( partial_reset && clients.count() != 0 )
|
|
starting_client = clients.first();
|
|
else
|
|
client = starting_client = workspace()->activeClient();
|
|
|
|
// get all clients to show
|
|
createClientList(clients, options_traverse_all ? -1 : workspace()->currentDesktop(), starting_client, true);
|
|
|
|
// calculate maximum caption width
|
|
cw = fontMetrics().width(no_tasks) + 20;
|
|
QFont f = font();
|
|
f.setPointSize( KGlobalSettings::smallestReadableFont().pointSize() );
|
|
QFontMetrics fm = QFontMetrics( f );
|
|
for (ClientList::ConstIterator it = clients.constBegin(); it != clients.constEnd(); ++it)
|
|
{
|
|
cw = fm.width( (*it)->caption() );
|
|
if( (*it)->desktop() != wspace->currentDesktop() )
|
|
cw += fm.width( QString( wspace->desktopName((*it)->desktop()) + ": " ) );
|
|
if ( cw > wmax ) wmax = cw;
|
|
}
|
|
|
|
// calculate height for the popup
|
|
if ( clients.count() == 0 ) // height for the "not tasks" text
|
|
{
|
|
QFont f = font();
|
|
f.setBold( true );
|
|
f.setPointSize( 14 );
|
|
|
|
h = QFontMetrics(f).height()*4;
|
|
}
|
|
else
|
|
{
|
|
showMiniIcon = false;
|
|
h = clients.count() * lineHeight;
|
|
|
|
if ( h > (r.height()-(top + bottom)) ) // if too high, use mini icons
|
|
{
|
|
showMiniIcon = true;
|
|
// fontheight + 1 pixel above + 1 pixel below, or 16x16 icon + 2 pixel above + below
|
|
lineHeight = qMax(QFontMetrics( KGlobalSettings::smallestReadableFont() ).height() + 2, 16 + 4);
|
|
|
|
h = clients.count() * lineHeight;
|
|
|
|
if ( h > (r.height()-(top + bottom)) ) // if still too high, remove some clients
|
|
{
|
|
// how many clients to remove
|
|
int howMany = (h - (r.height()-(top + bottom)))/lineHeight + 1;
|
|
for (; howMany; howMany--)
|
|
clients.removeAll(clients.last());
|
|
|
|
h = clients.count() * lineHeight;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int starting_desktop;
|
|
if( mode() == TabBoxDesktopListMode )
|
|
{
|
|
starting_desktop = 1;
|
|
createDesktopList(desktops, starting_desktop, StaticOrder );
|
|
}
|
|
else
|
|
{ // TabBoxDesktopMode
|
|
starting_desktop = workspace()->currentDesktop();
|
|
createDesktopList(desktops, starting_desktop, MostRecentlyUsedOrder );
|
|
}
|
|
|
|
if( !partial_reset )
|
|
desk = workspace()->currentDesktop();
|
|
|
|
showMiniIcon = false;
|
|
|
|
foreach (int it, desktops)
|
|
{
|
|
cw = fontMetrics().width( workspace()->desktopName(it) );
|
|
if ( cw > wmax ) wmax = cw;
|
|
}
|
|
|
|
// calculate height for the popup (max. 16 desktops always fit in a 800x600 screen)
|
|
h = desktops.count() * lineHeight;
|
|
}
|
|
|
|
// height, width for the popup
|
|
h += top + bottom;
|
|
h = qMin( h, r.height() );
|
|
w = left + right + 5*2 + ( showMiniIcon ? 16 : 32 ) + 8 + wmax; // 5*2=margins, ()=icon, 8=space between icon+text
|
|
w = qBound( r.width()/5 , w, r.width() * 4 / 5 );
|
|
|
|
setGeometry((r.width()-w)/2 + r.x(),
|
|
(r.height()-h)/2+ r.y(),
|
|
w, h );
|
|
scene->setSceneRect( 0, 0, w, h );
|
|
frame.resizeFrame( QSize( w , h ) );
|
|
// resizing the item frame
|
|
item_frame.resizeFrame( QSize( w-left-right, lineHeight ) );
|
|
|
|
setMask( frame.mask() );
|
|
|
|
if( partial_reset )
|
|
initScene();
|
|
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxUpdated();
|
|
}
|
|
|
|
void TabBox::initScene()
|
|
{
|
|
scene->clear();
|
|
qreal left, top, right, bottom;
|
|
frame.getMargins( left, top, right, bottom );
|
|
|
|
if( KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects )
|
|
{
|
|
selectionItem = new TabBoxSelectionItem( this );
|
|
selectionItem->setPos( left, top );
|
|
selectionItem->hide();
|
|
scene->addItem( selectionItem );
|
|
}
|
|
else
|
|
{
|
|
selectionItem = 0;
|
|
}
|
|
|
|
if( mode() == TabBoxWindowsMode )
|
|
{
|
|
if( clients.isEmpty() )
|
|
{
|
|
QFont f = font();
|
|
f.setBold( true );
|
|
f.setPointSize( 14 );
|
|
|
|
QGraphicsTextItem* item = scene->addText( no_tasks, f );
|
|
item->setDefaultTextColor( Plasma::Theme::defaultTheme()->color( Plasma::Theme::TextColor ) );
|
|
item->adjustSize();
|
|
item->setPos( width()*0.5 - QFontMetrics(f).width( item->toPlainText() )*0.5,
|
|
height()*0.5 - QFontMetrics(f).height()*0.5 );
|
|
}
|
|
else
|
|
{
|
|
// add clients to scene
|
|
int index = 0;
|
|
|
|
foreach( Client* c, clients )
|
|
{
|
|
TabBoxWindowItem* item = new TabBoxWindowItem( c, this );
|
|
item->setHeight( lineHeight );
|
|
item->setWidth( width() - left - right );
|
|
item->setShowMiniIcons( showMiniIcon );
|
|
item->setPos( left, top + lineHeight * index );
|
|
scene->addItem( item );
|
|
|
|
if ( selectionItem && c == client )
|
|
{
|
|
selectionItem->setPos( item->pos() );
|
|
}
|
|
|
|
index++;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{ // TabBoxDesktopMode || TabBoxDesktopListMode
|
|
int y = top;
|
|
|
|
QRect r = workspace()->screenGeometry( workspace()->activeScreen());
|
|
foreach (int it, desktops)
|
|
{
|
|
TabBoxDesktopItem* item = new TabBoxDesktopItem( it, this );
|
|
item->setHeight( lineHeight );
|
|
item->setWidth( width() - left - right );
|
|
item->setPos( left, top + lineHeight * (it-1) );
|
|
scene->addItem( item );
|
|
// next desktop
|
|
y += lineHeight;
|
|
if ( y >= r.height() )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Shows the next or previous item, depending on \a next
|
|
*/
|
|
void TabBox::nextPrev( bool next)
|
|
{
|
|
if ( mode() == TabBoxWindowsMode )
|
|
{
|
|
Client* firstClient = 0;
|
|
Client* newClient = client;
|
|
do
|
|
{
|
|
if ( next )
|
|
newClient = workspace()->nextClientFocusChain(newClient);
|
|
else
|
|
newClient = workspace()->previousClientFocusChain(newClient);
|
|
if (!firstClient)
|
|
{
|
|
// When we see our first client for the second time,
|
|
// it's time to stop.
|
|
firstClient = newClient;
|
|
}
|
|
else if (newClient == firstClient)
|
|
{
|
|
// No candidates found.
|
|
newClient = 0;
|
|
break;
|
|
}
|
|
} while ( newClient && !clients.contains( newClient ));
|
|
setCurrentClient( newClient );
|
|
}
|
|
else if( mode() == TabBoxDesktopMode )
|
|
{
|
|
setCurrentDesktop ( next ? workspace()->nextDesktopFocusChain( desk )
|
|
: workspace()->previousDesktopFocusChain( desk ) );
|
|
}
|
|
else
|
|
{ // TabBoxDesktopListMode
|
|
setCurrentDesktop ( next ? workspace()->nextDesktopStatic( desk )
|
|
: workspace()->previousDesktopStatic( desk )) ;
|
|
}
|
|
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxUpdated();
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
Returns the currently displayed client ( only works in TabBoxWindowsMode ).
|
|
Returns 0 if no client is displayed.
|
|
*/
|
|
Client* TabBox::currentClient()
|
|
{
|
|
if ( mode() != TabBoxWindowsMode )
|
|
return 0;
|
|
if (!workspace()->hasClient( client ))
|
|
return 0;
|
|
return client;
|
|
}
|
|
|
|
/*!
|
|
Returns the list of clients potentially displayed ( only works in
|
|
TabBoxWindowsMode ).
|
|
Returns an empty list if no clients are available.
|
|
*/
|
|
ClientList TabBox::currentClientList()
|
|
{
|
|
if( mode() != TabBoxWindowsMode )
|
|
return ClientList();
|
|
return clients;
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the currently displayed virtual desktop ( only works in
|
|
TabBoxDesktopListMode )
|
|
Returns -1 if no desktop is displayed.
|
|
*/
|
|
int TabBox::currentDesktop()
|
|
{
|
|
if ( mode() == TabBoxDesktopListMode || mode() == TabBoxDesktopMode )
|
|
return desk;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the list of desktops potentially displayed ( only works in
|
|
TabBoxDesktopListMode )
|
|
Returns an empty list if no desktops are available.
|
|
*/
|
|
QList< int > TabBox::currentDesktopList()
|
|
{
|
|
if ( mode() == TabBoxDesktopListMode || mode() == TabBoxDesktopMode )
|
|
return desktops;
|
|
return QList< int >();
|
|
}
|
|
|
|
|
|
/*!
|
|
Change the currently selected client, and notify the effects.
|
|
|
|
\sa setCurrentDesktop()
|
|
*/
|
|
void TabBox::setCurrentClient( Client* newClient )
|
|
{
|
|
foreach( QGraphicsItem *item, scene->items() )
|
|
{
|
|
TabBoxWindowItem* wItem = dynamic_cast<TabBoxWindowItem*>( item );
|
|
if( !wItem )
|
|
continue;
|
|
|
|
if ( wItem->client() == newClient )
|
|
{
|
|
if (selectionItem)
|
|
selectionItem->moveTo( wItem );
|
|
else
|
|
wItem->update();
|
|
}
|
|
else if ( !selectionItem && wItem->client() == client )
|
|
{
|
|
wItem->update();
|
|
}
|
|
}
|
|
|
|
client = newClient;
|
|
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxUpdated();
|
|
|
|
if( isVisible() )
|
|
updateOutline();
|
|
}
|
|
|
|
/*!
|
|
Change the currently selected desktop, and notify the effects.
|
|
|
|
\sa setCurrentClient()
|
|
*/
|
|
void TabBox::setCurrentDesktop( int newDesktop )
|
|
{
|
|
foreach( QGraphicsItem *item, scene->items() )
|
|
{
|
|
TabBoxDesktopItem* dItem = dynamic_cast<TabBoxDesktopItem*>( item );
|
|
if( !dItem )
|
|
continue;
|
|
|
|
if ( dItem->desktop() == newDesktop )
|
|
{
|
|
if (selectionItem)
|
|
selectionItem->moveTo( dItem );
|
|
else
|
|
dItem->update();
|
|
}
|
|
else if ( !selectionItem && dItem->desktop() == desk )
|
|
{
|
|
dItem->update();
|
|
}
|
|
}
|
|
|
|
desk = newDesktop;
|
|
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxUpdated();
|
|
}
|
|
|
|
/*!
|
|
Reimplemented to raise the tab box as well
|
|
*/
|
|
void TabBox::showEvent( QShowEvent* )
|
|
{
|
|
if( isVisible() )
|
|
updateOutline();
|
|
raise();
|
|
}
|
|
|
|
|
|
/*!
|
|
hide the icon box if necessary
|
|
*/
|
|
void TabBox::hideEvent( QHideEvent* )
|
|
{
|
|
}
|
|
|
|
void TabBox::drawBackground( QPainter* painter, const QRectF& rect )
|
|
{
|
|
painter->save();
|
|
painter->setCompositionMode( QPainter::CompositionMode_Source );
|
|
qreal left, top, right, bottom;
|
|
frame.getMargins( left, top, right, bottom );
|
|
frame.paintFrame( painter, rect.adjusted( -left, -top, right, bottom ) );
|
|
painter->restore();
|
|
}
|
|
|
|
|
|
/*!
|
|
Notify effects that the tab box is being shown, and only display the
|
|
default tab box QFrame if no effect has referenced the tab box.
|
|
*/
|
|
void TabBox::show()
|
|
{
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxAdded( mode());
|
|
if( isDisplayed())
|
|
return;
|
|
refDisplay();
|
|
QWidget::show();
|
|
}
|
|
|
|
void TabBox::updateOutline()
|
|
{
|
|
Client* c = currentClient();
|
|
if( c == NULL || this->isHidden() || !c->isShown( true ) || !c->isOnCurrentDesktop())
|
|
{
|
|
XUnmapWindow( QX11Info::display(), outline_left );
|
|
XUnmapWindow( QX11Info::display(), outline_right );
|
|
XUnmapWindow( QX11Info::display(), outline_top );
|
|
XUnmapWindow( QX11Info::display(), outline_bottom );
|
|
return;
|
|
}
|
|
// left/right parts are between top/bottom, they don't reach as far as the corners
|
|
XMoveResizeWindow( QX11Info::display(), outline_left, c->x(), c->y() + 5, 5, c->height() - 10 );
|
|
XMoveResizeWindow( QX11Info::display(), outline_right, c->x() + c->width() - 5, c->y() + 5, 5, c->height() - 10 );
|
|
XMoveResizeWindow( QX11Info::display(), outline_top, c->x(), c->y(), c->width(), 5 );
|
|
XMoveResizeWindow( QX11Info::display(), outline_bottom, c->x(), c->y() + c->height() - 5, c->width(), 5 );
|
|
{
|
|
QPixmap pix( 5, c->height() - 10 );
|
|
QPainter p( &pix );
|
|
p.setPen( Qt::white );
|
|
p.drawLine( 0, 0, 0, pix.height() - 1 );
|
|
p.drawLine( 4, 0, 4, pix.height() - 1 );
|
|
p.setPen( Qt::gray );
|
|
p.drawLine( 1, 0, 1, pix.height() - 1 );
|
|
p.drawLine( 3, 0, 3, pix.height() - 1 );
|
|
p.setPen( Qt::black );
|
|
p.drawLine( 2, 0, 2, pix.height() - 1 );
|
|
p.end();
|
|
XSetWindowBackgroundPixmap( QX11Info::display(), outline_left, pix.handle());
|
|
XSetWindowBackgroundPixmap( QX11Info::display(), outline_right, pix.handle());
|
|
}
|
|
{
|
|
QPixmap pix( c->width(), 5 );
|
|
QPainter p( &pix );
|
|
p.setPen( Qt::white );
|
|
p.drawLine( 0, 0, pix.width() - 1 - 0, 0 );
|
|
p.drawLine( 4, 4, pix.width() - 1 - 4, 4 );
|
|
p.drawLine( 0, 0, 0, 4 );
|
|
p.drawLine( pix.width() - 1 - 0, 0, pix.width() - 1 - 0, 4 );
|
|
p.setPen( Qt::gray );
|
|
p.drawLine( 1, 1, pix.width() - 1 - 1, 1 );
|
|
p.drawLine( 3, 3, pix.width() - 1 - 3, 3 );
|
|
p.drawLine( 1, 1, 1, 4 );
|
|
p.drawLine( 3, 3, 3, 4 );
|
|
p.drawLine( pix.width() - 1 - 1, 1, pix.width() - 1 - 1, 4 );
|
|
p.drawLine( pix.width() - 1 - 3, 3, pix.width() - 1 - 3, 4 );
|
|
p.setPen( Qt::black );
|
|
p.drawLine( 2, 2, pix.width() - 1 - 2, 2 );
|
|
p.drawLine( 2, 2, 2, 4 );
|
|
p.drawLine( pix.width() - 1 - 2, 2, pix.width() - 1 - 2, 4 );
|
|
p.end();
|
|
XSetWindowBackgroundPixmap( QX11Info::display(), outline_top, pix.handle());
|
|
}
|
|
{
|
|
QPixmap pix( c->width(), 5 );
|
|
QPainter p( &pix );
|
|
p.setPen( Qt::white );
|
|
p.drawLine( 4, 0, pix.width() - 1 - 4, 0 );
|
|
p.drawLine( 0, 4, pix.width() - 1 - 0, 4 );
|
|
p.drawLine( 0, 4, 0, 0 );
|
|
p.drawLine( pix.width() - 1 - 0, 4, pix.width() - 1 - 0, 0 );
|
|
p.setPen( Qt::gray );
|
|
p.drawLine( 3, 1, pix.width() - 1 - 3, 1 );
|
|
p.drawLine( 1, 3, pix.width() - 1 - 1, 3 );
|
|
p.drawLine( 3, 1, 3, 0 );
|
|
p.drawLine( 1, 3, 1, 0 );
|
|
p.drawLine( pix.width() - 1 - 3, 1, pix.width() - 1 - 3, 0 );
|
|
p.drawLine( pix.width() - 1 - 1, 3, pix.width() - 1 - 1, 0 );
|
|
p.setPen( Qt::black );
|
|
p.drawLine( 2, 2, pix.width() - 1 - 2, 2 );
|
|
p.drawLine( 2, 0, 2, 2 );
|
|
p.drawLine( pix.width() - 1 - 2, 0, pix.width() - 1 - 2, 2 );
|
|
p.end();
|
|
XSetWindowBackgroundPixmap( QX11Info::display(), outline_bottom, pix.handle());
|
|
}
|
|
XClearWindow( QX11Info::display(), outline_left );
|
|
XClearWindow( QX11Info::display(), outline_right );
|
|
XClearWindow( QX11Info::display(), outline_top );
|
|
XClearWindow( QX11Info::display(), outline_bottom );
|
|
XMapWindow( QX11Info::display(), outline_left );
|
|
XMapWindow( QX11Info::display(), outline_right );
|
|
XMapWindow( QX11Info::display(), outline_top );
|
|
XMapWindow( QX11Info::display(), outline_bottom );
|
|
}
|
|
|
|
/*!
|
|
Notify effects that the tab box is being hidden.
|
|
*/
|
|
void TabBox::hide()
|
|
{
|
|
delayedShowTimer.stop();
|
|
if( isVisible())
|
|
{
|
|
unrefDisplay();
|
|
XUnmapWindow( QX11Info::display(), outline_left );
|
|
XUnmapWindow( QX11Info::display(), outline_right );
|
|
XUnmapWindow( QX11Info::display(), outline_top );
|
|
XUnmapWindow( QX11Info::display(), outline_bottom );
|
|
}
|
|
if( effects )
|
|
static_cast<EffectsHandlerImpl*>(effects)->tabBoxClosed();
|
|
if( isDisplayed())
|
|
kDebug( 1212 ) << "Tab box was not properly closed by an effect";
|
|
QWidget::hide();
|
|
QApplication::syncX();
|
|
XEvent otherEvent;
|
|
while (XCheckTypedEvent (display(), EnterNotify, &otherEvent ) )
|
|
;
|
|
}
|
|
|
|
|
|
/*!
|
|
Decrease the reference count. Only when the reference count is 0 will
|
|
the default tab box be shown.
|
|
*/
|
|
void TabBox::unrefDisplay()
|
|
{
|
|
--display_refcount;
|
|
}
|
|
|
|
void TabBox::reconfigure()
|
|
{
|
|
KSharedConfigPtr c(KGlobal::config());
|
|
options_traverse_all = c->group("TabBox").readEntry("TraverseAll", false );
|
|
}
|
|
|
|
/*!
|
|
Rikkus: please document! (Matthias)
|
|
|
|
Ok, here's the docs :)
|
|
|
|
You call delayedShow() instead of show() directly.
|
|
|
|
If the 'ShowDelay' setting is false, show() is simply called.
|
|
|
|
Otherwise, we start a timer for the delay given in the settings and only
|
|
do a show() when it times out.
|
|
|
|
This means that you can alt-tab between windows and you don't see the
|
|
tab box immediately. Not only does this make alt-tabbing faster, it gives
|
|
less 'flicker' to the eyes. You don't need to see the tab box if you're
|
|
just quickly switching between 2 or 3 windows. It seems to work quite
|
|
nicely.
|
|
*/
|
|
void TabBox::delayedShow()
|
|
{
|
|
KSharedConfigPtr c(KGlobal::config());
|
|
KConfigGroup cg(c, "TabBox");
|
|
bool delay = cg.readEntry("ShowDelay", true);
|
|
|
|
if (!delay)
|
|
{
|
|
show();
|
|
return;
|
|
}
|
|
|
|
int delayTime = cg.readEntry("DelayTime", 90);
|
|
delayedShowTimer.setSingleShot(true);
|
|
delayedShowTimer.start(delayTime);
|
|
}
|
|
|
|
|
|
void TabBox::handleMouseEvent( XEvent* e )
|
|
{
|
|
XAllowEvents( display(), AsyncPointer, xTime());
|
|
if( !isVisible() && isDisplayed())
|
|
{ // tabbox has been replaced, check effects
|
|
if( effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent( e ))
|
|
return;
|
|
}
|
|
if( e->type != ButtonPress )
|
|
return;
|
|
QPoint pos( e->xbutton.x_root, e->xbutton.y_root );
|
|
QPoint widgetPos = mapFromGlobal( pos ); // inside tabbox
|
|
|
|
if(( !isVisible() && isDisplayed())
|
|
|| !geometry().contains( pos ))
|
|
{
|
|
workspace()->closeTabBox(); // click outside closes tab
|
|
return;
|
|
}
|
|
|
|
qreal left, top, right, bottom;
|
|
frame.getMargins( left, top, right, bottom );
|
|
int num = (widgetPos.y()-top) / lineHeight;
|
|
|
|
if( mode() == TabBoxWindowsMode )
|
|
{
|
|
for( ClientList::ConstIterator it = clients.constBegin();
|
|
it != clients.constEnd();
|
|
++it)
|
|
{
|
|
if( workspace()->hasClient( *it ) && (num == 0) ) // safety
|
|
{
|
|
setCurrentClient( *it );
|
|
break;
|
|
}
|
|
num--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach( int it, desktops )
|
|
{
|
|
if( num == 0 )
|
|
{
|
|
setCurrentDesktop( it );
|
|
break;
|
|
}
|
|
num--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//*******************************
|
|
// TabBoxSelectionItem
|
|
//*******************************
|
|
TabBoxSelectionItem::TabBoxSelectionItem( TabBox* parent )
|
|
: QObject()
|
|
, QGraphicsItem()
|
|
, m_parent( parent )
|
|
, m_timeLine( new QTimeLine( 100, this ) )
|
|
{
|
|
setCacheMode( DeviceCoordinateCache );
|
|
setZValue( -1000 );
|
|
setFlag(ItemIsMovable, false);
|
|
setFlag(ItemIsSelectable, false);
|
|
setFlag(ItemIsFocusable, false);
|
|
|
|
m_timeLine->setFrameRange( 0, 40 );
|
|
m_timeLine->setCurveShape( QTimeLine::EaseInCurve );
|
|
connect( m_timeLine, SIGNAL( valueChanged(qreal) ),
|
|
this, SLOT( animateMove(qreal) ) );
|
|
}
|
|
|
|
TabBoxSelectionItem::~TabBoxSelectionItem()
|
|
{
|
|
}
|
|
|
|
QRectF TabBoxSelectionItem::boundingRect() const
|
|
{
|
|
return m_boundingRect;
|
|
}
|
|
|
|
void TabBoxSelectionItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget )
|
|
{
|
|
Q_UNUSED( widget );
|
|
painter->setRenderHint( QPainter::Antialiasing );
|
|
m_parent->itemFrame()->paintFrame( painter, option->exposedRect, option->exposedRect );
|
|
}
|
|
|
|
void TabBoxSelectionItem::moveTo( QGraphicsItem * item )
|
|
{
|
|
if (m_boundingRect != item->boundingRect())
|
|
{
|
|
prepareGeometryChange();
|
|
m_boundingRect = item->boundingRect();
|
|
}
|
|
|
|
show();
|
|
|
|
if (!m_animEndRect.isEmpty()) {
|
|
setPos(m_animEndRect.topLeft());
|
|
}
|
|
|
|
m_animStartRect = QRectF( pos(), boundingRect().size() );
|
|
m_animEndRect = QRectF( item->pos(), item->boundingRect().size() );
|
|
m_timeLine->stop();
|
|
m_timeLine->start();
|
|
}
|
|
|
|
void TabBoxSelectionItem::animateMove( qreal t )
|
|
{
|
|
setPos(m_animStartRect.topLeft() * (1 - t) + m_animEndRect.topLeft() * t);
|
|
if (qFuzzyCompare(t, qreal(1.0))) {
|
|
m_animEndRect = QRect();
|
|
}
|
|
}
|
|
|
|
//*******************************
|
|
// TabBoxWindowItem
|
|
//*******************************
|
|
|
|
TabBoxWindowItem::TabBoxWindowItem( Client* client, TabBox* parent )
|
|
: QGraphicsItem()
|
|
, m_client( client )
|
|
, m_parent( parent )
|
|
, m_width( 0 )
|
|
, m_height( 0 )
|
|
, m_showMiniIcons( false )
|
|
{
|
|
setCacheMode( DeviceCoordinateCache );
|
|
}
|
|
|
|
TabBoxWindowItem::~TabBoxWindowItem()
|
|
{
|
|
}
|
|
|
|
QRectF TabBoxWindowItem::boundingRect() const
|
|
{
|
|
return QRectF( 0, 0, m_width, m_height );
|
|
}
|
|
|
|
void TabBoxWindowItem::setHeight( int height )
|
|
{
|
|
m_height = height;
|
|
}
|
|
|
|
void TabBoxWindowItem::setWidth( int width )
|
|
{
|
|
m_width = width;
|
|
}
|
|
|
|
void TabBoxWindowItem::setShowMiniIcons( bool showMiniIcons )
|
|
{
|
|
m_showMiniIcons = showMiniIcons;
|
|
}
|
|
|
|
Client* TabBoxWindowItem::client() const
|
|
{
|
|
return m_client;
|
|
}
|
|
|
|
void TabBoxWindowItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget )
|
|
{
|
|
painter->setRenderHint( QPainter::Antialiasing );
|
|
|
|
drawBackground( painter, option, widget );
|
|
|
|
// draw icon
|
|
int iconWidth = m_showMiniIcons ? 16 : 32;
|
|
int x = 0;
|
|
QPixmap* menu_pix = kwin_get_menu_pix_hack();
|
|
QPixmap icon;
|
|
if ( m_showMiniIcons )
|
|
{
|
|
if ( !m_client->miniIcon().isNull() )
|
|
icon = m_client->miniIcon();
|
|
}
|
|
else
|
|
{
|
|
if ( !m_client->icon().isNull() )
|
|
icon = m_client->icon();
|
|
else if ( menu_pix )
|
|
icon = *menu_pix;
|
|
}
|
|
|
|
const int iconX = x + 5;
|
|
const int iconY = ( m_height - iconWidth ) / 2;
|
|
if( !icon.isNull() )
|
|
{
|
|
if( m_client->isMinimized())
|
|
KIconEffect::semiTransparent( icon );
|
|
if( m_client == m_parent->currentClient() )
|
|
{
|
|
KIconEffect *effect = KIconLoader::global()->iconEffect();
|
|
icon = effect->apply( icon, KIconLoader::Desktop, KIconLoader::ActiveState );
|
|
}
|
|
painter->drawPixmap( iconX, iconY, icon );
|
|
}
|
|
|
|
// generate text to display
|
|
QString s;
|
|
|
|
if ( !m_client->isOnDesktop(m_parent->workspace()->currentDesktop()) )
|
|
s = m_parent->workspace()->desktopName(m_client->desktop()).append(": ");
|
|
|
|
int textOptions = Qt::AlignLeft | Qt::AlignBottom | Qt ::TextSingleLine;
|
|
QFont font = painter->font();
|
|
font.setPointSize( KGlobalSettings::smallestReadableFont().pointSize() );
|
|
|
|
if ( m_client->isMinimized() )
|
|
{
|
|
s += '(' + m_client->caption() + ')';
|
|
font.setItalic( true );
|
|
}
|
|
else
|
|
s += m_client->caption();
|
|
|
|
QFontMetrics fm = QFontMetrics( font );
|
|
const int textWidth = m_width - iconX - iconWidth;
|
|
int textHeight = m_height - (iconX * 2);
|
|
|
|
if (!m_showMiniIcons && fm.height() < m_height * 2 / 3) {
|
|
textHeight = m_height - (m_height / 3);
|
|
}
|
|
|
|
s = fm.elidedText( s, Qt::ElideMiddle, textWidth );
|
|
painter->setPen( Plasma::Theme::defaultTheme()->color( Plasma::Theme::TextColor ) );
|
|
painter->setFont( font );
|
|
painter->drawText( iconX + iconWidth + 8, iconY, textWidth, textHeight, textOptions, s );
|
|
}
|
|
|
|
void TabBoxWindowItem::drawBackground( QPainter* painter, const QStyleOptionGraphicsItem* , QWidget* )
|
|
{
|
|
if( m_parent->itemsDrawBackgrounds() && m_client == m_parent->currentClient() )
|
|
{
|
|
m_parent->itemFrame()->paintFrame( painter, boundingRect() );
|
|
}
|
|
}
|
|
|
|
|
|
//*******************************
|
|
// TabBoxDesktopItem
|
|
//*******************************
|
|
|
|
TabBoxDesktopItem::TabBoxDesktopItem( int desktop, TabBox* parent )
|
|
: QGraphicsItem()
|
|
, m_desktop( desktop )
|
|
, m_parent( parent )
|
|
, m_width( 0 )
|
|
, m_height( 0 )
|
|
{
|
|
setCacheMode( DeviceCoordinateCache );
|
|
}
|
|
|
|
TabBoxDesktopItem::~TabBoxDesktopItem()
|
|
{
|
|
}
|
|
|
|
QRectF TabBoxDesktopItem::boundingRect() const
|
|
{
|
|
return QRectF( 0, 0, m_width, m_height );
|
|
}
|
|
|
|
void TabBoxDesktopItem::setHeight( int height )
|
|
{
|
|
m_height = height;
|
|
}
|
|
|
|
void TabBoxDesktopItem::setWidth( int width )
|
|
{
|
|
m_width = width;
|
|
}
|
|
|
|
int TabBoxDesktopItem::desktop() const
|
|
{
|
|
return m_desktop;
|
|
}
|
|
|
|
void TabBoxDesktopItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget )
|
|
{
|
|
painter->setRenderHint( QPainter::Antialiasing );
|
|
|
|
drawBackground( painter, option, widget );
|
|
|
|
int iconWidth = 32;
|
|
int iconHeight = iconWidth;
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
// get widest desktop name/number
|
|
QFont f = painter->font();
|
|
f.setBold(true);
|
|
f.setPixelSize(iconHeight - 4); // pixel, not point because I need to know the pixels
|
|
QFontMetrics fm = QFontMetrics( f );
|
|
|
|
QString num = QString::number( m_desktop );
|
|
iconWidth = qMax(iconWidth - 4, fm.boundingRect(num).width()) + 4;
|
|
|
|
// draw "icon" (here: number of desktop)
|
|
painter->save();
|
|
QBrush brush;
|
|
if( m_desktop == m_parent->currentDesktop() )
|
|
brush = m_parent->palette().brush( QPalette::Active, QPalette::Highlight );
|
|
else
|
|
brush = m_parent->palette().brush( QPalette::Active, QPalette::Base );
|
|
painter->fillRect(x+5, y+4, iconWidth, iconHeight, brush );
|
|
painter->setPen(m_parent->palette().color( QPalette::Active, QPalette::Text ));
|
|
painter->drawRect(x+5, y+4, iconWidth, iconHeight);
|
|
|
|
// draw desktop-number
|
|
painter->setFont(f);
|
|
painter->drawText(x+5, y+4, iconWidth, iconHeight, Qt::AlignCenter | Qt::AlignVCenter, num);
|
|
|
|
painter->restore();
|
|
|
|
// draw desktop name text
|
|
QFont font = painter->font();
|
|
font.setPointSize( KGlobalSettings::smallestReadableFont().pointSize() );
|
|
painter->setFont( font );
|
|
fm = QFontMetrics( font );
|
|
int wmax = fm.width( m_parent->workspace()->desktopName( m_desktop ));
|
|
|
|
painter->setPen( Plasma::Theme::defaultTheme()->color( Plasma::Theme::TextColor ) );
|
|
painter->drawText(x+5 + iconWidth + 8, y, m_width - 5 - iconWidth - 8, m_height - 4,
|
|
Qt::AlignLeft | Qt::AlignBottom | Qt::TextSingleLine,
|
|
m_parent->workspace()->desktopName( m_desktop ));
|
|
|
|
// show mini icons from that desktop aligned to each other
|
|
int x1 = x + 5 + iconWidth + 8 + wmax + 5;
|
|
|
|
ClientList list;
|
|
m_parent->createClientList(list, m_desktop, 0, false);
|
|
// clients are in reversed stacking order
|
|
for ( int i = list.size() - 1; i>=0; i-- )
|
|
{
|
|
if ( !list.at( i )->miniIcon().isNull() )
|
|
{
|
|
if ( x1+18 >= m_width ) // only show full icons
|
|
break;
|
|
|
|
painter->drawPixmap( x1, y + (m_height - 16)/2, list.at( i )->miniIcon() );
|
|
x1 += 18;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TabBoxDesktopItem::drawBackground( QPainter* painter, const QStyleOptionGraphicsItem*, QWidget* )
|
|
{
|
|
if( m_parent->itemsDrawBackgrounds() && m_desktop == m_parent->currentDesktop() )
|
|
{
|
|
m_parent->itemFrame()->paintFrame( painter, boundingRect() );
|
|
}
|
|
}
|
|
|
|
|
|
//*******************************
|
|
// Workspace
|
|
//*******************************
|
|
|
|
|
|
/*!
|
|
Handles alt-tab / control-tab
|
|
*/
|
|
|
|
static
|
|
bool areKeySymXsDepressed( bool bAll, const uint keySyms[], int nKeySyms )
|
|
{
|
|
char keymap[32];
|
|
|
|
kDebug(125) << "areKeySymXsDepressed: " << (bAll ? "all of " : "any of ") << nKeySyms;
|
|
|
|
XQueryKeymap( display(), keymap );
|
|
|
|
for( int iKeySym = 0; iKeySym < nKeySyms; iKeySym++ )
|
|
{
|
|
uint keySymX = keySyms[ iKeySym ];
|
|
uchar keyCodeX = XKeysymToKeycode( display(), keySymX );
|
|
int i = keyCodeX / 8;
|
|
char mask = 1 << (keyCodeX - (i * 8));
|
|
|
|
// Abort if bad index value,
|
|
if( i < 0 || i >= 32 )
|
|
return false;
|
|
|
|
kDebug(125) << iKeySym << ": keySymX=0x" << QString::number( keySymX, 16 )
|
|
<< " i=" << i << " mask=0x" << QString::number( mask, 16 )
|
|
<< " keymap[i]=0x" << QString::number( keymap[i], 16 ) << endl;
|
|
|
|
// If ALL keys passed need to be depressed,
|
|
if( bAll )
|
|
{
|
|
if( (keymap[i] & mask) == 0 )
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// If we are looking for ANY key press, and this key is depressed,
|
|
if( keymap[i] & mask )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// If we were looking for ANY key press, then none was found, return false,
|
|
// If we were looking for ALL key presses, then all were found, return true.
|
|
return bAll;
|
|
}
|
|
|
|
static bool areModKeysDepressed( const QKeySequence& seq )
|
|
{
|
|
uint rgKeySyms[10];
|
|
int nKeySyms = 0;
|
|
if( seq.isEmpty())
|
|
return false;
|
|
int mod = seq[seq.count()-1] & Qt::KeyboardModifierMask;
|
|
|
|
if ( mod & Qt::SHIFT )
|
|
{
|
|
rgKeySyms[nKeySyms++] = XK_Shift_L;
|
|
rgKeySyms[nKeySyms++] = XK_Shift_R;
|
|
}
|
|
if ( mod & Qt::CTRL )
|
|
{
|
|
rgKeySyms[nKeySyms++] = XK_Control_L;
|
|
rgKeySyms[nKeySyms++] = XK_Control_R;
|
|
}
|
|
if( mod & Qt::ALT )
|
|
{
|
|
rgKeySyms[nKeySyms++] = XK_Alt_L;
|
|
rgKeySyms[nKeySyms++] = XK_Alt_R;
|
|
}
|
|
if( mod & Qt::META )
|
|
{
|
|
// It would take some code to determine whether the Win key
|
|
// is associated with Super or Meta, so check for both.
|
|
// See bug #140023 for details.
|
|
rgKeySyms[nKeySyms++] = XK_Super_L;
|
|
rgKeySyms[nKeySyms++] = XK_Super_R;
|
|
rgKeySyms[nKeySyms++] = XK_Meta_L;
|
|
rgKeySyms[nKeySyms++] = XK_Meta_R;
|
|
}
|
|
|
|
return areKeySymXsDepressed( false, rgKeySyms, nKeySyms );
|
|
}
|
|
|
|
static bool areModKeysDepressed( const KShortcut& cut )
|
|
{
|
|
if( areModKeysDepressed( cut.primary()) || areModKeysDepressed( cut.alternate()) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void Workspace::slotWalkThroughWindows()
|
|
{
|
|
if ( tab_grab || control_grab )
|
|
return;
|
|
if ( options->altTabStyle == Options::CDE || !options->focusPolicyIsReasonable())
|
|
{
|
|
//ungrabXKeyboard(); // need that because of accelerator raw mode
|
|
// CDE style raise / lower
|
|
CDEWalkThroughWindows( true );
|
|
}
|
|
else
|
|
{
|
|
if ( areModKeysDepressed( cutWalkThroughWindows ) )
|
|
{
|
|
if ( startKDEWalkThroughWindows() )
|
|
KDEWalkThroughWindows( true );
|
|
}
|
|
else
|
|
// if the shortcut has no modifiers, don't show the tabbox,
|
|
// don't grab, but simply go to the next window
|
|
KDEOneStepThroughWindows( true );
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughWindows()
|
|
{
|
|
if( tab_grab || control_grab )
|
|
return;
|
|
if ( options->altTabStyle == Options::CDE || !options->focusPolicyIsReasonable())
|
|
{
|
|
// CDE style raise / lower
|
|
CDEWalkThroughWindows( false );
|
|
}
|
|
else
|
|
{
|
|
if ( areModKeysDepressed( cutWalkThroughWindowsReverse ) )
|
|
{
|
|
if ( startKDEWalkThroughWindows() )
|
|
KDEWalkThroughWindows( false );
|
|
}
|
|
else
|
|
{
|
|
KDEOneStepThroughWindows( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkThroughDesktops()
|
|
{
|
|
if( tab_grab || control_grab )
|
|
return;
|
|
if ( areModKeysDepressed( cutWalkThroughDesktops ) )
|
|
{
|
|
if ( startWalkThroughDesktops() )
|
|
walkThroughDesktops( true );
|
|
}
|
|
else
|
|
{
|
|
oneStepThroughDesktops( true );
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughDesktops()
|
|
{
|
|
if( tab_grab || control_grab )
|
|
return;
|
|
if ( areModKeysDepressed( cutWalkThroughDesktopsReverse ) )
|
|
{
|
|
if ( startWalkThroughDesktops() )
|
|
walkThroughDesktops( false );
|
|
}
|
|
else
|
|
{
|
|
oneStepThroughDesktops( false );
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkThroughDesktopList()
|
|
{
|
|
if( tab_grab || control_grab )
|
|
return;
|
|
if ( areModKeysDepressed( cutWalkThroughDesktopList ) )
|
|
{
|
|
if ( startWalkThroughDesktopList() )
|
|
walkThroughDesktops( true );
|
|
}
|
|
else
|
|
{
|
|
oneStepThroughDesktopList( true );
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughDesktopList()
|
|
{
|
|
if( tab_grab || control_grab )
|
|
return;
|
|
if ( areModKeysDepressed( cutWalkThroughDesktopListReverse ) )
|
|
{
|
|
if ( startWalkThroughDesktopList() )
|
|
walkThroughDesktops( false );
|
|
}
|
|
else
|
|
{
|
|
oneStepThroughDesktopList( false );
|
|
}
|
|
}
|
|
|
|
void Workspace::slotWalkThroughDesktopsKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughDesktops = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughDesktopsKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughDesktopsReverse = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::slotWalkThroughDesktopListKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughDesktopList = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughDesktopListKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughDesktopListReverse = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::slotWalkThroughWindowsKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughWindows = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::slotWalkBackThroughWindowsKeyChanged( const QKeySequence& seq )
|
|
{
|
|
cutWalkThroughWindowsReverse = KShortcut( seq );
|
|
}
|
|
|
|
void Workspace::modalActionsSwitch( bool enabled )
|
|
{
|
|
QList<KActionCollection*> collections;
|
|
collections.append( keys );
|
|
collections.append( disable_shortcuts_keys );
|
|
collections.append( client_keys );
|
|
foreach (KActionCollection* collection, collections)
|
|
foreach (QAction *action, collection->actions())
|
|
action->setEnabled(enabled);
|
|
}
|
|
|
|
bool Workspace::startKDEWalkThroughWindows()
|
|
{
|
|
if( !establishTabBoxGrab())
|
|
return false;
|
|
tab_grab = true;
|
|
modalActionsSwitch( false );
|
|
tab_box->setMode( TabBoxWindowsMode );
|
|
tab_box->reset();
|
|
tab_box->initScene();
|
|
return true;
|
|
}
|
|
|
|
bool Workspace::startWalkThroughDesktops( TabBoxMode mode )
|
|
{
|
|
if( !establishTabBoxGrab())
|
|
return false;
|
|
control_grab = true;
|
|
modalActionsSwitch( false );
|
|
tab_box->setMode( mode );
|
|
tab_box->reset();
|
|
tab_box->initScene();
|
|
return true;
|
|
}
|
|
|
|
bool Workspace::startWalkThroughDesktops()
|
|
{
|
|
return startWalkThroughDesktops( TabBoxDesktopMode );
|
|
}
|
|
|
|
bool Workspace::startWalkThroughDesktopList()
|
|
{
|
|
return startWalkThroughDesktops( TabBoxDesktopListMode );
|
|
}
|
|
|
|
void Workspace::KDEWalkThroughWindows( bool forward )
|
|
{
|
|
tab_box->nextPrev( forward );
|
|
tab_box->delayedShow();
|
|
}
|
|
|
|
void Workspace::walkThroughDesktops( bool forward )
|
|
{
|
|
tab_box->nextPrev( forward );
|
|
tab_box->delayedShow();
|
|
}
|
|
|
|
void Workspace::CDEWalkThroughWindows( bool forward )
|
|
{
|
|
Client* c = NULL;
|
|
// this function find the first suitable client for unreasonable focus
|
|
// policies - the topmost one, with some exceptions (can't be keepabove/below,
|
|
// otherwise it gets stuck on them)
|
|
Q_ASSERT( block_stacking_updates == 0 );
|
|
for( int i = stacking_order.size() - 1;
|
|
i >= 0 ;
|
|
--i )
|
|
{
|
|
Client* it = stacking_order.at( i );
|
|
if ( it->isOnCurrentDesktop() && !it->isSpecialWindow()
|
|
&& it->isShown( false ) && it->wantsTabFocus()
|
|
&& !it->keepAbove() && !it->keepBelow())
|
|
{
|
|
c = it;
|
|
break;
|
|
}
|
|
}
|
|
Client* nc = c;
|
|
bool options_traverse_all;
|
|
{
|
|
KConfigGroup group( KGlobal::config(), "TabBox" );
|
|
options_traverse_all = group.readEntry("TraverseAll", false );
|
|
}
|
|
|
|
Client* firstClient = 0;
|
|
do
|
|
{
|
|
nc = forward ? nextClientStatic(nc) : previousClientStatic(nc);
|
|
if (!firstClient)
|
|
{
|
|
// When we see our first client for the second time,
|
|
// it's time to stop.
|
|
firstClient = nc;
|
|
}
|
|
else if (nc == firstClient)
|
|
{
|
|
// No candidates found.
|
|
nc = 0;
|
|
break;
|
|
}
|
|
} while (nc && nc != c &&
|
|
(( !options_traverse_all && !nc->isOnDesktop(currentDesktop())) ||
|
|
nc->isMinimized() || !nc->wantsTabFocus() || nc->keepAbove() || nc->keepBelow() ) );
|
|
if (nc)
|
|
{
|
|
if (c && c != nc)
|
|
lowerClient( c );
|
|
if ( options->focusPolicyIsReasonable() )
|
|
{
|
|
activateClient( nc );
|
|
if( nc->isShade() && options->shadeHover )
|
|
nc->setShade( ShadeActivated );
|
|
}
|
|
else
|
|
{
|
|
if( !nc->isOnDesktop( currentDesktop()))
|
|
setCurrentDesktop( nc->desktop());
|
|
raiseClient( nc );
|
|
}
|
|
}
|
|
}
|
|
|
|
void Workspace::KDEOneStepThroughWindows( bool forward )
|
|
{
|
|
tab_box->setMode( TabBoxWindowsMode );
|
|
tab_box->reset();
|
|
tab_box->nextPrev( forward );
|
|
if( Client* c = tab_box->currentClient() )
|
|
{
|
|
activateClient( c );
|
|
if( c->isShade() && options->shadeHover )
|
|
c->setShade( ShadeActivated );
|
|
}
|
|
}
|
|
|
|
void Workspace::oneStepThroughDesktops( bool forward, TabBoxMode mode )
|
|
{
|
|
tab_box->setMode( mode );
|
|
tab_box->reset();
|
|
tab_box->nextPrev( forward );
|
|
if ( tab_box->currentDesktop() != -1 )
|
|
setCurrentDesktop( tab_box->currentDesktop() );
|
|
}
|
|
|
|
void Workspace::oneStepThroughDesktops( bool forward )
|
|
{
|
|
oneStepThroughDesktops( forward, TabBoxDesktopMode );
|
|
}
|
|
|
|
void Workspace::oneStepThroughDesktopList( bool forward )
|
|
{
|
|
oneStepThroughDesktops( forward, TabBoxDesktopListMode );
|
|
}
|
|
|
|
/*!
|
|
Handles holding alt-tab / control-tab
|
|
*/
|
|
void Workspace::tabBoxKeyPress( int keyQt )
|
|
{
|
|
bool forward = false;
|
|
bool backward = false;
|
|
|
|
if (tab_grab)
|
|
{
|
|
forward = cutWalkThroughWindows.contains( keyQt );
|
|
backward = cutWalkThroughWindowsReverse.contains( keyQt );
|
|
if (forward || backward)
|
|
{
|
|
kDebug(125) << "== " << cutWalkThroughWindows.toString()
|
|
<< " or " << cutWalkThroughWindowsReverse.toString() << endl;
|
|
KDEWalkThroughWindows( forward );
|
|
}
|
|
}
|
|
else if (control_grab)
|
|
{
|
|
forward = cutWalkThroughDesktops.contains( keyQt ) ||
|
|
cutWalkThroughDesktopList.contains( keyQt );
|
|
backward = cutWalkThroughDesktopsReverse.contains( keyQt ) ||
|
|
cutWalkThroughDesktopListReverse.contains( keyQt );
|
|
if (forward || backward)
|
|
walkThroughDesktops(forward);
|
|
}
|
|
|
|
if (control_grab || tab_grab)
|
|
{
|
|
if ( ((keyQt & ~Qt::KeyboardModifierMask) == Qt::Key_Escape)
|
|
&& !(forward || backward) )
|
|
{ // if Escape is part of the shortcut, don't cancel
|
|
closeTabBox();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Workspace::refTabBox()
|
|
{
|
|
if( tab_box )
|
|
tab_box->refDisplay();
|
|
}
|
|
|
|
void Workspace::unrefTabBox()
|
|
{
|
|
if( tab_box )
|
|
tab_box->unrefDisplay();
|
|
}
|
|
|
|
void Workspace::closeTabBox()
|
|
{
|
|
removeTabBoxGrab();
|
|
tab_box->hide();
|
|
modalActionsSwitch( true );
|
|
tab_grab = false;
|
|
control_grab = false;
|
|
}
|
|
|
|
/*!
|
|
Handles alt-tab / control-tab releasing
|
|
*/
|
|
void Workspace::tabBoxKeyRelease( const XKeyEvent& ev )
|
|
{
|
|
unsigned int mk = ev.state &
|
|
(KKeyServer::modXShift() |
|
|
KKeyServer::modXCtrl() |
|
|
KKeyServer::modXAlt() |
|
|
KKeyServer::modXMeta() );
|
|
// ev.state is state before the key release, so just checking mk being 0 isn't enough
|
|
// using XQueryPointer() also doesn't seem to work well, so the check that all
|
|
// modifiers are released: only one modifier is active and the currently released
|
|
// key is this modifier - if yes, release the grab
|
|
int mod_index = -1;
|
|
for( int i = ShiftMapIndex;
|
|
i <= Mod5MapIndex;
|
|
++i )
|
|
if(( mk & ( 1 << i )) != 0 )
|
|
{
|
|
if( mod_index >= 0 )
|
|
return;
|
|
mod_index = i;
|
|
}
|
|
bool release = false;
|
|
if( mod_index == -1 )
|
|
release = true;
|
|
else
|
|
{
|
|
XModifierKeymap* xmk = XGetModifierMapping(display());
|
|
for (int i=0; i<xmk->max_keypermod; i++)
|
|
if (xmk->modifiermap[xmk->max_keypermod * mod_index + i]
|
|
== ev.keycode)
|
|
release = true;
|
|
XFreeModifiermap(xmk);
|
|
}
|
|
if( !release )
|
|
return;
|
|
if (tab_grab)
|
|
{
|
|
bool old_control_grab = control_grab;
|
|
closeTabBox();
|
|
control_grab = old_control_grab;
|
|
if( Client* c = tab_box->currentClient())
|
|
{
|
|
activateClient( c );
|
|
if( c->isShade() && options->shadeHover )
|
|
c->setShade( ShadeActivated );
|
|
}
|
|
}
|
|
if (control_grab)
|
|
{
|
|
bool old_tab_grab = tab_grab;
|
|
closeTabBox();
|
|
tab_grab = old_tab_grab;
|
|
if ( tab_box->currentDesktop() != -1 )
|
|
{
|
|
setCurrentDesktop( tab_box->currentDesktop() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int Workspace::nextDesktopFocusChain( int iDesktop ) const
|
|
{
|
|
int i = desktop_focus_chain.indexOf( iDesktop );
|
|
if( i >= 0 && i+1 < (int)desktop_focus_chain.size() )
|
|
return desktop_focus_chain[i+1];
|
|
else if( desktop_focus_chain.size() > 0 )
|
|
return desktop_focus_chain[ 0 ];
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
int Workspace::previousDesktopFocusChain( int iDesktop ) const
|
|
{
|
|
int i = desktop_focus_chain.indexOf( iDesktop );
|
|
if( i-1 >= 0 )
|
|
return desktop_focus_chain[i-1];
|
|
else if( desktop_focus_chain.size() > 0 )
|
|
return desktop_focus_chain[desktop_focus_chain.size()-1];
|
|
else
|
|
return numberOfDesktops();
|
|
}
|
|
|
|
int Workspace::nextDesktopStatic( int iDesktop ) const
|
|
{
|
|
int i = ++iDesktop;
|
|
if( i > numberOfDesktops())
|
|
i = 1;
|
|
return i;
|
|
}
|
|
|
|
int Workspace::previousDesktopStatic( int iDesktop ) const
|
|
{
|
|
int i = --iDesktop;
|
|
if( i < 1 )
|
|
i = numberOfDesktops();
|
|
return i;
|
|
}
|
|
|
|
/*!
|
|
auxiliary functions to travers all clients according to the focus
|
|
order. Useful for kwms Alt-tab feature.
|
|
*/
|
|
Client* Workspace::nextClientFocusChain( Client* c ) const
|
|
{
|
|
if ( global_focus_chain.isEmpty() )
|
|
return 0;
|
|
int pos = global_focus_chain.indexOf( c );
|
|
if ( pos == -1 )
|
|
return global_focus_chain.last();
|
|
if ( pos == 0 )
|
|
return global_focus_chain.last();
|
|
pos--;
|
|
return global_focus_chain[ pos ];
|
|
}
|
|
|
|
/*!
|
|
auxiliary functions to travers all clients according to the focus
|
|
order. Useful for kwms Alt-tab feature.
|
|
*/
|
|
Client* Workspace::previousClientFocusChain( Client* c ) const
|
|
{
|
|
if ( global_focus_chain.isEmpty() )
|
|
return 0;
|
|
int pos = global_focus_chain.indexOf( c );
|
|
if ( pos == -1 )
|
|
return global_focus_chain.first();
|
|
pos++;
|
|
if ( pos == global_focus_chain.count() )
|
|
return global_focus_chain.first();
|
|
return global_focus_chain[ pos ];
|
|
}
|
|
|
|
/*!
|
|
auxiliary functions to travers all clients according to the static
|
|
order. Useful for the CDE-style Alt-tab feature.
|
|
*/
|
|
Client* Workspace::nextClientStatic( Client* c ) const
|
|
{
|
|
if ( !c || clients.isEmpty() )
|
|
return 0;
|
|
int pos = clients.indexOf( c );
|
|
if ( pos == -1 )
|
|
return clients.first();
|
|
++pos;
|
|
if ( pos == clients.count() )
|
|
return clients.first();
|
|
return clients[ pos ];
|
|
}
|
|
/*!
|
|
auxiliary functions to travers all clients according to the static
|
|
order. Useful for the CDE-style Alt-tab feature.
|
|
*/
|
|
Client* Workspace::previousClientStatic( Client* c ) const
|
|
{
|
|
if ( !c || clients.isEmpty() )
|
|
return 0;
|
|
int pos = clients.indexOf( c );
|
|
if ( pos == -1 )
|
|
return clients.last();
|
|
if ( pos == 0 )
|
|
return clients.last();
|
|
--pos;
|
|
return clients[ pos ];
|
|
}
|
|
|
|
Client* Workspace::currentTabBoxClient() const
|
|
{
|
|
if( !tab_box )
|
|
return 0;
|
|
return tab_box->currentClient();
|
|
}
|
|
|
|
ClientList Workspace::currentTabBoxClientList() const
|
|
{
|
|
if( !tab_box )
|
|
return ClientList();
|
|
return tab_box->currentClientList();
|
|
}
|
|
|
|
int Workspace::currentTabBoxDesktop() const
|
|
{
|
|
if( !tab_box )
|
|
return -1;
|
|
return tab_box->currentDesktop();
|
|
}
|
|
|
|
QList< int > Workspace::currentTabBoxDesktopList() const
|
|
{
|
|
if( !tab_box )
|
|
return QList< int >();
|
|
return tab_box->currentDesktopList();
|
|
}
|
|
|
|
void Workspace::setTabBoxClient( Client* c )
|
|
{
|
|
if( tab_box )
|
|
tab_box->setCurrentClient( c );
|
|
}
|
|
|
|
void Workspace::setTabBoxDesktop( int iDesktop )
|
|
{
|
|
if( tab_box )
|
|
tab_box->setCurrentDesktop( iDesktop );
|
|
}
|
|
|
|
bool Workspace::establishTabBoxGrab()
|
|
{
|
|
if( !grabXKeyboard())
|
|
return false;
|
|
// Don't try to establish a global mouse grab using XGrabPointer, as that would prevent
|
|
// using Alt+Tab while DND (#44972). However force passive grabs on all windows
|
|
// in order to catch MouseRelease events and close the tabbox (#67416).
|
|
// All clients already have passive grabs in their wrapper windows, so check only
|
|
// the active client, which may not have it.
|
|
assert( !forced_global_mouse_grab );
|
|
forced_global_mouse_grab = true;
|
|
if( active_client != NULL )
|
|
active_client->updateMouseGrab();
|
|
return true;
|
|
}
|
|
|
|
void Workspace::removeTabBoxGrab()
|
|
{
|
|
ungrabXKeyboard();
|
|
assert( forced_global_mouse_grab );
|
|
forced_global_mouse_grab = false;
|
|
if( active_client != NULL )
|
|
active_client->updateMouseGrab();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
#include "tabbox.moc"
|