summaryrefslogtreecommitdiffstats
path: root/twin/tabbox.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'twin/tabbox.cpp')
-rw-r--r--twin/tabbox.cpp1389
1 files changed, 1389 insertions, 0 deletions
diff --git a/twin/tabbox.cpp b/twin/tabbox.cpp
new file mode 100644
index 000000000..505af7abc
--- /dev/null
+++ b/twin/tabbox.cpp
@@ -0,0 +1,1389 @@
+/*****************************************************************
+ 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>
+
+You can Freely distribute this program under the GNU General Public
+License. See the file "COPYING" for the exact licensing terms.
+******************************************************************/
+
+//#define QT_CLEAN_NAMESPACE
+#include "tabbox.h"
+#include "workspace.h"
+#include "client.h"
+#include <tqpainter.h>
+#include <tqlabel.h>
+#include <tqdrawutil.h>
+#include <tqstyle.h>
+#include <tdeglobal.h>
+#include <fixx11h.h>
+#include <tdeconfig.h>
+#include <tdelocale.h>
+#include <tqapplication.h>
+#include <tqdesktopwidget.h>
+#include <kstringhandler.h>
+#include <stdarg.h>
+#include <kdebug.h>
+#include <kglobalaccel.h>
+#include <kkeynative.h>
+#include <tdeglobalsettings.h>
+#include <kiconeffect.h>
+#include <X11/keysym.h>
+#include <X11/keysymdef.h>
+
+// specify externals before namespace
+
+namespace KWinInternal
+{
+
+extern TQPixmap* twin_get_menu_pix_hack();
+
+TabBox::TabBox( Workspace *ws, const char *name )
+ : TQFrame( 0, name, TQt::WNoAutoErase ), current_client( NULL ), wspace(ws)
+ {
+ setFrameStyle(TQFrame::StyledPanel | TQFrame::Plain);
+ setLineWidth(2);
+ setMargin(2);
+
+ appsOnly = false;
+ showMiniIcon = false;
+
+ no_tasks = i18n("*** No Windows ***");
+ m = DesktopMode; // init variables
+ reconfigure();
+ reset();
+ connect(&delayedShowTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(show()));
+
+ XSetWindowAttributes attr;
+ attr.override_redirect = 1;
+ outline_left = XCreateWindow( tqt_xdisplay(), tqt_xrootwin(), 0, 0, 1, 1, 0,
+ CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
+ outline_right = XCreateWindow( tqt_xdisplay(), tqt_xrootwin(), 0, 0, 1, 1, 0,
+ CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
+ outline_top = XCreateWindow( tqt_xdisplay(), tqt_xrootwin(), 0, 0, 1, 1, 0,
+ CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
+ outline_bottom = XCreateWindow( tqt_xdisplay(), tqt_xrootwin(), 0, 0, 1, 1, 0,
+ CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect, &attr );
+ }
+
+TabBox::~TabBox()
+ {
+ XDestroyWindow( tqt_xdisplay(), outline_left );
+ XDestroyWindow( tqt_xdisplay(), outline_right );
+ XDestroyWindow( tqt_xdisplay(), outline_top );
+ XDestroyWindow( tqt_xdisplay(), outline_bottom );
+ }
+
+
+/*!
+ Sets the current mode to \a mode, either DesktopListMode or WindowsMode
+
+ \sa mode()
+ */
+void TabBox::setMode( Mode mode )
+ {
+ m = mode;
+ }
+
+/*!
+ Sets AppsOnly, which when true, createClientList will return only applications within the same class
+
+ */
+void TabBox::setAppsOnly( bool a )
+ {
+ appsOnly = a;
+ }
+
+/*!
+ 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;
+ TQString startClass;
+ list.clear();
+
+ Client* start = c;
+
+ if( start )
+ startClass = start->resourceClass();
+
+ if ( chain )
+ c = workspace()->nextFocusChainClient(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(appsOnly && (TQString::compare( startClass, c->resourceClass()) != 0))
+ {
+ add = NULL;
+ }
+
+ if( options->separateScreenFocus && options->xineramaEnabled )
+ {
+ if( c->screen() != workspace()->activeScreen())
+ add = NULL;
+ }
+
+ if( add != NULL )
+ {
+ if ( start == add )
+ {
+ list.remove( add );
+ list.prepend( add );
+ }
+ else
+ list += add;
+ }
+
+ if ( chain )
+ c = workspace()->nextFocusChainClient( c );
+ else
+ {
+ if ( idx >= (workspace()->stackingOrder().size()-1) )
+ c = 0;
+ else
+ c = workspace()->stackingOrder()[++idx];
+ }
+
+ if ( c == stop )
+ break;
+ }
+ }
+
+
+/*!
+ Resets the tab box to display the active client in WindowsMode, or the
+ current desktop in DesktopListMode
+ */
+void TabBox::reset()
+ {
+ int w, h, cw = 0, wmax = 0;
+
+ TQRect r = workspace()->screenGeometry( workspace()->activeScreen());
+
+ // calculate height of 1 line
+ // fontheight + 1 pixel above + 1 pixel below, or 32x32 icon + 2 pixel above + below
+ lineHeight = TQMAX(fontMetrics().height() + 2, 32 + 4);
+
+ if ( mode() == WindowsMode )
+ {
+ setCurrentClient( workspace()->activeClient());
+
+ // get all clients to show
+ createClientList(clients, options_traverse_all ? -1 : workspace()->currentDesktop(), current_client, true);
+
+ // calculate maximum caption width
+ cw = fontMetrics().width(no_tasks)+20;
+ for (ClientList::ConstIterator it = clients.begin(); it != clients.end(); ++it)
+ {
+ cw = fontMetrics().width( (*it)->caption() );
+ if ( cw > wmax ) wmax = cw;
+ }
+
+ // calculate height for the popup
+ if ( clients.count() == 0 ) // height for the "not tasks" text
+ {
+ TQFont f = font();
+ f.setBold( TRUE );
+ f.setPointSize( 14 );
+
+ h = TQFontMetrics(f).height()*4;
+ }
+ else
+ {
+ showMiniIcon = false;
+ h = clients.count() * lineHeight;
+
+ if ( h > (r.height()-(2*frameWidth())) ) // if too high, use mini icons
+ {
+ showMiniIcon = true;
+ // fontheight + 1 pixel above + 1 pixel below, or 16x16 icon + 1 pixel above + below
+ lineHeight = TQMAX(fontMetrics().height() + 2, 16 + 2);
+
+ h = clients.count() * lineHeight;
+
+ if ( h > (r.height()-(2*frameWidth())) ) // if still too high, remove some clients
+ {
+ // how many clients to remove
+ int howMany = (h - (r.height()-(2*frameWidth())))/lineHeight;
+ for (; howMany; howMany--)
+ clients.remove(clients.last());
+
+ h = clients.count() * lineHeight;
+ }
+ }
+ }
+ }
+ else
+ { // DesktopListMode
+ showMiniIcon = false;
+ desk = workspace()->currentDesktop();
+
+ for ( int i = 1; i <= workspace()->numberOfDesktops(); i++ )
+ {
+ cw = fontMetrics().width( workspace()->desktopName(i) );
+ if ( cw > wmax ) wmax = cw;
+ }
+
+ // calculate height for the popup (max. 16 desktops always fit in a 800x600 screen)
+ h = workspace()->numberOfDesktops() * lineHeight;
+ }
+
+ // height, width for the popup
+ h += 2 * frameWidth();
+ w = 2*frameWidth() + 5*2 + ( showMiniIcon ? 16 : 32 ) + 8 + wmax; // 5*2=margins, ()=icon, 8=space between icon+text
+ w = kClamp( w, r.width()/3 , r.width() * 4 / 5 );
+
+ setGeometry( (r.width()-w)/2 + r.x(),
+ (r.height()-h)/2+ r.y(),
+ w, h );
+ }
+
+
+/*!
+ Shows the next or previous item, depending on \a next
+ */
+void TabBox::nextPrev( bool next)
+ {
+ if ( mode() == WindowsMode )
+ {
+ Client* firstClient = NULL;
+ Client* client = current_client;
+ do
+ {
+ if ( next )
+ client = workspace()->nextFocusChainClient(client);
+ else
+ client = workspace()->previousFocusChainClient(client);
+ if (!firstClient)
+ {
+ // When we see our first client for the second time,
+ // it's time to stop.
+ firstClient = client;
+ }
+ else if (client == firstClient)
+ {
+ // No candidates found.
+ client = 0;
+ break;
+ }
+ } while ( client && !clients.contains( client ));
+ setCurrentClient( client );
+ }
+ else if( mode() == DesktopMode )
+ {
+ if ( next )
+ desk = workspace()->nextDesktopFocusChain( desk );
+ else
+ desk = workspace()->previousDesktopFocusChain( desk );
+ }
+ else
+ { // DesktopListMode
+ if ( next )
+ {
+ desk++;
+ if ( desk > workspace()->numberOfDesktops() )
+ desk = 1;
+ }
+ else
+ {
+ desk--;
+ if ( desk < 1 )
+ desk = workspace()->numberOfDesktops();
+ }
+ }
+
+ update();
+ }
+
+
+
+/*!
+ Returns the currently displayed client ( only works in WindowsMode ).
+ Returns 0 if no client is displayed.
+ */
+Client* TabBox::currentClient()
+ {
+ if ( mode() != WindowsMode )
+ return 0;
+ if (!workspace()->hasClient( current_client ))
+ return 0;
+ return current_client;
+ }
+
+void TabBox::setCurrentClient( Client* c )
+ {
+ if( current_client != c )
+ {
+ current_client = c;
+ updateOutline();
+ }
+ }
+
+/*!
+ Returns the currently displayed virtual desktop ( only works in
+ DesktopListMode )
+ Returns -1 if no desktop is displayed.
+ */
+int TabBox::currentDesktop()
+ {
+ if ( mode() == DesktopListMode || mode() == DesktopMode )
+ return desk;
+ else
+ return -1;
+ }
+
+
+/*!
+ Reimplemented to raise the tab box as well
+ */
+void TabBox::showEvent( TQShowEvent* )
+ {
+ updateOutline();
+ XRaiseWindow( tqt_xdisplay(), outline_left );
+ XRaiseWindow( tqt_xdisplay(), outline_right );
+ XRaiseWindow( tqt_xdisplay(), outline_top );
+ XRaiseWindow( tqt_xdisplay(), outline_bottom );
+ raise();
+ }
+
+
+/*!
+ hide the icon box if necessary
+ */
+void TabBox::hideEvent( TQHideEvent* )
+ {
+ XUnmapWindow( tqt_xdisplay(), outline_left );
+ XUnmapWindow( tqt_xdisplay(), outline_right );
+ XUnmapWindow( tqt_xdisplay(), outline_top );
+ XUnmapWindow( tqt_xdisplay(), outline_bottom );
+ }
+
+/*!
+ Paints the tab box
+ */
+void TabBox::drawContents( TQPainter * )
+ {
+ TQRect r(contentsRect());
+ TQPixmap pix(r.size()); // do double buffering to avoid flickers
+ pix.fill(this, 0, 0);
+
+ TQPainter p;
+ p.begin(&pix, this);
+
+ TQPixmap* menu_pix = twin_get_menu_pix_hack();
+
+ int iconWidth = showMiniIcon ? 16 : 32;
+ int x = 0;
+ int y = 0;
+
+ if ( mode () == WindowsMode )
+ {
+ if ( !currentClient() )
+ {
+ TQFont f = font();
+ f.setBold( TRUE );
+ f.setPointSize( 14 );
+
+ p.setFont(f);
+ p.drawText( r, AlignCenter, no_tasks);
+ }
+ else
+ {
+ for (ClientList::ConstIterator it = clients.begin(); it != clients.end(); ++it)
+ {
+ if ( workspace()->hasClient( *it ) ) // safety
+ {
+ // draw highlight background
+ if ( (*it) == current_client )
+ p.fillRect(x, y, r.width(), lineHeight, colorGroup().highlight());
+
+ // draw icon
+ TQPixmap icon;
+ if ( showMiniIcon )
+ {
+ if ( !(*it)->miniIcon().isNull() )
+ icon = (*it)->miniIcon();
+ }
+ else
+ if ( !(*it)->icon().isNull() )
+ icon = (*it)->icon();
+ else if ( menu_pix )
+ icon = *menu_pix;
+
+ if( !icon.isNull())
+ {
+ if( (*it)->isMinimized())
+ TDEIconEffect::semiTransparent( icon );
+ p.drawPixmap( x+5, y + (lineHeight - iconWidth)/2, icon );
+ }
+
+ // generate text to display
+ TQString s;
+
+ if ( !(*it)->isOnDesktop(workspace()->currentDesktop()) )
+ s = workspace()->desktopName((*it)->desktop()) + ": ";
+
+ if ( (*it)->isMinimized() )
+ s += TQString("(") + (*it)->caption() + ")";
+ else
+ s += (*it)->caption();
+
+ s = KStringHandler::cPixelSqueeze(s, fontMetrics(), r.width() - 5 - iconWidth - 8);
+
+ // draw text
+ if ( (*it) == current_client )
+ p.setPen(colorGroup().highlightedText());
+ else if( (*it)->isMinimized())
+ {
+ TQColor c1 = colorGroup().text();
+ TQColor c2 = colorGroup().background();
+ // from kicker's TaskContainer::blendColors()
+ int r1, g1, b1;
+ int r2, g2, b2;
+
+ c1.rgb( &r1, &g1, &b1 );
+ c2.rgb( &r2, &g2, &b2 );
+
+ r1 += (int) ( .5 * ( r2 - r1 ) );
+ g1 += (int) ( .5 * ( g2 - g1 ) );
+ b1 += (int) ( .5 * ( b2 - b1 ) );
+
+ p.setPen(TQColor( r1, g1, b1 ));
+ }
+ else
+ p.setPen(colorGroup().text());
+
+ p.drawText(x+5 + iconWidth + 8, y, r.width() - 5 - iconWidth - 8, lineHeight,
+ Qt::AlignLeft | Qt::AlignVCenter | TQt::SingleLine, s);
+
+ y += lineHeight;
+ }
+ if ( y >= r.height() ) break;
+ }
+ }
+ }
+ else
+ { // DesktopMode || DesktopListMode
+ int iconHeight = iconWidth;
+
+ // get widest desktop name/number
+ TQFont f(font());
+ f.setBold(true);
+ f.setPixelSize(iconHeight - 4); // pixel, not point because I need to know the pixels
+ TQFontMetrics fm(f);
+
+ int wmax = 0;
+ for ( int i = 1; i <= workspace()->numberOfDesktops(); i++ )
+ {
+ wmax = TQMAX(wmax, fontMetrics().width(workspace()->desktopName(i)));
+
+ // calculate max width of desktop-number text
+ TQString num = TQString::number(i);
+ iconWidth = TQMAX(iconWidth - 4, fm.boundingRect(num).width()) + 4;
+ }
+
+ // In DesktopMode, start at the current desktop
+ // In DesktopListMode, start at desktop #1
+ int iDesktop = (mode() == DesktopMode) ? workspace()->currentDesktop() : 1;
+ for ( int i = 1; i <= workspace()->numberOfDesktops(); i++ )
+ {
+ // draw highlight background
+ if ( iDesktop == desk ) // current desktop
+ p.fillRect(x, y, r.width(), lineHeight, colorGroup().highlight());
+
+ p.save();
+
+ // draw "icon" (here: number of desktop)
+ p.fillRect(x+5, y+2, iconWidth, iconHeight, colorGroup().base());
+ p.setPen(colorGroup().text());
+ p.drawRect(x+5, y+2, iconWidth, iconHeight);
+
+ // draw desktop-number
+ p.setFont(f);
+ TQString num = TQString::number(iDesktop);
+ p.drawText(x+5, y+2, iconWidth, iconHeight, Qt::AlignCenter, num);
+
+ p.restore();
+
+ // draw desktop name text
+ if ( iDesktop == desk )
+ p.setPen(colorGroup().highlightedText());
+ else
+ p.setPen(colorGroup().text());
+
+ p.drawText(x+5 + iconWidth + 8, y, r.width() - 5 - iconWidth - 8, lineHeight,
+ Qt::AlignLeft | Qt::AlignVCenter | TQt::SingleLine,
+ workspace()->desktopName(iDesktop));
+
+ // show mini icons from that desktop aligned to each other
+ int x1 = x + 5 + iconWidth + 8 + wmax + 5;
+
+ ClientList list;
+ createClientList(list, iDesktop, 0, false);
+ // clients are in reversed stacking order
+ for (ClientList::ConstIterator it = list.fromLast(); it != list.end(); --it)
+ {
+ if ( !(*it)->miniIcon().isNull() )
+ {
+ if ( x1+18 >= x+r.width() ) // only show full icons
+ break;
+
+ p.drawPixmap( x1, y + (lineHeight - 16)/2, (*it)->miniIcon() );
+ x1 += 18;
+ }
+ }
+
+ // next desktop
+ y += lineHeight;
+ if ( y >= r.height() ) break;
+
+ if( mode() == DesktopMode )
+ iDesktop = workspace()->nextDesktopFocusChain( iDesktop );
+ else
+ iDesktop++;
+ }
+ }
+ p.end();
+ bitBlt(this, r.x(), r.y(), &pix);
+ }
+
+void TabBox::updateOutline()
+ {
+ Client* c = currentClient();
+ if( !options->tabboxOutline || c == NULL || this->isHidden() || !c->isShown( true ) || !c->isOnCurrentDesktop())
+ {
+ XUnmapWindow( tqt_xdisplay(), outline_left );
+ XUnmapWindow( tqt_xdisplay(), outline_right );
+ XUnmapWindow( tqt_xdisplay(), outline_top );
+ XUnmapWindow( tqt_xdisplay(), outline_bottom );
+ return;
+ }
+ // left/right parts are between top/bottom, they don't reach as far as the corners
+ XMoveResizeWindow( tqt_xdisplay(), outline_left, c->x(), c->y() + 5, 5, c->height() - 10 );
+ XMoveResizeWindow( tqt_xdisplay(), outline_right, c->x() + c->width() - 5, c->y() + 5, 5, c->height() - 10 );
+ XMoveResizeWindow( tqt_xdisplay(), outline_top, c->x(), c->y(), c->width(), 5 );
+ XMoveResizeWindow( tqt_xdisplay(), outline_bottom, c->x(), c->y() + c->height() - 5, c->width(), 5 );
+ {
+ TQPixmap pix( 5, c->height() - 10 );
+ TQPainter p( &pix );
+ p.setPen( white );
+ p.drawLine( 0, 0, 0, pix.height() - 1 );
+ p.drawLine( 4, 0, 4, pix.height() - 1 );
+ p.setPen( gray );
+ p.drawLine( 1, 0, 1, pix.height() - 1 );
+ p.drawLine( 3, 0, 3, pix.height() - 1 );
+ p.setPen( black );
+ p.drawLine( 2, 0, 2, pix.height() - 1 );
+ p.end();
+ XSetWindowBackgroundPixmap( tqt_xdisplay(), outline_left, pix.handle());
+ XSetWindowBackgroundPixmap( tqt_xdisplay(), outline_right, pix.handle());
+ }
+ {
+ TQPixmap pix( c->width(), 5 );
+ TQPainter p( &pix );
+ p.setPen( 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( 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( 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( tqt_xdisplay(), outline_top, pix.handle());
+ }
+ {
+ TQPixmap pix( c->width(), 5 );
+ TQPainter p( &pix );
+ p.setPen( 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( 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( 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( tqt_xdisplay(), outline_bottom, pix.handle());
+ }
+ XClearWindow( tqt_xdisplay(), outline_left );
+ XClearWindow( tqt_xdisplay(), outline_right );
+ XClearWindow( tqt_xdisplay(), outline_top );
+ XClearWindow( tqt_xdisplay(), outline_bottom );
+ XMapWindow( tqt_xdisplay(), outline_left );
+ XMapWindow( tqt_xdisplay(), outline_right );
+ XMapWindow( tqt_xdisplay(), outline_top );
+ XMapWindow( tqt_xdisplay(), outline_bottom );
+ }
+
+void TabBox::hide()
+ {
+ delayedShowTimer.stop();
+ TQWidget::hide();
+ TQApplication::syncX();
+ XEvent otherEvent;
+ while (XCheckTypedEvent (tqt_xdisplay(), EnterNotify, &otherEvent ) )
+ ;
+ appsOnly = false;
+ }
+
+
+void TabBox::reconfigure()
+ {
+ TDEConfig * c(TDEGlobal::config());
+ c->setGroup("TabBox");
+ options_traverse_all = c->readBoolEntry("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()
+ {
+ TDEConfig * c(TDEGlobal::config());
+ c->setGroup("TabBox");
+ bool delay = c->readBoolEntry("ShowDelay", true);
+
+ if (!delay)
+ {
+ show();
+ return;
+ }
+
+ int delayTime = c->readNumEntry("DelayTime", 90);
+ delayedShowTimer.start(delayTime, true);
+ }
+
+
+void TabBox::handleMouseEvent( XEvent* e )
+ {
+ XAllowEvents( tqt_xdisplay(), AsyncPointer, GET_QT_X_TIME() );
+ if( e->type != ButtonPress )
+ return;
+ TQPoint pos( e->xbutton.x_root, e->xbutton.y_root );
+ if( !geometry().contains( pos ))
+ {
+ workspace()->closeTabBox(); // click outside closes tab
+ return;
+ }
+ pos.rx() -= x(); // pos is now inside tabbox
+ pos.ry() -= y();
+ int num = (pos.y()-frameWidth()) / lineHeight;
+
+ if( mode() == WindowsMode )
+ {
+ for( ClientList::ConstIterator it = clients.begin();
+ it != clients.end();
+ ++it)
+ {
+ if( workspace()->hasClient( *it ) && (num == 0) ) // safety
+ {
+ setCurrentClient( *it );
+ break;
+ }
+ num--;
+ }
+ }
+ else
+ {
+ int iDesktop = (mode() == DesktopMode) ? workspace()->currentDesktop() : 1;
+ for( int i = 1;
+ i <= workspace()->numberOfDesktops();
+ ++i )
+ {
+ if( num == 0 )
+ {
+ desk = iDesktop;
+ break;
+ }
+ num--;
+ if( mode() == DesktopMode )
+ iDesktop = workspace()->nextDesktopFocusChain( iDesktop );
+ else
+ iDesktop++;
+ }
+ }
+ update();
+ }
+
+//*******************************
+// Workspace
+//*******************************
+
+
+/*!
+ Handles alt-tab / control-tab
+ */
+
+static
+bool areKeySymXsDepressed( bool bAll, const uint keySyms[], int nKeySyms )
+ {
+ char keymap[32];
+
+ kdDebug(125) << "areKeySymXsDepressed: " << (bAll ? "all of " : "any of ") << nKeySyms << endl;
+
+ XQueryKeymap( tqt_xdisplay(), keymap );
+
+ for( int iKeySym = 0; iKeySym < nKeySyms; iKeySym++ )
+ {
+ uint keySymX = keySyms[ iKeySym ];
+ uchar keyCodeX = XKeysymToKeycode( tqt_xdisplay(), keySymX );
+ int i = keyCodeX / 8;
+ char mask = 1 << (keyCodeX - (i * 8));
+
+ kdDebug(125) << iKeySym << ": keySymX=0x" << TQString::number( keySymX, 16 )
+ << " i=" << i << " mask=0x" << TQString::number( mask, 16 )
+ << " keymap[i]=0x" << TQString::number( keymap[i], 16 ) << endl;
+
+ // Abort if bad index value,
+ if( i < 0 || i >= 32 )
+ return false;
+
+ // 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 KKeySequence& seq )
+ {
+ uint rgKeySyms[10];
+ int nKeySyms = 0;
+ if( seq.isNull())
+ return false;
+ int mod = seq.key(seq.count()-1).modFlags();
+
+ if ( mod & KKey::SHIFT )
+ {
+ rgKeySyms[nKeySyms++] = XK_Shift_L;
+ rgKeySyms[nKeySyms++] = XK_Shift_R;
+ }
+ if ( mod & KKey::CTRL )
+ {
+ rgKeySyms[nKeySyms++] = XK_Control_L;
+ rgKeySyms[nKeySyms++] = XK_Control_R;
+ }
+ if( mod & KKey::ALT )
+ {
+ rgKeySyms[nKeySyms++] = XK_Alt_L;
+ rgKeySyms[nKeySyms++] = XK_Alt_R;
+ }
+ if( mod & KKey::WIN )
+ {
+ // 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 TDEShortcut& cut )
+ {
+ for( unsigned int i = 0;
+ i < cut.count();
+ ++i )
+ {
+ if( areModKeysDepressed( cut.seq( i )))
+ return true;
+ }
+ return false;
+ }
+
+void Workspace::slotWalkThroughWindows()
+ {
+ if ( root != tqt_xrootwin() )
+ return;
+ if ( tab_grab || control_grab )
+ return;
+ if ( options->altTabStyle == Options::CDE || !options->focusPolicyIsReasonable())
+ {
+ //XUngrabKeyboard(tqt_xdisplay(), GET_QT_X_TIME()); // 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 ( root != tqt_xrootwin() )
+ return;
+ 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::slotWalkThroughApps()
+ {
+ tab_box->setAppsOnly(true);
+ slotWalkThroughWindows();
+ }
+
+void Workspace::slotWalkBackThroughApps()
+ {
+ tab_box->setAppsOnly(true);
+ slotWalkBackThroughWindows();
+ }
+
+void Workspace::slotWalkThroughDesktops()
+ {
+ if ( root != tqt_xrootwin() )
+ return;
+ if( tab_grab || control_grab )
+ return;
+ if ( areModKeysDepressed( cutWalkThroughDesktops ) )
+ {
+ if ( startWalkThroughDesktops() )
+ walkThroughDesktops( true );
+ }
+ else
+ {
+ oneStepThroughDesktops( true );
+ }
+ }
+
+void Workspace::slotWalkBackThroughDesktops()
+ {
+ if ( root != tqt_xrootwin() )
+ return;
+ if( tab_grab || control_grab )
+ return;
+ if ( areModKeysDepressed( cutWalkThroughDesktopsReverse ) )
+ {
+ if ( startWalkThroughDesktops() )
+ walkThroughDesktops( false );
+ }
+ else
+ {
+ oneStepThroughDesktops( false );
+ }
+ }
+
+void Workspace::slotWalkThroughDesktopList()
+ {
+ if ( root != tqt_xrootwin() )
+ return;
+ if( tab_grab || control_grab )
+ return;
+ if ( areModKeysDepressed( cutWalkThroughDesktopList ) )
+ {
+ if ( startWalkThroughDesktopList() )
+ walkThroughDesktops( true );
+ }
+ else
+ {
+ oneStepThroughDesktopList( true );
+ }
+ }
+
+void Workspace::slotWalkBackThroughDesktopList()
+ {
+ if ( root != tqt_xrootwin() )
+ return;
+ if( tab_grab || control_grab )
+ return;
+ if ( areModKeysDepressed( cutWalkThroughDesktopListReverse ) )
+ {
+ if ( startWalkThroughDesktopList() )
+ walkThroughDesktops( false );
+ }
+ else
+ {
+ oneStepThroughDesktopList( false );
+ }
+ }
+
+bool Workspace::startKDEWalkThroughWindows()
+ {
+ if( !establishTabBoxGrab())
+ return false;
+ tab_grab = TRUE;
+ keys->suspend( true );
+ disable_shortcuts_keys->suspend( true );
+ client_keys->suspend( true );
+ tab_box->setMode( TabBox::WindowsMode );
+ tab_box->reset();
+ return TRUE;
+ }
+
+bool Workspace::startWalkThroughDesktops( int mode )
+ {
+ if( !establishTabBoxGrab())
+ return false;
+ control_grab = TRUE;
+ keys->suspend( true );
+ disable_shortcuts_keys->suspend( true );
+ client_keys->suspend( true );
+ tab_box->setMode( (TabBox::Mode) mode );
+ tab_box->reset();
+ return TRUE;
+ }
+
+bool Workspace::startWalkThroughDesktops()
+ {
+ return startWalkThroughDesktops( TabBox::DesktopMode );
+ }
+
+bool Workspace::startWalkThroughDesktopList()
+ {
+ return startWalkThroughDesktops( TabBox::DesktopListMode );
+ }
+
+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( ClientList::ConstIterator it = stacking_order.fromLast();
+ it != stacking_order.end();
+ --it )
+ {
+ if ( (*it)->isOnCurrentDesktop() && !(*it)->isSpecialWindow()
+ && (*it)->isShown( false ) && (*it)->wantsTabFocus()
+ && !(*it)->keepAbove() && !(*it)->keepBelow())
+ {
+ c = *it;
+ break;
+ }
+ }
+ Client* nc = c;
+ bool options_traverse_all;
+ {
+ TDEConfigGroupSaver saver( TDEGlobal::config(), "TabBox" );
+ options_traverse_all = TDEGlobal::config()->readBoolEntry("TraverseAll", false );
+ }
+
+ Client* firstClient = 0;
+ do
+ {
+ nc = forward ? nextStaticClient(nc) : previousStaticClient(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( TabBox::WindowsMode );
+ 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, int mode )
+ {
+ tab_box->setMode( (TabBox::Mode) mode );
+ tab_box->reset();
+ tab_box->nextPrev( forward );
+ if ( tab_box->currentDesktop() != -1 )
+ setCurrentDesktop( tab_box->currentDesktop() );
+ }
+
+void Workspace::oneStepThroughDesktops( bool forward )
+ {
+ oneStepThroughDesktops( forward, TabBox::DesktopMode );
+ }
+
+void Workspace::oneStepThroughDesktopList( bool forward )
+ {
+ oneStepThroughDesktops( forward, TabBox::DesktopListMode );
+ }
+
+/*!
+ Handles holding alt-tab / control-tab
+ */
+void Workspace::tabBoxKeyPress( const KKeyNative& keyX )
+ {
+ bool forward = false;
+ bool backward = false;
+ bool forwardapps = false;
+ bool backwardapps = false;
+
+ if (tab_grab)
+ {
+ forward = cutWalkThroughWindows.contains( keyX );
+ backward = cutWalkThroughWindowsReverse.contains( keyX );
+
+ forwardapps = cutWalkThroughApps.contains( keyX );
+ backwardapps = cutWalkThroughAppsReverse.contains( keyX );
+
+ if ( (forward || backward) && (!tab_box->isAppsOnly()) )
+ {
+ kdDebug(125) << "== " << cutWalkThroughWindows.toStringInternal()
+ << " or " << cutWalkThroughWindowsReverse.toStringInternal() << endl;
+
+ KDEWalkThroughWindows( forward );
+ }
+
+ if ( (forwardapps || backwardapps) && (tab_box->isAppsOnly()) )
+ {
+ kdDebug(125) << "== " << cutWalkThroughWindows.toStringInternal()
+ << " or " << cutWalkThroughWindowsReverse.toStringInternal() << endl;
+ KDEWalkThroughWindows( forwardapps );
+ }
+ }
+
+ else if (control_grab)
+ {
+ forward = cutWalkThroughDesktops.contains( keyX ) ||
+ cutWalkThroughDesktopList.contains( keyX );
+ backward = cutWalkThroughDesktopsReverse.contains( keyX ) ||
+ cutWalkThroughDesktopListReverse.contains( keyX );
+ if (forward || backward)
+ walkThroughDesktops(forward);
+ }
+
+ if (control_grab || tab_grab)
+ {
+ uint keyQt = keyX.keyCodeQt();
+ if ( ((keyQt & 0xffff) == Qt::Key_Escape)
+ && !(forward || backward) )
+ { // if Escape is part of the shortcut, don't cancel
+ closeTabBox();
+ }
+ }
+ }
+
+void Workspace::closeTabBox()
+ {
+ removeTabBoxGrab();
+ tab_box->hide();
+ keys->suspend( false );
+ disable_shortcuts_keys->suspend( false );
+ client_keys->suspend( false );
+ tab_grab = FALSE;
+ control_grab = FALSE;
+ }
+
+/*!
+ Handles alt-tab / control-tab releasing
+ */
+void Workspace::tabBoxKeyRelease( const XKeyEvent& ev )
+ {
+ unsigned int mk = ev.state &
+ (KKeyNative::modX(KKey::SHIFT) |
+ KKeyNative::modX(KKey::CTRL) |
+ KKeyNative::modX(KKey::ALT) |
+ KKeyNative::modX(KKey::WIN));
+ // 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(tqt_xdisplay());
+ 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)
+ {
+ removeTabBoxGrab();
+ tab_box->hide();
+ keys->suspend( false );
+ disable_shortcuts_keys->suspend( false );
+ client_keys->suspend( false );
+ tab_grab = false;
+ if( Client* c = tab_box->currentClient())
+ {
+ activateClient( c );
+ if( c->isShade() && options->shadeHover )
+ c->setShade( ShadeActivated );
+ }
+ }
+ if (control_grab)
+ {
+ removeTabBoxGrab();
+ tab_box->hide();
+ keys->suspend( false );
+ disable_shortcuts_keys->suspend( false );
+ client_keys->suspend( false );
+ control_grab = False;
+ if ( tab_box->currentDesktop() != -1 )
+ {
+ setCurrentDesktop( tab_box->currentDesktop() );
+ }
+ }
+ }
+
+
+int Workspace::nextDesktopFocusChain( int iDesktop ) const
+ {
+ int i = desktop_focus_chain.find( 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.find( 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();
+ }
+
+/*!
+ auxiliary functions to travers all clients according the focus
+ order. Useful for kwms Alt-tab feature.
+*/
+Client* Workspace::nextFocusChainClient( Client* c ) const
+ {
+ if ( global_focus_chain.isEmpty() )
+ return 0;
+ ClientList::ConstIterator it = global_focus_chain.find( c );
+ if ( it == global_focus_chain.end() )
+ return global_focus_chain.last();
+ if ( it == global_focus_chain.begin() )
+ return global_focus_chain.last();
+ --it;
+ return *it;
+ }
+
+/*!
+ auxiliary functions to travers all clients according the focus
+ order. Useful for kwms Alt-tab feature.
+*/
+Client* Workspace::previousFocusChainClient( Client* c ) const
+ {
+ if ( global_focus_chain.isEmpty() )
+ return 0;
+ ClientList::ConstIterator it = global_focus_chain.find( c );
+ if ( it == global_focus_chain.end() )
+ return global_focus_chain.first();
+ ++it;
+ if ( it == global_focus_chain.end() )
+ return global_focus_chain.first();
+ return *it;
+ }
+
+/*!
+ auxiliary functions to travers all clients according the static
+ order. Useful for the CDE-style Alt-tab feature.
+*/
+Client* Workspace::nextStaticClient( Client* c ) const
+ {
+ if ( !c || clients.isEmpty() )
+ return 0;
+ ClientList::ConstIterator it = clients.find( c );
+ if ( it == clients.end() )
+ return clients.first();
+ ++it;
+ if ( it == clients.end() )
+ return clients.first();
+ return *it;
+ }
+/*!
+ auxiliary functions to travers all clients according the static
+ order. Useful for the CDE-style Alt-tab feature.
+*/
+Client* Workspace::previousStaticClient( Client* c ) const
+ {
+ if ( !c || clients.isEmpty() )
+ return 0;
+ ClientList::ConstIterator it = clients.find( c );
+ if ( it == clients.end() )
+ return clients.last();
+ if ( it == clients.begin() )
+ return clients.last();
+ --it;
+ return *it;
+ }
+
+bool Workspace::establishTabBoxGrab()
+ {
+ if( XGrabKeyboard( tqt_xdisplay(), root, FALSE,
+ GrabModeAsync, GrabModeAsync, GET_QT_X_TIME()) != GrabSuccess )
+ 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()
+ {
+ XUngrabKeyboard(tqt_xdisplay(), GET_QT_X_TIME());
+ assert( forced_global_mouse_grab );
+ forced_global_mouse_grab = false;
+ if( active_client != NULL )
+ active_client->updateMouseGrab();
+ }
+
+} // namespace
+
+#include "tabbox.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-23 21:35:54 +0000