Rename kwin to twin (Part 2 of 2)

1 files changed, 3010 insertions, 0 deletions

diff --git a/twin/workspace.cpp b/twin/workspace.cpp
new file mode 100644
index 000000000..44045838c
--- /dev/null
+++ b/twin/workspace.cpp
@@ -0,0 +1,3010 @@
+/*****************************************************************
+ 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 "workspace.h"
+
+#include <kapplication.h>
+#include <kstartupinfo.h>
+#include <fixx11h.h>
+#include <kconfig.h>
+#include <kglobal.h>
+#include <tqpopupmenu.h>
+#include <klocale.h>
+#include <tqregexp.h>
+#include <tqpainter.h>
+#include <tqbitmap.h>
+#include <tqclipboard.h>
+#include <kmenubar.h>
+#include <kprocess.h>
+#include <kglobalaccel.h>
+#include <dcopclient.h>
+#include <kipc.h>
+
+#include "plugins.h"
+#include "client.h"
+#include "popupinfo.h"
+#include "tabbox.h"
+#include "atoms.h"
+#include "placement.h"
+#include "notifications.h"
+#include "group.h"
+#include "rules.h"
+
+#include <X11/extensions/shape.h>
+#include <X11/keysym.h>
+#include <X11/keysymdef.h>
+#include <X11/cursorfont.h>
+
+#include <pwd.h>
+
+namespace KWinInternal
+{
+
+extern int screen_number;
+
+Workspace *Workspace::_self = 0;
+
+KProcess* kompmgr = 0;
+KSelectionOwner* kompmgr_selection;
+
+bool allowKompmgrRestart = TRUE;
+
+bool supportsCompMgr()
+{
+    int i;
+
+    bool damageExt = XQueryExtension(qt_xdisplay(), "DAMAGE", &i, &i, &i);
+    bool compositeExt = XQueryExtension(qt_xdisplay(), "Composite", &i, &i, &i);
+    bool xfixesExt = XQueryExtension(qt_xdisplay(), "XFIXES", &i, &i, &i);
+
+    return damageExt && compositeExt && xfixesExt;
+}
+
+// Rikkus: This class is too complex. It needs splitting further.
+// It's a nightmare to understand, especially with so few comments :(
+
+// Matthias: Feel free to ask me questions about it. Feel free to add
+// comments. I disagree that further splittings makes it easier. 2500
+// lines are not too much. It's the task that is complex, not the
+// code.
+Workspace::Workspace( bool restore )
+  : DCOPObject        ("KWinInterface"),
+    TQObject           (0, "workspace"),
+    current_desktop   (0),
+    number_of_desktops(0),
+    active_screen     (0),
+    active_popup( NULL ),
+    active_popup_client( NULL ),
+    desktop_widget    (0),
+    temporaryRulesMessages( "_KDE_NET_WM_TEMPORARY_RULES", NULL, false ),
+    rules_updates_disabled( false ),
+    active_client     (0),
+    last_active_client     (0),
+    next_active_client     (0),
+    most_recently_raised (0),
+    movingClient(0),
+    pending_take_activity ( NULL ),
+    delayfocus_client (0),
+    showing_desktop( false ),
+    block_showing_desktop( 0 ),
+    was_user_interaction (false),
+    session_saving    (false),
+    control_grab      (false),
+    tab_grab          (false),
+    mouse_emulation   (false),
+    block_focus       (0),
+    tab_box           (0),
+    popupinfo         (0),
+    popup             (0),
+    advanced_popup    (0),
+    desk_popup        (0),
+    desk_popup_index  (0),
+    keys              (0),
+    client_keys       ( NULL ),
+    client_keys_dialog ( NULL ),
+    client_keys_client ( NULL ),
+    disable_shortcuts_keys ( NULL ),
+    global_shortcuts_disabled( false ),
+    global_shortcuts_disabled_for_client( false ),
+    root              (0),
+    workspaceInit     (true),
+    startup(0), electric_have_borders(false),
+    electric_current_border(0),
+    electric_top_border(None),
+    electric_bottom_border(None),
+    electric_left_border(None),
+    electric_right_border(None),
+    layoutOrientation(Qt::Vertical),
+    layoutX(-1),
+    layoutY(2),
+    workarea(NULL),
+    screenarea(NULL),
+    managing_topmenus( false ),
+    topmenu_selection( NULL ),
+    topmenu_watcher( NULL ),
+    topmenu_height( 0 ),
+    topmenu_space( NULL ),
+    set_active_client_recursion( 0 ),
+    block_stacking_updates( 0 ),
+    forced_global_mouse_grab( false )
+    {
+    _self = this;
+    mgr = new PluginMgr;
+    root = qt_xrootwin();
+    default_colormap = DefaultColormap(qt_xdisplay(), qt_xscreen() );
+    installed_colormap = default_colormap;
+    session.setAutoDelete( TRUE );
+
+    connect( &temporaryRulesMessages, TQT_SIGNAL( gotMessage( const TQString& )),
+        this, TQT_SLOT( gotTemporaryRulesMessage( const TQString& )));
+    connect( &rulesUpdatedTimer, TQT_SIGNAL( timeout()), this, TQT_SLOT( writeWindowRules()));
+
+    updateXTime(); // needed for proper initialization of user_time in Client ctor
+
+    delayFocusTimer = 0; 
+    
+    electric_time_first = GET_QT_X_TIME();
+    electric_time_last = GET_QT_X_TIME();
+
+    if ( restore )
+      loadSessionInfo();
+
+    loadWindowRules();
+
+    (void) TQApplication::desktop(); // trigger creation of desktop widget
+
+    desktop_widget =
+      new TQWidget(
+        0,
+        "desktop_widget",
+        (WFlags)(TQt::WType_Desktop | TQt::WPaintUnclipped)
+    );
+
+    kapp->setGlobalMouseTracking( true ); // so that this doesn't mess eventmask on root window later
+    // call this before XSelectInput() on the root window
+    startup = new KStartupInfo(
+        KStartupInfo::DisableKWinModule | KStartupInfo::AnnounceSilenceChanges, this );
+
+    // select windowmanager privileges
+    XSelectInput(qt_xdisplay(), root,
+                 KeyPressMask |
+                 PropertyChangeMask |
+                 ColormapChangeMask |
+                 SubstructureRedirectMask |
+                 SubstructureNotifyMask |
+                 FocusChangeMask // for NotifyDetailNone
+                 );
+
+    Shape::init();
+
+    // compatibility
+    long data = 1;
+
+    XChangeProperty(
+      qt_xdisplay(),
+      qt_xrootwin(),
+      atoms->twin_running,
+      atoms->twin_running,
+      32,
+      PropModeAppend,
+      (unsigned char*) &data,
+      1
+    );
+
+    client_keys = new KGlobalAccel( this );
+    initShortcuts();
+    tab_box = new TabBox( this );
+    popupinfo = new PopupInfo( this );
+
+    init();
+
+#if (QT_VERSION-0 >= 0x030200) // XRANDR support
+    connect( kapp->desktop(), TQT_SIGNAL( resized( int )), TQT_SLOT( desktopResized()));
+#endif
+
+    if (!supportsCompMgr())
+        options->useTranslucency = false;
+
+    // start kompmgr - i wanted to put this into main.cpp, but that would prevent dcop support, as long as Application was no dcop_object
+    if (options->useTranslucency)
+        {
+        kompmgr = new KProcess;
+        connect(kompmgr, TQT_SIGNAL(receivedStderr(KProcess*, char*, int)), TQT_SLOT(handleKompmgrOutput(KProcess*, char*, int)));
+        *kompmgr << "kompmgr";
+        startKompmgr();
+        }
+    else
+        {
+        // If kompmgr is already running, send it SIGTERM
+        // Attempt to load the kompmgr pid file
+        const char *home;
+        struct passwd *p;
+        p = getpwuid(getuid());
+        if (p)
+            home = p->pw_dir;
+        else
+            home = getenv("HOME");
+        char *filename;
+        const char *configfile = "/.kompmgr.pid";
+        int n = strlen(home)+strlen(configfile)+1;
+        filename = (char*)malloc(n*sizeof(char));
+        memset(filename,0,n);
+        strcat(filename, home);
+        strcat(filename, configfile);
+
+        printf("reading '%s' as kompmgr pidfile\n\n", filename);
+
+        // Now that we did all that by way of introduction...read the file!
+        FILE *pFile;
+        char buffer[255];
+        pFile = fopen(filename, "r");
+        int kompmgrpid = 0;
+        if (pFile)
+            {
+            // obtain file size
+            fseek (pFile , 0 , SEEK_END);
+            unsigned long lSize = ftell (pFile);
+            if (lSize > 254)
+                lSize = 254;
+            rewind (pFile);
+            size_t result = fread (buffer, 1, lSize, pFile);
+            fclose(pFile);
+            kompmgrpid = atoi(buffer);
+            }
+
+        free(filename);
+        filename = NULL;
+
+        if (kompmgrpid)
+                {
+                kill(kompmgrpid, SIGTERM);
+                }
+            else
+                {
+                stopKompmgr();
+                }
+        }
+    }
+
+
+void Workspace::init()
+    {
+    checkElectricBorders();
+
+// not used yet
+//     topDock = 0L;
+//     maximizedWindowCounter = 0;
+    
+    supportWindow = new TQWidget;
+    XLowerWindow( qt_xdisplay(), supportWindow->winId()); // see usage in layers.cpp
+
+    XSetWindowAttributes attr;
+    attr.override_redirect = 1;
+    null_focus_window = XCreateWindow( qt_xdisplay(), qt_xrootwin(), -1,-1, 1, 1, 0, CopyFromParent,
+        InputOnly, CopyFromParent, CWOverrideRedirect, &attr );
+    XMapWindow(qt_xdisplay(), null_focus_window);
+
+    unsigned long protocols[ 5 ] =
+        {
+        NET::Supported |
+        NET::SupportingWMCheck |
+        NET::ClientList |
+        NET::ClientListStacking |
+        NET::DesktopGeometry |
+        NET::NumberOfDesktops |
+        NET::CurrentDesktop |
+        NET::ActiveWindow |
+        NET::WorkArea |
+        NET::CloseWindow |
+        NET::DesktopNames |
+        NET::KDESystemTrayWindows |
+        NET::WMName |
+        NET::WMVisibleName |
+        NET::WMDesktop |
+        NET::WMWindowType |
+        NET::WMState |
+        NET::WMStrut |
+        NET::WMIconGeometry |
+        NET::WMIcon |
+        NET::WMPid |
+        NET::WMMoveResize |
+        NET::WMKDESystemTrayWinFor |
+        NET::WMFrameExtents |
+        NET::WMPing
+        ,
+        NET::NormalMask |
+        NET::DesktopMask |
+        NET::DockMask |
+        NET::ToolbarMask |
+        NET::MenuMask |
+        NET::DialogMask |
+        NET::OverrideMask |
+        NET::TopMenuMask |
+        NET::UtilityMask |
+        NET::SplashMask |
+        0
+        ,
+        NET::Modal |
+//        NET::Sticky |  // large desktops not supported (and probably never will be)
+        NET::MaxVert |
+        NET::MaxHoriz |
+        NET::Shaded |
+        NET::SkipTaskbar |
+        NET::KeepAbove |
+//        NET::StaysOnTop |  the same like KeepAbove
+        NET::SkipPager |
+        NET::Hidden |
+        NET::FullScreen |
+        NET::KeepBelow |
+        NET::DemandsAttention |
+        0
+        ,
+        NET::WM2UserTime |
+        NET::WM2StartupId |
+        NET::WM2AllowedActions |
+        NET::WM2RestackWindow |
+        NET::WM2MoveResizeWindow |
+        NET::WM2ExtendedStrut |
+        NET::WM2KDETemporaryRules |
+        NET::WM2ShowingDesktop |
+        NET::WM2FullPlacement |
+        NET::WM2DesktopLayout |
+        0
+        ,
+        NET::ActionMove |
+        NET::ActionResize |
+        NET::ActionMinimize |
+        NET::ActionShade |
+//        NET::ActionStick | // Sticky state is not supported
+        NET::ActionMaxVert |
+        NET::ActionMaxHoriz |
+        NET::ActionFullScreen |
+        NET::ActionChangeDesktop |
+        NET::ActionClose |
+        0
+        ,
+        };
+
+    rootInfo = new RootInfo( this, qt_xdisplay(), supportWindow->winId(), "KWin",
+        protocols, 5, qt_xscreen() );
+
+    loadDesktopSettings();
+    updateDesktopLayout();
+    // extra NETRootInfo instance in Client mode is needed to get the values of the properties
+    NETRootInfo client_info( qt_xdisplay(), NET::ActiveWindow | NET::CurrentDesktop );
+    int initial_desktop;
+    if( !kapp->isSessionRestored())
+        initial_desktop = client_info.currentDesktop();
+    else
+        {
+        KConfigGroupSaver saver( kapp->sessionConfig(), "Session" );
+        initial_desktop = kapp->sessionConfig()->readNumEntry( "desktop", 1 );
+        }
+    if( !setCurrentDesktop( initial_desktop ))
+        setCurrentDesktop( 1 );
+
+    // now we know how many desktops we'll, thus, we initialise the positioning object
+    initPositioning = new Placement(this);
+
+    connect(&reconfigureTimer, TQT_SIGNAL(timeout()), this,
+            TQT_SLOT(slotReconfigure()));
+    connect( &updateToolWindowsTimer, TQT_SIGNAL( timeout()), this, TQT_SLOT( slotUpdateToolWindows()));
+
+    connect(kapp, TQT_SIGNAL(appearanceChanged()), this,
+            TQT_SLOT(slotReconfigure()));
+    connect(kapp, TQT_SIGNAL(settingsChanged(int)), this,
+            TQT_SLOT(slotSettingsChanged(int)));
+    connect(kapp, TQT_SIGNAL( kipcMessage( int, int )), this, TQT_SLOT( kipcMessage( int, int )));
+
+    active_client = NULL;
+    rootInfo->setActiveWindow( None );
+    focusToNull();
+    if( !kapp->isSessionRestored())
+        ++block_focus; // because it will be set below
+
+    char nm[ 100 ];
+    sprintf( nm, "_KDE_TOPMENU_OWNER_S%d", DefaultScreen( qt_xdisplay()));
+    Atom topmenu_atom = XInternAtom( qt_xdisplay(), nm, False );
+    topmenu_selection = new KSelectionOwner( topmenu_atom );
+    topmenu_watcher = new KSelectionWatcher( topmenu_atom );
+// TODO grabXServer(); - where exactly put this? topmenu selection claiming down belong must be before
+
+        { // begin updates blocker block
+        StackingUpdatesBlocker blocker( this );
+
+        if( options->topMenuEnabled() && topmenu_selection->claim( false ))
+            setupTopMenuHandling(); // this can call updateStackingOrder()
+        else
+            lostTopMenuSelection();
+
+        unsigned int i, nwins;
+        Window root_return, parent_return, *wins;
+        XQueryTree(qt_xdisplay(), root, &root_return, &parent_return, &wins, &nwins);
+        for (i = 0; i < nwins; i++) 
+            {
+            XWindowAttributes attr;
+            XGetWindowAttributes(qt_xdisplay(), wins[i], &attr);
+            if (attr.override_redirect )
+                continue;
+            if( topmenu_space && topmenu_space->winId() == wins[ i ] )
+                continue;
+            if (attr.map_state != IsUnmapped) 
+                {
+                if ( addSystemTrayWin( wins[i] ) )
+                    continue;
+                Client* c = createClient( wins[i], true );
+                if ( c != NULL && root != qt_xrootwin() ) 
+                    { // TODO what is this?
+                // TODO may use TQWidget:.create
+                    XReparentWindow( qt_xdisplay(), c->frameId(), root, 0, 0 );
+                    c->move(0,0);
+                    }
+                }
+            }
+        if ( wins )
+            XFree((void *) wins);
+    // propagate clients, will really happen at the end of the updates blocker block
+        updateStackingOrder( true );
+
+        updateClientArea();
+        raiseElectricBorders();
+
+    // NETWM spec says we have to set it to (0,0) if we don't support it
+        NETPoint* viewports = new NETPoint[ number_of_desktops ];
+        rootInfo->setDesktopViewport( number_of_desktops, *viewports );
+        delete[] viewports;
+        TQRect geom = TQApplication::desktop()->geometry();
+        NETSize desktop_geometry;
+        desktop_geometry.width = geom.width();
+        desktop_geometry.height = geom.height();
+        rootInfo->setDesktopGeometry( -1, desktop_geometry );
+        setShowingDesktop( false );
+
+        } // end updates blocker block
+
+    Client* new_active_client = NULL;
+    if( !kapp->isSessionRestored())
+        {
+        --block_focus;
+        new_active_client = findClient( WindowMatchPredicate( client_info.activeWindow()));
+        }
+    if( new_active_client == NULL
+        && activeClient() == NULL && should_get_focus.count() == 0 ) // no client activated in manage()
+        {
+        if( new_active_client == NULL )
+            new_active_client = topClientOnDesktop( currentDesktop());
+        if( new_active_client == NULL && !desktops.isEmpty() )
+            new_active_client = findDesktop( true, currentDesktop());
+        }
+    if( new_active_client != NULL )
+        activateClient( new_active_client );
+    // SELI TODO this won't work with unreasonable focus policies,
+    // and maybe in rare cases also if the selected client doesn't
+    // want focus
+    workspaceInit = false;
+// TODO ungrabXServer()
+    }
+
+Workspace::~Workspace()
+    {
+    if (kompmgr)
+        delete kompmgr;
+    blockStackingUpdates( true );
+// TODO    grabXServer();
+    // use stacking_order, so that twin --replace keeps stacking order
+    for( ClientList::ConstIterator it = stacking_order.begin();
+         it != stacking_order.end();
+         ++it )
+        {
+	// only release the window
+        (*it)->releaseWindow( true );
+        // No removeClient() is called, it does more than just removing.
+        // However, remove from some lists to e.g. prevent performTransiencyCheck()
+        // from crashing.
+        clients.remove( *it );
+        desktops.remove( *it );
+        }
+    delete desktop_widget;
+    delete tab_box;
+    delete popupinfo;
+    delete popup;
+    if ( root == qt_xrootwin() )
+        XDeleteProperty(qt_xdisplay(), qt_xrootwin(), atoms->twin_running);
+
+    writeWindowRules();
+    KGlobal::config()->sync();
+
+    delete rootInfo;
+    delete supportWindow;
+    delete mgr;
+    delete[] workarea;
+    delete[] screenarea;
+    delete startup;
+    delete initPositioning;
+    delete topmenu_watcher;
+    delete topmenu_selection;
+    delete topmenu_space;
+    delete client_keys_dialog;
+    while( !rules.isEmpty())
+        {
+        delete rules.front();
+        rules.pop_front();
+        }
+    XDestroyWindow( qt_xdisplay(), null_focus_window );
+// TODO    ungrabXServer();
+    _self = 0;
+    }
+
+Client* Workspace::createClient( Window w, bool is_mapped )
+    {
+    StackingUpdatesBlocker blocker( this );
+    Client* c = new Client( this );
+    if( !c->manage( w, is_mapped ))
+        {
+        Client::deleteClient( c, Allowed );
+        return NULL;
+        }
+    addClient( c, Allowed );
+    return c;
+    }
+
+void Workspace::addClient( Client* c, allowed_t )
+    {
+    // waited with trans settings until window figured out if active or not ;)
+//     qWarning("%s", (const char*)(c->resourceClass()));
+    c->setBMP(c->resourceName() == "beep-media-player" || c->decorationId() == None);
+    // first check if the window has it's own opinion of it's translucency ;)
+    c->getWindowOpacity();
+    if (c->isDock())
+        {
+//         if (c->x() == 0 && c->y() == 0 && c->width() > c->height()) topDock = c;
+        if (!c->hasCustomOpacity()) // this xould be done slightly more efficient, but we want to support the topDock in future
+            {
+            c->setShadowSize(options->dockShadowSize);
+            c->setOpacity(options->translucentDocks, options->dockOpacity);
+            }
+        }
+
+    if (c->isMenu() || c->isTopMenu())
+        {
+            c->setShadowSize(options->menuShadowSize);
+        }
+//------------------------------------------------
+    Group* grp = findGroup( c->window());
+    if( grp != NULL )
+        grp->gotLeader( c );
+
+    if ( c->isDesktop() )
+        {
+        desktops.append( c );
+        if( active_client == NULL && should_get_focus.isEmpty() && c->isOnCurrentDesktop())
+            requestFocus( c ); // CHECKME? make sure desktop is active after startup if there's no other window active
+        }
+    else
+        {
+        updateFocusChains( c, FocusChainUpdate ); // add to focus chain if not already there
+        clients.append( c );
+        }
+    if( !unconstrained_stacking_order.contains( c ))
+        unconstrained_stacking_order.append( c );
+    if( !stacking_order.contains( c )) // it'll be updated later, and updateToolWindows() requires
+        stacking_order.append( c );    // c to be in stacking_order
+    if( c->isTopMenu())
+        addTopMenu( c );
+    updateClientArea(); // this cannot be in manage(), because the client got added only now
+    updateClientLayer( c );
+    if( c->isDesktop())
+        {
+        raiseClient( c );
+	// if there's no active client, make this desktop the active one
+        if( activeClient() == NULL && should_get_focus.count() == 0 )
+            activateClient( findDesktop( true, currentDesktop()));
+        }
+    c->checkActiveModal();
+    checkTransients( c->window()); // SELI does this really belong here?
+    updateStackingOrder( true ); // propagate new client
+    if( c->isUtility() || c->isMenu() || c->isToolbar())
+        updateToolWindows( true );
+    checkNonExistentClients();
+    }
+
+/*
+  Destroys the client \a c
+ */
+void Workspace::removeClient( Client* c, allowed_t )
+    {
+    if (c == active_popup_client)
+        closeActivePopup();
+
+    if( client_keys_client == c )
+        setupWindowShortcutDone( false );
+    if( !c->shortcut().isNull())
+        c->setShortcut( TQString::null ); // remove from client_keys
+
+    if( c->isDialog())
+        Notify::raise( Notify::TransDelete );
+    if( c->isNormalWindow())
+        Notify::raise( Notify::Delete );
+
+    Q_ASSERT( clients.contains( c ) || desktops.contains( c ));
+    clients.remove( c );
+    desktops.remove( c );
+    unconstrained_stacking_order.remove( c );
+    stacking_order.remove( c );
+    for( int i = 1;
+         i <= numberOfDesktops();
+         ++i )
+        focus_chain[ i ].remove( c );
+    global_focus_chain.remove( c );
+    attention_chain.remove( c );
+    showing_desktop_clients.remove( c );
+    if( c->isTopMenu())
+        removeTopMenu( c );
+    Group* group = findGroup( c->window());
+    if( group != NULL )
+        group->lostLeader();
+
+    if ( c == most_recently_raised )
+        most_recently_raised = 0;
+    should_get_focus.remove( c );
+    Q_ASSERT( c != active_client );
+    if ( c == last_active_client )
+        last_active_client = 0;
+    if( c == pending_take_activity )
+        pending_take_activity = NULL;
+    if( c == delayfocus_client )
+        cancelDelayFocus();
+
+    updateStackingOrder( true );
+
+    if (tab_grab)
+       tab_box->repaint();
+
+    updateClientArea();
+    }
+
+void Workspace::updateFocusChains( Client* c, FocusChainChange change )
+    {
+    if( !c->wantsTabFocus()) // doesn't want tab focus, remove
+        {
+        for( int i=1;
+             i<= numberOfDesktops();
+             ++i )
+            focus_chain[i].remove(c);
+        global_focus_chain.remove( c );
+        return;
+        }
+    if(c->desktop() == NET::OnAllDesktops)
+        { //now on all desktops, add it to focus_chains it is not already in
+        for( int i=1; i<= numberOfDesktops(); i++)
+            { // making first/last works only on current desktop, don't affect all desktops
+            if( i == currentDesktop()
+                && ( change == FocusChainMakeFirst || change == FocusChainMakeLast ))
+                {
+                focus_chain[ i ].remove( c );
+                if( change == FocusChainMakeFirst )
+                    focus_chain[ i ].append( c );
+                else
+                    focus_chain[ i ].prepend( c );
+                }
+            else if( !focus_chain[ i ].contains( c ))
+                { // add it after the active one
+                if( active_client != NULL && active_client != c
+                    && !focus_chain[ i ].isEmpty() && focus_chain[ i ].last() == active_client )
+                    focus_chain[ i ].insert( focus_chain[ i ].fromLast(), c );
+                else
+                    focus_chain[ i ].append( c ); // otherwise add as the first one
+                }
+            }
+        }
+    else    //now only on desktop, remove it anywhere else
+        {
+        for( int i=1; i<= numberOfDesktops(); i++)
+            {
+            if( i == c->desktop())
+                {
+                if( change == FocusChainMakeFirst )
+                    {
+                    focus_chain[ i ].remove( c );
+                    focus_chain[ i ].append( c );
+                    }
+                else if( change == FocusChainMakeLast )
+                    {
+                    focus_chain[ i ].remove( c );
+                    focus_chain[ i ].prepend( c );
+                    }
+                else if( !focus_chain[ i ].contains( c ))
+                    {
+                    if( active_client != NULL && active_client != c
+                        && !focus_chain[ i ].isEmpty() && focus_chain[ i ].last() == active_client )
+                        focus_chain[ i ].insert( focus_chain[ i ].fromLast(), c );
+                    else
+                        focus_chain[ i ].append( c ); // otherwise add as the first one
+                    }
+                }
+            else
+                focus_chain[ i ].remove( c );
+            }
+        }
+    if( change == FocusChainMakeFirst )
+        {
+        global_focus_chain.remove( c );
+        global_focus_chain.append( c );
+        }
+    else if( change == FocusChainMakeLast )
+        {
+        global_focus_chain.remove( c );
+        global_focus_chain.prepend( c );
+        }
+    else if( !global_focus_chain.contains( c ))
+        {
+        if( active_client != NULL && active_client != c
+            && !global_focus_chain.isEmpty() && global_focus_chain.last() == active_client )
+            global_focus_chain.insert( global_focus_chain.fromLast(), c );
+        else
+            global_focus_chain.append( c ); // otherwise add as the first one
+        }
+    }
+
+void Workspace::updateOverlappingShadows(unsigned long window)
+    {
+    Client *client;
+    
+    if ((client = findClient(WindowMatchPredicate((WId)window))))
+        // Redraw overlapping shadows without waiting for the specified window
+        // to redraw its own shadow
+        client->drawOverlappingShadows(false);
+    }
+
+void Workspace::setShadowed(unsigned long window, bool shadowed)
+    {
+    Client *client;
+    
+    if ((client = findClient(WindowMatchPredicate((WId)window))))
+        client->setShadowed(shadowed);
+    }
+
+void Workspace::updateCurrentTopMenu()
+    {
+    if( !managingTopMenus())
+        return;
+    // toplevel menubar handling
+    Client* menubar = 0;
+    bool block_desktop_menubar = false;
+    if( active_client )
+        {
+        // show the new menu bar first...
+        Client* menu_client = active_client;
+        for(;;)
+            {
+            if( menu_client->isFullScreen())
+                block_desktop_menubar = true;
+            for( ClientList::ConstIterator it = menu_client->transients().begin();
+                 it != menu_client->transients().end();
+                 ++it )
+                if( (*it)->isTopMenu())
+                    {
+                    menubar = *it;
+                    break;
+                    }
+            if( menubar != NULL || !menu_client->isTransient())
+                break;
+            if( menu_client->isModal() || menu_client->transientFor() == NULL )
+                break; // don't use mainwindow's menu if this is modal or group transient
+            menu_client = menu_client->transientFor();
+            }
+        if( !menubar )
+            { // try to find any topmenu from the application (#72113)
+            for( ClientList::ConstIterator it = active_client->group()->members().begin();
+                 it != active_client->group()->members().end();
+                 ++it )
+                if( (*it)->isTopMenu())
+                    {
+                    menubar = *it;
+                    break;
+                    }
+            }
+        }
+    if( !menubar && !block_desktop_menubar && options->desktopTopMenu())
+        {
+        // Find the menubar of the desktop
+        Client* desktop = findDesktop( true, currentDesktop());
+        if( desktop != NULL )
+            {
+            for( ClientList::ConstIterator it = desktop->transients().begin();
+                 it != desktop->transients().end();
+                 ++it )
+                if( (*it)->isTopMenu())
+                    {
+                    menubar = *it;
+                    break;
+                    }
+            }
+        // TODO to be cleaned app with window grouping
+        // Without qt-copy patch #0009, the topmenu and desktop are not in the same group,
+        // thus the topmenu is not transient for it :-/.
+        if( menubar == NULL )
+            {
+            for( ClientList::ConstIterator it = topmenus.begin();
+                 it != topmenus.end();
+                 ++it )
+                if( (*it)->wasOriginallyGroupTransient()) // kdesktop's topmenu has WM_TRANSIENT_FOR
+                    {                                     // set pointing to the root window
+                    menubar = *it;                        // to recognize it here
+                    break;                                // Also, with the xroot hack in kdesktop,
+                    }                                     // there's no NET::Desktop window to be transient for
+            }
+        }
+
+//    kdDebug() << "CURRENT TOPMENU:" << menubar << ":" << active_client << endl;
+    if ( menubar )
+        {
+        if( active_client && !menubar->isOnDesktop( active_client->desktop()))
+            menubar->setDesktop( active_client->desktop());
+        menubar->hideClient( false );
+        topmenu_space->hide();
+        // make it appear like it's been raised manually - it's in the Dock layer anyway,
+        // and not raising it could mess up stacking order of topmenus within one application,
+        // and thus break raising of mainclients in raiseClient()
+        unconstrained_stacking_order.remove( menubar );
+        unconstrained_stacking_order.append( menubar );
+        }
+    else if( !block_desktop_menubar )
+        { // no topmenu active - show the space window, so that there's not empty space
+        topmenu_space->show();
+        }
+
+    // ... then hide the other ones. Avoids flickers.
+    for ( ClientList::ConstIterator it = clients.begin(); it != clients.end(); ++it) 
+        {
+        if( (*it)->isTopMenu() && (*it) != menubar )
+            (*it)->hideClient( true );
+        }
+    }
+
+
+void Workspace::updateToolWindows( bool also_hide )
+    {
+    // TODO what if Client's transiency/group changes? should this be called too? (I'm paranoid, am I not?)
+    if( !options->hideUtilityWindowsForInactive )
+        {
+        for( ClientList::ConstIterator it = clients.begin();
+             it != clients.end();
+             ++it )
+            (*it)->hideClient( false );
+        return;
+        }
+    const Group* group = NULL;
+    const Client* client = active_client;
+// Go up in transiency hiearchy, if the top is found, only tool transients for the top mainwindow
+// will be shown; if a group transient is group, all tools in the group will be shown
+    while( client != NULL )
+        {
+        if( !client->isTransient())
+            break;
+        if( client->groupTransient())
+            {
+            group = client->group();
+            break;
+            }
+        client = client->transientFor();
+        }
+    // use stacking order only to reduce flicker, it doesn't matter if block_stacking_updates == 0,
+    // i.e. if it's not up to date
+
+    // SELI but maybe it should - what if a new client has been added that's not in stacking order yet?
+    ClientList to_show, to_hide;
+    for( ClientList::ConstIterator it = stacking_order.begin();
+         it != stacking_order.end();
+         ++it )
+        {
+        if( (*it)->isUtility() || (*it)->isMenu() || (*it)->isToolbar())
+            {
+            bool show = true;
+            if( !(*it)->isTransient())
+                {
+                if( (*it)->group()->members().count() == 1 ) // has its own group, keep always visible
+                    show = true;
+                else if( client != NULL && (*it)->group() == client->group())
+                    show = true;
+                else
+                    show = false;
+                }
+            else
+                {
+                if( group != NULL && (*it)->group() == group )
+                    show = true;
+                else if( client != NULL && client->hasTransient( (*it), true ))
+                    show = true;
+                else
+                    show = false;
+                }
+            if( !show && also_hide )
+                {
+                const ClientList mainclients = (*it)->mainClients();
+                // don't hide utility windows which are standalone(?) or
+                // have e.g. kicker as mainwindow
+                if( mainclients.isEmpty())
+                    show = true;
+                for( ClientList::ConstIterator it2 = mainclients.begin();
+                     it2 != mainclients.end();
+                     ++it2 )
+                    {
+                    if( (*it2)->isSpecialWindow())
+                        show = true;
+                    }
+                if( !show )
+                    to_hide.append( *it );
+                }
+            if( show )
+                to_show.append( *it );
+            }
+        } // first show new ones, then hide
+    for( ClientList::ConstIterator it = to_show.fromLast();
+         it != to_show.end();
+         --it ) // from topmost
+        // TODO since this is in stacking order, the order of taskbar entries changes :(
+        (*it)->hideClient( false );
+    if( also_hide )
+        {
+        for( ClientList::ConstIterator it = to_hide.begin();
+             it != to_hide.end();
+             ++it ) // from bottommost
+            (*it)->hideClient( true );
+        updateToolWindowsTimer.stop();
+        }
+    else // setActiveClient() is after called with NULL client, quickly followed
+        {    // by setting a new client, which would result in flickering
+        updateToolWindowsTimer.start( 50, true );
+        }
+    }
+
+void Workspace::slotUpdateToolWindows()
+    {
+    updateToolWindows( true );
+    }
+
+/*!
+  Updates the current colormap according to the currently active client
+ */
+void Workspace::updateColormap()
+    {
+    Colormap cmap = default_colormap;
+    if ( activeClient() && activeClient()->colormap() != None )
+        cmap = activeClient()->colormap();
+    if ( cmap != installed_colormap ) 
+        {
+        XInstallColormap(qt_xdisplay(), cmap );
+        installed_colormap = cmap;
+        }
+    }
+
+void Workspace::reconfigure()
+    {
+    reconfigureTimer.start(200, true);
+    }
+
+
+void Workspace::slotSettingsChanged(int category)
+    {
+    kdDebug(1212) << "Workspace::slotSettingsChanged()" << endl;
+    if( category == (int) KApplication::SETTINGS_SHORTCUTS )
+        readShortcuts();
+    }
+
+/*!
+  Reread settings
+ */
+KWIN_PROCEDURE( CheckBorderSizesProcedure, cl->checkBorderSizes() );
+
+void Workspace::slotReconfigure()
+    {
+    kdDebug(1212) << "Workspace::slotReconfigure()" << endl;
+    reconfigureTimer.stop();
+
+    KGlobal::config()->reparseConfiguration();
+    unsigned long changed = options->updateSettings();
+    tab_box->reconfigure();
+    popupinfo->reconfigure();
+    initPositioning->reinitCascading( 0 );
+    readShortcuts();
+    forEachClient( CheckIgnoreFocusStealingProcedure());
+    updateToolWindows( true );
+
+    if( mgr->reset( changed ))
+        { // decorations need to be recreated
+#if 0 // This actually seems to make things worse now
+        TQWidget curtain;
+        curtain.setBackgroundMode( NoBackground );
+        curtain.setGeometry( TQApplication::desktop()->geometry() );
+        curtain.show();
+#endif
+        for( ClientList::ConstIterator it = clients.begin();
+                it != clients.end();
+                ++it )
+            {
+            (*it)->updateDecoration( true, true );
+            }
+        mgr->destroyPreviousPlugin();
+        }
+    else
+        {
+        forEachClient( CheckBorderSizesProcedure());
+        }
+
+    checkElectricBorders();
+
+    if( options->topMenuEnabled() && !managingTopMenus())
+        {
+        if( topmenu_selection->claim( false ))
+            setupTopMenuHandling();
+        else
+            lostTopMenuSelection();
+        }
+    else if( !options->topMenuEnabled() && managingTopMenus())
+        {
+        topmenu_selection->release();
+        lostTopMenuSelection();
+        }
+    topmenu_height = 0; // tqinvalidate used menu height
+    if( managingTopMenus())
+        {
+        updateTopMenuGeometry();
+        updateCurrentTopMenu();
+        }
+
+    loadWindowRules();
+    for( ClientList::Iterator it = clients.begin();
+         it != clients.end();
+         ++it )
+        {
+        (*it)->setupWindowRules( true );
+        (*it)->applyWindowRules();
+        discardUsedWindowRules( *it, false );
+        }
+
+    if (options->resetKompmgr) // need restart
+        {
+        bool tmp = options->useTranslucency;
+
+        // If kompmgr is already running, sending SIGUSR2 will force a reload of its settings
+        // Attempt to load the kompmgr pid file
+        const char *home;
+        struct passwd *p;
+        p = getpwuid(getuid());
+        if (p)
+            home = p->pw_dir;
+        else
+            home = getenv("HOME");
+        char *filename;
+        const char *configfile = "/.kompmgr.pid";
+        int n = strlen(home)+strlen(configfile)+1;
+        filename = (char*)malloc(n*sizeof(char));
+        memset(filename,0,n);
+        strcat(filename, home);
+        strcat(filename, configfile);
+
+        printf("reading '%s' as kompmgr pidfile\n\n", filename);
+
+        // Now that we did all that by way of introduction...read the file!
+        FILE *pFile;
+        char buffer[255];
+        pFile = fopen(filename, "r");
+        int kompmgrpid = 0;
+        if (pFile)
+            {
+            // obtain file size
+            fseek (pFile , 0 , SEEK_END);
+            unsigned long lSize = ftell (pFile);
+            if (lSize > 254)
+                lSize = 254;
+            rewind (pFile);
+            size_t result = fread (buffer, 1, lSize, pFile);
+            fclose(pFile);
+            kompmgrpid = atoi(buffer);
+            }
+
+        free(filename);
+        filename = NULL;
+
+        if (tmp)
+            {
+            if (kompmgrpid)
+                {
+                kill(kompmgrpid, SIGUSR2);
+                }
+            else
+                {
+                stopKompmgr();
+                TQTimer::singleShot( 200, this, TQT_SLOT(startKompmgr()) ); // wait some time to ensure system's ready for restart
+                }
+            }
+        else
+            {
+            if (kompmgrpid)
+                {
+                kill(kompmgrpid, SIGTERM);
+                }
+            else
+                {
+                stopKompmgr();
+                }
+            }
+        }
+    }
+
+void Workspace::loadDesktopSettings()
+    {
+    KConfig* c = KGlobal::config();
+    TQCString groupname;
+    if (screen_number == 0)
+        groupname = "Desktops";
+    else
+        groupname.sprintf("Desktops-screen-%d", screen_number);
+    KConfigGroupSaver saver(c,groupname);
+
+    int n = c->readNumEntry("Number", 4);
+    number_of_desktops = n;
+    delete workarea;
+    workarea = new TQRect[ n + 1 ];
+    delete screenarea;
+    screenarea = NULL;
+    rootInfo->setNumberOfDesktops( number_of_desktops );
+    desktop_focus_chain.resize( n );
+    // make it +1, so that it can be accessed as [1..numberofdesktops]
+    focus_chain.resize( n + 1 );
+    for(int i = 1; i <= n; i++) 
+        {
+        TQString s = c->readEntry(TQString("Name_%1").arg(i),
+                                i18n("Desktop %1").arg(i));
+        rootInfo->setDesktopName( i, s.utf8().data() );
+        desktop_focus_chain[i-1] = i;
+        }
+    }
+
+void Workspace::saveDesktopSettings()
+    {
+    KConfig* c = KGlobal::config();
+    TQCString groupname;
+    if (screen_number == 0)
+        groupname = "Desktops";
+    else
+        groupname.sprintf("Desktops-screen-%d", screen_number);
+    KConfigGroupSaver saver(c,groupname);
+
+    c->writeEntry("Number", number_of_desktops );
+    for(int i = 1; i <= number_of_desktops; i++) 
+        {
+        TQString s = desktopName( i );
+        TQString defaultvalue = i18n("Desktop %1").arg(i);
+        if ( s.isEmpty() ) 
+            {
+            s = defaultvalue;
+            rootInfo->setDesktopName( i, s.utf8().data() );
+            }
+
+        if (s != defaultvalue) 
+            {
+            c->writeEntry( TQString("Name_%1").arg(i), s );
+            }
+        else 
+            {
+            TQString currentvalue = c->readEntry(TQString("Name_%1").arg(i));
+            if (currentvalue != defaultvalue)
+                c->writeEntry( TQString("Name_%1").arg(i), "" );
+            }
+        }
+    }
+
+TQStringList Workspace::configModules(bool controlCenter)
+    {
+    TQStringList args;
+    args <<  "kde-twindecoration.desktop";
+    if (controlCenter)
+        args << "kde-twinoptions.desktop";
+    else if (kapp->authorizeControlModule("kde-twinoptions.desktop"))
+        args  << "twinactions" << "twinfocus" <<  "twinmoving" << "twinadvanced" << "twinrules" << "twintranslucency";
+    return args;
+    }
+
+void Workspace::configureWM()
+    {
+    KApplication::tdeinitExec( "kcmshell", configModules(false) );
+    }
+
+/*!
+  avoids managing a window with title \a title
+ */
+void Workspace::doNotManage( TQString title )
+    {
+    doNotManageList.append( title );
+    }
+
+/*!
+  Hack for java applets
+ */
+bool Workspace::isNotManaged( const TQString& title )
+    {
+    for ( TQStringList::Iterator it = doNotManageList.begin(); it != doNotManageList.end(); ++it ) 
+        {
+        TQRegExp r( (*it) );
+        if (r.search(title) != -1) 
+            {
+            doNotManageList.remove( it );
+            return TRUE;
+            }
+        }
+    return FALSE;
+    }
+
+/*!
+  Refreshes all the client windows
+ */
+void Workspace::refresh() 
+    {
+    TQWidget w;
+    w.setGeometry( TQApplication::desktop()->geometry() );
+    w.show();
+    w.hide();
+    TQApplication::flushX();
+    }
+
+/*!
+  During virt. desktop switching, desktop areas covered by windows that are
+  going to be hidden are first obscured by new windows with no background
+  ( i.e. transparent ) placed right below the windows. These invisible windows
+  are removed after the switch is complete.
+  Reduces desktop ( wallpaper ) repaints during desktop switching
+*/
+class ObscuringWindows
+    {
+    public:
+        ~ObscuringWindows();
+        void create( Client* c );
+    private:
+        TQValueList<Window> obscuring_windows;
+        static TQValueList<Window>* cached;
+        static unsigned int max_cache_size;
+    };
+
+TQValueList<Window>* ObscuringWindows::cached = 0;
+unsigned int ObscuringWindows::max_cache_size = 0;
+
+void ObscuringWindows::create( Client* c )
+    {
+    if( cached == 0 )
+        cached = new TQValueList<Window>;
+    Window obs_win;
+    XWindowChanges chngs;
+    int mask = CWSibling | CWStackMode;
+    if( cached->count() > 0 ) 
+        {
+        cached->remove( obs_win = cached->first());
+        chngs.x = c->x();
+        chngs.y = c->y();
+        chngs.width = c->width();
+        chngs.height = c->height();
+        mask |= CWX | CWY | CWWidth | CWHeight;
+        }
+    else 
+        {
+        XSetWindowAttributes a;
+        a.background_pixmap = None;
+        a.override_redirect = True;
+        obs_win = XCreateWindow( qt_xdisplay(), qt_xrootwin(), c->x(), c->y(),
+            c->width(), c->height(), 0, CopyFromParent, InputOutput,
+            CopyFromParent, CWBackPixmap | CWOverrideRedirect, &a );
+        }
+    chngs.sibling = c->frameId();
+    chngs.stack_mode = Below;
+    XConfigureWindow( qt_xdisplay(), obs_win, mask, &chngs );
+    XMapWindow( qt_xdisplay(), obs_win );
+    obscuring_windows.append( obs_win );
+    }
+
+ObscuringWindows::~ObscuringWindows()
+    {
+    max_cache_size = TQMAX( max_cache_size, obscuring_windows.count() + 4 ) - 1;
+    for( TQValueList<Window>::ConstIterator it = obscuring_windows.begin();
+         it != obscuring_windows.end();
+         ++it ) 
+        {
+        XUnmapWindow( qt_xdisplay(), *it );
+        if( cached->count() < max_cache_size )
+            cached->prepend( *it );
+        else
+            XDestroyWindow( qt_xdisplay(), *it );
+        }
+    }
+
+
+/*!
+  Sets the current desktop to \a new_desktop
+
+  Shows/Hides windows according to the stacking order and finally
+  propages the new desktop to the world
+ */
+bool Workspace::setCurrentDesktop( int new_desktop )
+    {
+    if (new_desktop < 1 || new_desktop > number_of_desktops )
+        return false;
+
+    closeActivePopup();
+    ++block_focus;
+// TODO    Q_ASSERT( block_stacking_updates == 0 ); // make sure stacking_order is up to date
+    StackingUpdatesBlocker blocker( this );
+
+    int old_desktop = current_desktop;
+    if (new_desktop != current_desktop) 
+        {
+        ++block_showing_desktop;
+        /*
+          optimized Desktop switching: unmapping done from back to front
+          mapping done from front to back => less exposure events
+        */
+        Notify::raise((Notify::Event) (Notify::DesktopChange+new_desktop));
+
+        ObscuringWindows obs_wins;
+
+        current_desktop = new_desktop; // change the desktop (so that Client::updateVisibility() works)
+
+        bool desktopHasCompositing = kapp->isCompositionManagerAvailable();	// Technically I should call isX11CompositionAvailable(), but it isn't initialized via my kapp constructir, and in this case it doesn't really matter anyway....
+        if (!desktopHasCompositing) {
+            // If composition is not in use then we can hide the old windows before showing the new ones
+            for ( ClientList::ConstIterator it = stacking_order.begin(); it != stacking_order.end(); ++it) {
+                if ( !(*it)->isOnDesktop( new_desktop ) && (*it) != movingClient )
+                {
+                    if( (*it)->isShown( true ) && (*it)->isOnDesktop( old_desktop )) {
+                        obs_wins.create( *it );
+                    }
+                    (*it)->updateVisibility();
+                }
+            }
+        }
+
+        rootInfo->setCurrentDesktop( current_desktop ); // now propagate the change, after hiding, before showing
+
+        if( movingClient && !movingClient->isOnDesktop( new_desktop ))
+            movingClient->setDesktop( new_desktop );
+
+        for ( ClientList::ConstIterator it = stacking_order.fromLast(); it != stacking_order.end(); --it) {
+            if ( (*it)->isOnDesktop( new_desktop ) ) {
+                (*it)->updateVisibility();
+            }
+        }
+
+        if (desktopHasCompositing) {
+            // If composition is in use then we cannot hide the old windows before showing the new ones, 
+            // unless you happen to like the "flicker annoyingly to desktop" effect... :-P
+            XSync( qt_xdisplay(), false);	// Make absolutely certain all new windows are shown before hiding the old ones
+            for ( ClientList::ConstIterator it = stacking_order.begin(); it != stacking_order.end(); ++it) {
+                if ( !(*it)->isOnDesktop( new_desktop ) && (*it) != movingClient )
+                {
+                    if( (*it)->isShown( true ) && (*it)->isOnDesktop( old_desktop )) {
+                        obs_wins.create( *it );
+                    }
+                    (*it)->updateVisibility();
+                }
+            }
+        }
+
+        --block_showing_desktop;
+        if( showingDesktop()) // do this only after desktop change to avoid flicker
+            resetShowingDesktop( false );
+        }
+
+    // restore the focus on this desktop
+    --block_focus;
+    Client* c = 0;
+
+    if ( options->focusPolicyIsReasonable()) 
+        {
+        // Search in focus chain
+        if ( movingClient != NULL && active_client == movingClient
+            && focus_chain[currentDesktop()].contains( active_client )
+            && active_client->isShown( true ) && active_client->isOnCurrentDesktop())
+            {
+            c = active_client; // the requestFocus below will fail, as the client is already active
+            }
+        if ( !c ) 
+            {
+            for( ClientList::ConstIterator it = focus_chain[currentDesktop()].fromLast();
+                 it != focus_chain[currentDesktop()].end();
+                 --it )
+                {
+                if ( (*it)->isShown( false ) && (*it)->isOnCurrentDesktop())
+                    {
+                    c = *it;
+                    break;
+                    }
+                }
+            }
+        }
+
+    //if "unreasonable focus policy"
+    // and active_client is on_all_desktops and under mouse (hence == old_active_client),
+    // conserve focus (thanks to Volker Schatz <V.Schatz at thphys.uni-heidelberg.de>)
+    else if( active_client && active_client->isShown( true ) && active_client->isOnCurrentDesktop())
+      c = active_client;
+
+    if( c == NULL && !desktops.isEmpty())
+        c = findDesktop( true, currentDesktop());
+
+    if( c != active_client )
+        setActiveClient( NULL, Allowed );
+
+    if ( c ) 
+        requestFocus( c );
+    else 
+        focusToNull();
+
+    updateCurrentTopMenu();
+
+    // Update focus chain:
+    //  If input: chain = { 1, 2, 3, 4 } and current_desktop = 3,
+    //   Output: chain = { 3, 1, 2, 4 }.
+//    kdDebug(1212) << TQString("Switching to desktop #%1, at focus_chain[currentDesktop()] index %2\n")
+//      .arg(currentDesktop()).arg(desktop_focus_chain.find( currentDesktop() ));
+    for( int i = desktop_focus_chain.find( currentDesktop() ); i > 0; i-- )
+        desktop_focus_chain[i] = desktop_focus_chain[i-1];
+    desktop_focus_chain[0] = currentDesktop();
+
+//    TQString s = "desktop_focus_chain[] = { ";
+//    for( uint i = 0; i < desktop_focus_chain.size(); i++ )
+//        s += TQString::number(desktop_focus_chain[i]) + ", ";
+//    kdDebug(1212) << s << "}\n";
+
+    if( old_desktop != 0 )  // not for the very first time
+        popupinfo->showInfo( desktopName(currentDesktop()) );
+    return true;
+    }
+
+// called only from DCOP
+void Workspace::nextDesktop()
+    {
+    int desktop = currentDesktop() + 1;
+    setCurrentDesktop(desktop > numberOfDesktops() ? 1 : desktop);
+    }
+
+// called only from DCOP
+void Workspace::previousDesktop()
+    {
+    int desktop = currentDesktop() - 1;
+    setCurrentDesktop(desktop > 0 ? desktop : numberOfDesktops());
+    }
+
+int Workspace::desktopToRight( int desktop ) const
+    {
+    int x,y;
+    calcDesktopLayout(x,y);
+    int dt = desktop-1;
+    if (layoutOrientation == Qt::Vertical)
+        {
+        dt += y;
+        if ( dt >= numberOfDesktops() ) 
+            {
+            if ( options->rollOverDesktops )
+              dt -= numberOfDesktops();
+            else
+              return desktop;
+            }
+        }
+    else
+        {
+        int d = (dt % x) + 1;
+        if ( d >= x ) 
+            {
+            if ( options->rollOverDesktops )
+              d -= x;
+            else
+              return desktop;
+            }
+        dt = dt - (dt % x) + d;
+        }
+    return dt+1;
+    }
+
+int Workspace::desktopToLeft( int desktop ) const
+    {
+    int x,y;
+    calcDesktopLayout(x,y);
+    int dt = desktop-1;
+    if (layoutOrientation == Qt::Vertical)
+        {
+        dt -= y;
+        if ( dt < 0 ) 
+            {
+            if ( options->rollOverDesktops )
+              dt += numberOfDesktops();
+            else
+              return desktop;
+            }
+        }
+    else
+        {
+        int d = (dt % x) - 1;
+        if ( d < 0 ) 
+            {
+            if ( options->rollOverDesktops )
+              d += x;
+            else
+              return desktop;
+            }
+        dt = dt - (dt % x) + d;
+        }
+    return dt+1;
+    }
+
+int Workspace::desktopUp( int desktop ) const
+    {
+    int x,y;
+    calcDesktopLayout(x,y);
+    int dt = desktop-1;
+    if (layoutOrientation == Qt::Horizontal)
+        {
+        dt -= x;
+        if ( dt < 0 ) 
+            {
+            if ( options->rollOverDesktops )
+              dt += numberOfDesktops();
+            else
+              return desktop;
+            }
+        }
+    else
+        {
+        int d = (dt % y) - 1;
+        if ( d < 0 ) 
+            {
+            if ( options->rollOverDesktops )
+              d += y;
+            else
+              return desktop;
+            }
+        dt = dt - (dt % y) + d;
+        }
+    return dt+1;
+    }
+
+int Workspace::desktopDown( int desktop ) const
+    {
+    int x,y;
+    calcDesktopLayout(x,y);
+    int dt = desktop-1;
+    if (layoutOrientation == Qt::Horizontal)
+        {
+        dt += x;
+        if ( dt >= numberOfDesktops() ) 
+            {
+            if ( options->rollOverDesktops )
+              dt -= numberOfDesktops();
+            else
+              return desktop;
+            }
+        }
+    else
+        {
+        int d = (dt % y) + 1;
+        if ( d >= y ) 
+            {
+            if ( options->rollOverDesktops )
+              d -= y;
+            else
+              return desktop;
+            }
+        dt = dt - (dt % y) + d;
+        }
+    return dt+1;
+    }
+
+
+/*!
+  Sets the number of virtual desktops to \a n
+ */
+void Workspace::setNumberOfDesktops( int n )
+    {
+    if ( n == number_of_desktops )
+        return;
+    int old_number_of_desktops = number_of_desktops;
+    number_of_desktops = n;
+
+    if( currentDesktop() > numberOfDesktops())
+        setCurrentDesktop( numberOfDesktops());
+
+    // if increasing the number, do the resizing now,
+    // otherwise after the moving of windows to still existing desktops
+    if( old_number_of_desktops < number_of_desktops ) 
+        {
+        rootInfo->setNumberOfDesktops( number_of_desktops );
+        NETPoint* viewports = new NETPoint[ number_of_desktops ];
+        rootInfo->setDesktopViewport( number_of_desktops, *viewports );
+        delete[] viewports;
+        updateClientArea( true );
+        focus_chain.resize( number_of_desktops + 1 );
+        }
+
+    // if the number of desktops decreased, move all
+    // windows that would be hidden to the last visible desktop
+    if( old_number_of_desktops > number_of_desktops ) 
+        {
+        for( ClientList::ConstIterator it = clients.begin();
+              it != clients.end();
+              ++it) 
+            {
+            if( !(*it)->isOnAllDesktops() && (*it)->desktop() > numberOfDesktops())
+                sendClientToDesktop( *it, numberOfDesktops(), true );
+            }
+        }
+    if( old_number_of_desktops > number_of_desktops ) 
+        {
+        rootInfo->setNumberOfDesktops( number_of_desktops );
+        NETPoint* viewports = new NETPoint[ number_of_desktops ];
+        rootInfo->setDesktopViewport( number_of_desktops, *viewports );
+        delete[] viewports;
+        updateClientArea( true );
+        focus_chain.resize( number_of_desktops + 1 );
+        }
+
+    saveDesktopSettings();
+
+    // Resize and reset the desktop focus chain.
+    desktop_focus_chain.resize( n );
+    for( int i = 0; i < (int)desktop_focus_chain.size(); i++ )
+        desktop_focus_chain[i] = i+1;
+    }
+
+/*!
+  Sends client \a c to desktop \a desk.
+
+  Takes care of transients as well.
+ */
+void Workspace::sendClientToDesktop( Client* c, int desk, bool dont_activate )
+    {
+    bool was_on_desktop = c->isOnDesktop( desk ) || c->isOnAllDesktops();
+    c->setDesktop( desk );
+    if ( c->desktop() != desk ) // no change or desktop forced
+        return;
+    desk = c->desktop(); // Client did range checking
+
+    if ( c->isOnDesktop( currentDesktop() ) )
+        {
+        if ( c->wantsTabFocus() && options->focusPolicyIsReasonable()
+            && !was_on_desktop // for stickyness changes
+            && !dont_activate )
+            requestFocus( c );
+        else
+            restackClientUnderActive( c );
+        }
+    else 
+        {
+        raiseClient( c );
+        }
+
+    ClientList transients_stacking_order = ensureStackingOrder( c->transients());
+    for( ClientList::ConstIterator it = transients_stacking_order.begin();
+         it != transients_stacking_order.end();
+         ++it )
+        sendClientToDesktop( *it, desk, dont_activate );
+    updateClientArea();
+    }
+
+int Workspace::numScreens() const
+    {
+    if( !options->xineramaEnabled )
+        return 0;
+    return tqApp->desktop()->numScreens();
+    }
+
+int Workspace::activeScreen() const
+    {
+    if( !options->xineramaEnabled )
+        return 0;
+    if( !options->activeMouseScreen )
+        {
+        if( activeClient() != NULL && !activeClient()->isOnScreen( active_screen ))
+            return tqApp->desktop()->screenNumber( activeClient()->geometry().center());
+        return active_screen;
+        }
+    return tqApp->desktop()->screenNumber( TQCursor::pos());
+    }
+
+// check whether a client moved completely out of what's considered the active screen,
+// if yes, set a new active screen
+void Workspace::checkActiveScreen( const Client* c )
+    {
+    if( !options->xineramaEnabled )
+        return;
+    if( !c->isActive())
+        return;
+    if( !c->isOnScreen( active_screen ))
+        active_screen = c->screen();
+    }
+
+// called e.g. when a user clicks on a window, set active screen to be the screen
+// where the click occured
+void Workspace::setActiveScreenMouse( TQPoint mousepos )
+    {
+    if( !options->xineramaEnabled )
+        return;
+    active_screen = tqApp->desktop()->screenNumber( mousepos );
+    }
+
+TQRect Workspace::screenGeometry( int screen ) const
+    {
+    if (( !options->xineramaEnabled ) || (kapp->desktop()->numScreens() < 2))
+        return tqApp->desktop()->geometry();
+    return tqApp->desktop()->screenGeometry( screen );
+    }
+
+int Workspace::screenNumber( TQPoint pos ) const
+    {
+    if( !options->xineramaEnabled )
+        return 0;
+    return tqApp->desktop()->screenNumber( pos );
+    }
+
+void Workspace::sendClientToScreen( Client* c, int screen )
+    {
+    if( c->screen() == screen ) // don't use isOnScreen(), that's true even when only partially
+        return;
+    GeometryUpdatesPostponer blocker( c );
+    TQRect old_sarea = clientArea( MaximizeArea, c );
+    TQRect sarea = clientArea( MaximizeArea, screen, c->desktop());
+    c->setGeometry( sarea.x() - old_sarea.x() + c->x(), sarea.y() - old_sarea.y() + c->y(),
+        c->size().width(), c->size().height());
+    c->checkWorkspacePosition();
+    ClientList transients_stacking_order = ensureStackingOrder( c->transients());
+    for( ClientList::ConstIterator it = transients_stacking_order.begin();
+         it != transients_stacking_order.end();
+         ++it )
+        sendClientToScreen( *it, screen );
+    if( c->isActive())
+        active_screen = screen;
+    }
+
+
+void Workspace::setDesktopLayout( int, int, int )
+    { // DCOP-only, unused
+    }
+
+void Workspace::updateDesktopLayout()
+    {
+    // rootInfo->desktopLayoutCorner(); // I don't find this worth bothering, feel free to
+    layoutOrientation = ( rootInfo->desktopLayoutOrientation() == NET::OrientationHorizontal
+        ? Qt::Horizontal : Qt::Vertical );
+    layoutX = rootInfo->desktopLayoutColumnsRows().width();
+    layoutY = rootInfo->desktopLayoutColumnsRows().height();
+    if( layoutX == 0 && layoutY == 0 ) // not given, set default layout
+        layoutY = 2;
+    }
+
+void Workspace::calcDesktopLayout(int &x, int &y) const
+    {
+    x = layoutX; // <= 0 means compute it from the other and total number of desktops
+    y = layoutY;
+    if((x <= 0) && (y > 0))
+       x = (numberOfDesktops()+y-1) / y;
+    else if((y <=0) && (x > 0))
+       y = (numberOfDesktops()+x-1) / x;
+
+    if(x <=0)
+       x = 1;
+    if (y <= 0)
+       y = 1;
+    }
+
+/*!
+  Check whether \a w is a system tray window. If so, add it to the respective
+  datastructures and propagate it to the world.
+ */
+bool Workspace::addSystemTrayWin( WId w )
+    {
+    if ( systemTrayWins.contains( w ) )
+        return TRUE;
+
+    NETWinInfo ni( qt_xdisplay(), w, root, NET::WMKDESystemTrayWinFor );
+    WId trayWinFor = ni.kdeSystemTrayWinFor();
+    if ( !trayWinFor )
+        return FALSE;
+    systemTrayWins.append( SystemTrayWindow( w, trayWinFor ) );
+    XSelectInput( qt_xdisplay(), w,
+                  StructureNotifyMask
+                  );
+    XAddToSaveSet( qt_xdisplay(), w );
+    propagateSystemTrayWins();
+    return TRUE;
+    }
+
+/*!
+  Check whether \a w is a system tray window. If so, remove it from
+  the respective datastructures and propagate this to the world.
+ */
+bool Workspace::removeSystemTrayWin( WId w, bool check )
+    {
+    if ( !systemTrayWins.contains( w ) )
+        return FALSE;
+    if( check )
+        {
+    // When getting UnmapNotify, it's not clear if it's the systray
+    // reparenting the window into itself, or if it's the window
+    // going away. This is obviously a flaw in the design, and we were
+    // just lucky it worked for so long. Kicker's systray temporarily
+    // sets _KDE_SYSTEM_TRAY_EMBEDDING property on the window while
+    // embedding it, allowing KWin to figure out. Kicker just mustn't
+    // crash before removing it again ... *shrug* .
+        int num_props;
+        Atom* props = XListProperties( qt_xdisplay(), w, &num_props );
+        if( props != NULL )
+            {
+            for( int i = 0;
+                 i < num_props;
+                 ++i )
+                if( props[ i ] == atoms->kde_system_tray_embedding )
+                    {
+                    XFree( props );
+                    return false;
+                    }
+            XFree( props );
+            }
+        }
+    systemTrayWins.remove( w );
+    XRemoveFromSaveSet (qt_xdisplay (), w);
+    propagateSystemTrayWins();
+    return TRUE;
+    }
+
+
+/*!
+  Propagates the systemTrayWins to the world
+ */
+void Workspace::propagateSystemTrayWins()
+    {
+    Window *cl = new Window[ systemTrayWins.count()];
+
+    int i = 0;
+    for ( SystemTrayWindowList::ConstIterator it = systemTrayWins.begin(); it != systemTrayWins.end(); ++it ) 
+        {
+        cl[i++] =  (*it).win;
+        }
+
+    rootInfo->setKDESystemTrayWindows( cl, i );
+    delete [] cl;
+    }
+
+
+void Workspace::killWindowId( Window window_to_kill )
+    {
+    if( window_to_kill == None )
+        return;
+    Window window = window_to_kill;
+    Client* client = NULL;
+    for(;;) 
+        {
+        client = findClient( FrameIdMatchPredicate( window ));
+        if( client != NULL ) // found the client
+            break;
+        Window parent, root;
+        Window* children;
+        unsigned int children_count;
+        XQueryTree( qt_xdisplay(), window, &root, &parent, &children, &children_count );
+        if( children != NULL )
+            XFree( children );
+        if( window == root ) // we didn't find the client, probably an override-redirect window
+            break;
+        window = parent; // go up
+        }
+    if( client != NULL )
+        client->killWindow();
+    else
+        XKillClient( qt_xdisplay(), window_to_kill );
+    }
+
+
+void Workspace::sendPingToWindow( Window window, Time timestamp )
+    {
+    rootInfo->sendPing( window, timestamp );
+    }
+
+void Workspace::sendTakeActivity( Client* c, Time timestamp, long flags )
+    {
+    rootInfo->takeActivity( c->window(), timestamp, flags );
+    pending_take_activity = c;
+    }
+
+
+/*!
+  Takes a screenshot of the current window and puts it in the clipboard.
+*/
+void Workspace::slotGrabWindow()
+    {
+    if ( active_client ) 
+        {
+        TQPixmap snapshot = TQPixmap::grabWindow( active_client->frameId() );
+
+	//No XShape - no work.
+        if( Shape::available()) 
+            {
+	    //As the first step, get the mask from XShape.
+            int count, order;
+            XRectangle* rects = XShapeGetRectangles( qt_xdisplay(), active_client->frameId(),
+                                                     ShapeBounding, &count, &order);
+	    //The ShapeBounding region is the outermost tqshape of the window;
+	    //ShapeBounding - ShapeClipping is defined to be the border.
+	    //Since the border area is part of the window, we use bounding
+	    // to limit our work region
+            if (rects) 
+                {
+		//Create a TQRegion from the rectangles describing the bounding mask.
+                TQRegion contents;
+                for (int pos = 0; pos < count; pos++)
+                    contents += TQRegion(rects[pos].x, rects[pos].y,
+                                        rects[pos].width, rects[pos].height);
+                XFree(rects);
+
+		//Create the bounding box.
+                TQRegion bbox(0, 0, snapshot.width(), snapshot.height());
+
+		//Get the masked away area.
+                TQRegion maskedAway = bbox - contents;
+                TQMemArray<TQRect> maskedAwayRects = maskedAway.tqrects();
+
+		//Construct a bitmap mask from the rectangles
+                TQBitmap mask( snapshot.width(), snapshot.height());
+                TQPainter p(&mask);
+                p.fillRect(0, 0, mask.width(), mask.height(), Qt::color1);
+                for (uint pos = 0; pos < maskedAwayRects.count(); pos++)
+                    p.fillRect(maskedAwayRects[pos], Qt::color0);
+                p.end();
+                snapshot.setMask(mask);
+                }
+            }
+
+        TQClipboard *cb = TQApplication::tqclipboard();
+        cb->setPixmap( snapshot );
+        }
+    else
+        slotGrabDesktop();
+    }
+
+/*!
+  Takes a screenshot of the whole desktop and puts it in the clipboard.
+*/
+void Workspace::slotGrabDesktop()
+    {
+    TQPixmap p = TQPixmap::grabWindow( qt_xrootwin() );
+    TQClipboard *cb = TQApplication::tqclipboard();
+    cb->setPixmap( p );
+    }
+
+
+/*!
+  Invokes keyboard mouse emulation
+ */
+void Workspace::slotMouseEmulation()
+    {
+
+    if ( mouse_emulation ) 
+        {
+        XUngrabKeyboard(qt_xdisplay(), GET_QT_X_TIME());
+        mouse_emulation = FALSE;
+        return;
+        }
+
+    if ( XGrabKeyboard(qt_xdisplay(),
+                       root, FALSE,
+                       GrabModeAsync, GrabModeAsync,
+                       GET_QT_X_TIME()) == GrabSuccess ) 
+        {
+        mouse_emulation = TRUE;
+        mouse_emulation_state = 0;
+        mouse_emulation_window = 0;
+        }
+    }
+
+/*!
+  Returns the child window under the mouse and activates the
+  respective client if necessary.
+
+  Auxiliary function for the mouse emulation system.
+ */
+WId Workspace::getMouseEmulationWindow()
+    {
+    Window root;
+    Window child = qt_xrootwin();
+    int root_x, root_y, lx, ly;
+    uint state;
+    Window w;
+    Client * c = 0;
+    do 
+        {
+        w = child;
+        if (!c)
+            c = findClient( FrameIdMatchPredicate( w ));
+        XQueryPointer( qt_xdisplay(), w, &root, &child,
+                       &root_x, &root_y, &lx, &ly, &state );
+        } while  ( child != None && child != w );
+
+    if ( c && !c->isActive() )
+        activateClient( c );
+    return (WId) w;
+    }
+
+/*!
+  Sends a faked mouse event to the specified window. Returns the new button state.
+ */
+unsigned int Workspace::sendFakedMouseEvent( TQPoint pos, WId w, MouseEmulation type, int button, unsigned int state )
+    {
+    if ( !w )
+        return state;
+    TQWidget* widget = TQWidget::find( w );
+    if ( (!widget ||  widget->inherits(TQTOOLBUTTON_OBJECT_NAME_STRING) ) && !findClient( WindowMatchPredicate( w )) ) 
+        {
+        int x, y;
+        Window xw;
+        XTranslateCoordinates( qt_xdisplay(), qt_xrootwin(), w, pos.x(), pos.y(), &x, &y, &xw );
+        if ( type == EmuMove ) 
+            { // motion notify events
+            XEvent e;
+            e.type = MotionNotify;
+            e.xmotion.window = w;
+            e.xmotion.root = qt_xrootwin();
+            e.xmotion.subwindow = w;
+            e.xmotion.time = GET_QT_X_TIME();
+            e.xmotion.x = x;
+            e.xmotion.y = y;
+            e.xmotion.x_root = pos.x();
+            e.xmotion.y_root = pos.y();
+            e.xmotion.state = state;
+            e.xmotion.is_hint = NotifyNormal;
+            XSendEvent( qt_xdisplay(), w, TRUE, ButtonMotionMask, &e );
+            }
+        else 
+            {
+            XEvent e;
+            e.type = type == EmuRelease ? ButtonRelease : ButtonPress;
+            e.xbutton.window = w;
+            e.xbutton.root = qt_xrootwin();
+            e.xbutton.subwindow = w;
+            e.xbutton.time = GET_QT_X_TIME();
+            e.xbutton.x = x;
+            e.xbutton.y = y;
+            e.xbutton.x_root = pos.x();
+            e.xbutton.y_root = pos.y();
+            e.xbutton.state = state;
+            e.xbutton.button = button;
+            XSendEvent( qt_xdisplay(), w, TRUE, ButtonPressMask, &e );
+
+            if ( type == EmuPress ) 
+                {
+                switch ( button ) 
+                    {
+                    case 2:
+                        state |= Button2Mask;
+                        break;
+                    case 3:
+                        state |= Button3Mask;
+                        break;
+                    default: // 1
+                        state |= Button1Mask;
+                        break;
+                    }
+                }
+            else 
+                {
+                switch ( button ) 
+                    {
+                    case 2:
+                        state &= ~Button2Mask;
+                        break;
+                    case 3:
+                        state &= ~Button3Mask;
+                        break;
+                    default: // 1
+                        state &= ~Button1Mask;
+                        break;
+                    }
+                }
+            }
+        }
+    return state;
+    }
+
+/*!
+  Handles keypress event during mouse emulation
+ */
+bool Workspace::keyPressMouseEmulation( XKeyEvent& ev )
+    {
+    if ( root != qt_xrootwin() )
+        return FALSE;
+    int kc = XKeycodeToKeysym(qt_xdisplay(), ev.keycode, 0);
+    int km = ev.state & (ControlMask | Mod1Mask | ShiftMask);
+
+    bool is_control = km & ControlMask;
+    bool is_alt = km & Mod1Mask;
+    bool is_shift = km & ShiftMask;
+    int delta = is_control?1:is_alt?32:8;
+    TQPoint pos = TQCursor::pos();
+
+    switch ( kc ) 
+        {
+        case XK_Left:
+        case XK_KP_Left:
+            pos.rx() -= delta;
+            break;
+        case XK_Right:
+        case XK_KP_Right:
+            pos.rx() += delta;
+            break;
+        case XK_Up:
+        case XK_KP_Up:
+            pos.ry() -= delta;
+            break;
+        case XK_Down:
+        case XK_KP_Down:
+            pos.ry() += delta;
+            break;
+        case XK_F1:
+            if ( !mouse_emulation_state )
+                mouse_emulation_window = getMouseEmulationWindow();
+            if ( (mouse_emulation_state & Button1Mask) == 0 )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuPress, Button1, mouse_emulation_state );
+            if ( !is_shift )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button1, mouse_emulation_state );
+            break;
+        case XK_F2:
+            if ( !mouse_emulation_state )
+                mouse_emulation_window = getMouseEmulationWindow();
+            if ( (mouse_emulation_state & Button2Mask) == 0 )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuPress, Button2, mouse_emulation_state );
+            if ( !is_shift )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button2, mouse_emulation_state );
+            break;
+        case XK_F3:
+            if ( !mouse_emulation_state )
+                mouse_emulation_window = getMouseEmulationWindow();
+            if ( (mouse_emulation_state & Button3Mask) == 0 )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuPress, Button3, mouse_emulation_state );
+            if ( !is_shift )
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button3, mouse_emulation_state );
+            break;
+        case XK_Return:
+        case XK_space:
+        case XK_KP_Enter:
+        case XK_KP_Space: 
+            {
+            if ( !mouse_emulation_state ) 
+                {
+            // nothing was pressed, fake a LMB click
+                mouse_emulation_window = getMouseEmulationWindow();
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuPress, Button1, mouse_emulation_state );
+                mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button1, mouse_emulation_state );
+                }
+            else 
+                { // release all
+                if ( mouse_emulation_state & Button1Mask )
+                    mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button1, mouse_emulation_state );
+                if ( mouse_emulation_state & Button2Mask )
+                    mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button2, mouse_emulation_state );
+                if ( mouse_emulation_state & Button3Mask )
+                    mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuRelease, Button3, mouse_emulation_state );
+                }
+            }
+    // fall through
+        case XK_Escape:
+            XUngrabKeyboard(qt_xdisplay(), GET_QT_X_TIME());
+            mouse_emulation = FALSE;
+            return TRUE;
+        default:
+            return FALSE;
+        }
+
+    TQCursor::setPos( pos );
+    if ( mouse_emulation_state )
+        mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuMove, 0,  mouse_emulation_state );
+    return TRUE;
+
+    }
+
+/*!
+  Returns the workspace's desktop widget. The desktop widget is
+  sometimes required by clients to draw on it, for example outlines on
+  moving or resizing.
+ */
+TQWidget* Workspace::desktopWidget()
+    {
+    return desktop_widget;
+    }
+
+//Delayed focus functions
+void Workspace::delayFocus()
+    {
+    requestFocus( delayfocus_client );
+    cancelDelayFocus();
+    }
+    
+void Workspace::requestDelayFocus( Client* c )
+    {
+    delayfocus_client = c;
+    delete delayFocusTimer;
+    delayFocusTimer = new TQTimer( this );
+    connect( delayFocusTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( delayFocus() ) );
+    delayFocusTimer->start( options->delayFocusInterval, TRUE  );
+    }
+    
+void Workspace::cancelDelayFocus()
+    {
+    delete delayFocusTimer;
+    delayFocusTimer = 0;
+    }
+
+// Electric Borders
+//========================================================================//
+// Electric Border Window management. Electric borders allow a user
+// to change the virtual desktop by moving the mouse pointer to the
+// borders. Technically this is done with input only windows. Since
+// electric borders can be switched on and off, we have these two
+// functions to create and destroy them.
+void Workspace::checkElectricBorders( bool force )
+    {
+    if( force )
+        destroyBorderWindows();
+    
+    electric_current_border = 0;
+
+    TQRect r = TQApplication::desktop()->geometry();
+    electricTop = r.top();
+    electricBottom = r.bottom();
+    electricLeft = r.left();
+    electricRight = r.right();
+
+    if (options->electricBorders() == Options::ElectricAlways)
+       createBorderWindows();
+    else
+       destroyBorderWindows();
+    }
+
+void Workspace::createBorderWindows()
+    {
+    if ( electric_have_borders )
+        return;
+
+    electric_have_borders = true;
+
+    TQRect r = TQApplication::desktop()->geometry();
+    XSetWindowAttributes attributes;
+    unsigned long valuemask;
+    attributes.override_redirect = True;
+    attributes.event_mask =  ( EnterWindowMask | LeaveWindowMask );
+    valuemask=  (CWOverrideRedirect | CWEventMask | CWCursor );
+    attributes.cursor = XCreateFontCursor(qt_xdisplay(),
+                                          XC_sb_up_arrow);
+    electric_top_border = XCreateWindow (qt_xdisplay(), qt_xrootwin(),
+                                0,0,
+                                r.width(),1,
+                                0,
+                                CopyFromParent, InputOnly,
+                                CopyFromParent,
+                                valuemask, &attributes);
+    XMapWindow(qt_xdisplay(), electric_top_border);
+
+    attributes.cursor = XCreateFontCursor(qt_xdisplay(),
+                                          XC_sb_down_arrow);
+    electric_bottom_border = XCreateWindow (qt_xdisplay(), qt_xrootwin(),
+                                   0,r.height()-1,
+                                   r.width(),1,
+                                   0,
+                                   CopyFromParent, InputOnly,
+                                   CopyFromParent,
+                                   valuemask, &attributes);
+    XMapWindow(qt_xdisplay(), electric_bottom_border);
+
+    attributes.cursor = XCreateFontCursor(qt_xdisplay(),
+                                          XC_sb_left_arrow);
+    electric_left_border = XCreateWindow (qt_xdisplay(), qt_xrootwin(),
+                                 0,0,
+                                 1,r.height(),
+                                 0,
+                                 CopyFromParent, InputOnly,
+                                 CopyFromParent,
+                                 valuemask, &attributes);
+    XMapWindow(qt_xdisplay(), electric_left_border);
+
+    attributes.cursor = XCreateFontCursor(qt_xdisplay(),
+                                          XC_sb_right_arrow);
+    electric_right_border = XCreateWindow (qt_xdisplay(), qt_xrootwin(),
+                                  r.width()-1,0,
+                                  1,r.height(),
+                                  0,
+                                  CopyFromParent, InputOnly,
+                                  CopyFromParent,
+                                  valuemask, &attributes);
+    XMapWindow(qt_xdisplay(),  electric_right_border);
+    // Set XdndAware on the windows, so that DND enter events are received (#86998)
+    Atom version = 4; // XDND version
+    XChangeProperty( qt_xdisplay(), electric_top_border, atoms->xdnd_aware, XA_ATOM,
+        32, PropModeReplace, ( unsigned char* )&version, 1 );
+    XChangeProperty( qt_xdisplay(), electric_bottom_border, atoms->xdnd_aware, XA_ATOM,
+        32, PropModeReplace, ( unsigned char* )&version, 1 );
+    XChangeProperty( qt_xdisplay(), electric_left_border, atoms->xdnd_aware, XA_ATOM,
+        32, PropModeReplace, ( unsigned char* )&version, 1 );
+    XChangeProperty( qt_xdisplay(), electric_right_border, atoms->xdnd_aware, XA_ATOM,
+        32, PropModeReplace, ( unsigned char* )&version, 1 );
+    }
+
+
+// Electric Border Window management. Electric borders allow a user
+// to change the virtual desktop by moving the mouse pointer to the
+// borders. Technically this is done with input only windows. Since
+// electric borders can be switched on and off, we have these two
+// functions to create and destroy them.
+void Workspace::destroyBorderWindows()
+    {
+    if( !electric_have_borders)
+      return;
+
+    electric_have_borders = false;
+
+    if(electric_top_border)
+      XDestroyWindow(qt_xdisplay(),electric_top_border);
+    if(electric_bottom_border)
+      XDestroyWindow(qt_xdisplay(),electric_bottom_border);
+    if(electric_left_border)
+      XDestroyWindow(qt_xdisplay(),electric_left_border);
+    if(electric_right_border)
+      XDestroyWindow(qt_xdisplay(),electric_right_border);
+
+    electric_top_border    = None;
+    electric_bottom_border = None;
+    electric_left_border   = None;
+    electric_right_border  = None;
+    }
+
+void Workspace::clientMoved(const TQPoint &pos, Time now)
+    {
+    if (options->electricBorders() == Options::ElectricDisabled)
+       return;
+
+    if ((pos.x() != electricLeft) &&
+        (pos.x() != electricRight) &&
+        (pos.y() != electricTop) &&
+        (pos.y() != electricBottom))
+       return;
+
+    Time treshold_set = options->electricBorderDelay(); // set timeout
+    Time treshold_reset = 250; // reset timeout
+    int distance_reset = 30; // Mouse should not move more than this many pixels
+
+    int border = 0;
+    if (pos.x() == electricLeft)
+       border = 1;
+    else if (pos.x() == electricRight)
+       border = 2;
+    else if (pos.y() == electricTop)
+       border = 3;
+    else if (pos.y() == electricBottom)
+       border = 4;
+
+    if ((electric_current_border == border) &&
+        (timestampDiff(electric_time_last, now) < treshold_reset) &&
+        ((pos-electric_push_point).manhattanLength() < distance_reset))
+        {
+        electric_time_last = now;
+
+        if (timestampDiff(electric_time_first, now) > treshold_set)
+            {
+            electric_current_border = 0;
+
+            TQRect r = TQApplication::desktop()->geometry();
+            int offset;
+
+            int desk_before = currentDesktop();
+            switch(border)
+                {
+                case 1:
+                 slotSwitchDesktopLeft();
+                 if (currentDesktop() != desk_before) 
+                    {
+                    offset = r.width() / 5;
+                    TQCursor::setPos(r.width() - offset, pos.y());
+                    }
+                break;
+
+               case 2:
+                slotSwitchDesktopRight();
+                if (currentDesktop() != desk_before) 
+                    {
+                    offset = r.width() / 5;
+                    TQCursor::setPos(offset, pos.y());
+                    }
+                break;
+
+               case 3:
+                slotSwitchDesktopUp();
+                if (currentDesktop() != desk_before) 
+                    {
+                    offset = r.height() / 5;
+                    TQCursor::setPos(pos.x(), r.height() - offset);
+                    }
+                break;
+
+               case 4:
+                slotSwitchDesktopDown();
+                if (currentDesktop() != desk_before) 
+                    {
+                    offset = r.height() / 5;
+                    TQCursor::setPos(pos.x(), offset);
+                    }
+                break;
+                }
+            return;
+            }
+        }
+    else 
+        {
+        electric_current_border = border;
+        electric_time_first = now;
+        electric_time_last = now;
+        electric_push_point = pos;
+        }
+
+    int mouse_warp = 1;
+
+  // reset the pointer to find out wether the user is really pushing
+    switch( border)
+        {
+        case 1: TQCursor::setPos(pos.x()+mouse_warp, pos.y()); break;
+        case 2: TQCursor::setPos(pos.x()-mouse_warp, pos.y()); break;
+        case 3: TQCursor::setPos(pos.x(), pos.y()+mouse_warp); break;
+        case 4: TQCursor::setPos(pos.x(), pos.y()-mouse_warp); break;
+        }
+    }
+
+// this function is called when the user entered an electric border
+// with the mouse. It may switch to another virtual desktop
+bool Workspace::electricBorder(XEvent *e)
+    {
+    if( !electric_have_borders )
+        return false;
+    if( e->type == EnterNotify )
+        {
+        if( e->xcrossing.window == electric_top_border ||
+            e->xcrossing.window == electric_left_border ||
+            e->xcrossing.window == electric_bottom_border ||
+            e->xcrossing.window == electric_right_border)
+            // the user entered an electric border
+            {
+            clientMoved( TQPoint( e->xcrossing.x_root, e->xcrossing.y_root ), e->xcrossing.time );
+            return true;
+            }
+        }
+    if( e->type == ClientMessage )
+        {
+        if( e->xclient.message_type == atoms->xdnd_position
+            && ( e->xclient.window == electric_top_border
+                 || e->xclient.window == electric_bottom_border
+                 || e->xclient.window == electric_left_border
+                 || e->xclient.window == electric_right_border ))
+            {
+            updateXTime();
+            clientMoved( TQPoint( e->xclient.data.l[2]>>16, e->xclient.data.l[2]&0xffff), GET_QT_X_TIME() );
+            return true;
+            }
+        }
+    return false;
+    }
+
+// electric borders (input only windows) have to be always on the
+// top. For that reason kwm calls this function always after some
+// windows have been raised.
+void Workspace::raiseElectricBorders()
+    {
+
+    if(electric_have_borders)
+        {
+        XRaiseWindow(qt_xdisplay(), electric_top_border);
+        XRaiseWindow(qt_xdisplay(), electric_left_border);
+        XRaiseWindow(qt_xdisplay(), electric_bottom_border);
+        XRaiseWindow(qt_xdisplay(), electric_right_border);
+        }
+    }
+
+void Workspace::addTopMenu( Client* c )
+    {
+    assert( c->isTopMenu());
+    assert( !topmenus.contains( c ));
+    topmenus.append( c );
+    if( managingTopMenus())
+        {
+        int minsize = c->minSize().height();
+        if( minsize > topMenuHeight())
+            {
+            topmenu_height = minsize;
+            updateTopMenuGeometry();
+            }
+        updateTopMenuGeometry( c );
+        updateCurrentTopMenu();
+        }
+//        kdDebug() << "NEW TOPMENU:" << c << endl;
+    }
+
+void Workspace::removeTopMenu( Client* c )
+    {
+//    if( c->isTopMenu())
+//        kdDebug() << "REMOVE TOPMENU:" << c << endl;
+    assert( c->isTopMenu());
+    assert( topmenus.contains( c ));
+    topmenus.remove( c );
+    updateCurrentTopMenu();
+    // TODO reduce topMenuHeight() if possible?
+    }
+
+void Workspace::lostTopMenuSelection()
+    {
+//    kdDebug() << "lost TopMenu selection" << endl;
+    // make sure this signal is always set when not owning the selection
+    disconnect( topmenu_watcher, TQT_SIGNAL( lostOwner()), this, TQT_SLOT( lostTopMenuOwner()));
+    connect( topmenu_watcher, TQT_SIGNAL( lostOwner()), this, TQT_SLOT( lostTopMenuOwner()));
+    if( !managing_topmenus )
+        return;
+    connect( topmenu_watcher, TQT_SIGNAL( lostOwner()), this, TQT_SLOT( lostTopMenuOwner()));
+    disconnect( topmenu_selection, TQT_SIGNAL( lostOwnership()), this, TQT_SLOT( lostTopMenuSelection()));
+    managing_topmenus = false;
+    delete topmenu_space;
+    topmenu_space = NULL;
+    updateClientArea();
+    for( ClientList::ConstIterator it = topmenus.begin();
+         it != topmenus.end();
+         ++it )
+        (*it)->checkWorkspacePosition();
+    }
+
+void Workspace::lostTopMenuOwner()
+    {
+    if( !options->topMenuEnabled())
+        return;
+//    kdDebug() << "TopMenu selection lost owner" << endl;
+    if( !topmenu_selection->claim( false ))
+        {
+//        kdDebug() << "Failed to claim TopMenu selection" << endl;
+        return;
+        }
+//    kdDebug() << "claimed TopMenu selection" << endl;
+    setupTopMenuHandling();
+    }
+
+void Workspace::setupTopMenuHandling()
+    {
+    if( managing_topmenus )
+        return;
+    connect( topmenu_selection, TQT_SIGNAL( lostOwnership()), this, TQT_SLOT( lostTopMenuSelection()));
+    disconnect( topmenu_watcher, TQT_SIGNAL( lostOwner()), this, TQT_SLOT( lostTopMenuOwner()));
+    managing_topmenus = true;
+    topmenu_space = new TQWidget;
+    Window stack[ 2 ];
+    stack[ 0 ] = supportWindow->winId();
+    stack[ 1 ] = topmenu_space->winId();
+    XRestackWindows(qt_xdisplay(), stack, 2);
+    updateTopMenuGeometry();
+    topmenu_space->show();
+    updateClientArea();
+    updateCurrentTopMenu();
+    }
+
+int Workspace::topMenuHeight() const
+    {
+    if( topmenu_height == 0 )
+        { // simply create a dummy menubar and use its preffered height as the menu height
+        KMenuBar tmpmenu;
+        tmpmenu.insertItem( "dummy" );
+        topmenu_height = tmpmenu.tqsizeHint().height();
+        }
+    return topmenu_height;
+    }
+
+KDecoration* Workspace::createDecoration( KDecorationBridge* bridge )
+    {
+    return mgr->createDecoration( bridge );
+    }
+
+TQString Workspace::desktopName( int desk ) const
+    {
+    return TQString::fromUtf8( rootInfo->desktopName( desk ) );
+    }
+
+bool Workspace::checkStartupNotification( Window w, KStartupInfoId& id, KStartupInfoData& data )
+    {
+    return startup->checkStartup( w, id, data ) == KStartupInfo::Match;
+    }
+
+/*!
+  Puts the focus on a dummy window
+  Just using XSetInputFocus() with None would block keyboard input
+ */
+void Workspace::focusToNull()
+    {
+    XSetInputFocus(qt_xdisplay(), null_focus_window, RevertToPointerRoot, GET_QT_X_TIME() );
+    }
+
+void Workspace::helperDialog( const TQString& message, const Client* c )
+    {
+    TQStringList args;
+    TQString type;
+    if( message == "noborderaltf3" )
+        {
+        TQString shortcut = TQString( "%1 (%2)" ).arg( keys->label( "Window Operations Menu" ))
+            .arg( keys->shortcut( "Window Operations Menu" ).seq( 0 ).toString());
+        args << "--msgbox" <<
+              i18n( "You have selected to show a window without its border.\n"
+                    "Without the border, you will not be able to enable the border "
+                    "again using the mouse: use the window operations menu instead, "
+                    "activated using the %1 keyboard shortcut." )
+                .arg( shortcut );
+        type = "altf3warning";
+        }
+    else if( message == "fullscreenaltf3" )
+        {
+        TQString shortcut = TQString( "%1 (%2)" ).arg( keys->label( "Window Operations Menu" ))
+            .arg( keys->shortcut( "Window Operations Menu" ).seq( 0 ).toString());
+        args << "--msgbox" <<
+              i18n( "You have selected to show a window in fullscreen mode.\n"
+                    "If the application itself does not have an option to turn the fullscreen "
+                    "mode off you will not be able to disable it "
+                    "again using the mouse: use the window operations menu instead, "
+                    "activated using the %1 keyboard shortcut." )
+                .arg( shortcut );
+        type = "altf3warning";
+        }
+    else
+        assert( false );
+    KProcess proc;
+    proc << "kdialog" << args;
+    if( !type.isEmpty())
+        {
+        KConfig cfg( "twin_dialogsrc" );
+        cfg.setGroup( "Notification Messages" ); // this depends on KMessageBox
+        if( !cfg.readBoolEntry( type, true )) // has don't show again checked
+            return;                           // save launching kdialog
+        proc << "--dontagain" << "twin_dialogsrc:" + type;
+        }
+    if( c != NULL )
+        proc << "--embed" << TQString::number( c->window());
+    proc.start( KProcess::DontCare );
+    }
+
+
+// kompmgr stuff
+
+void Workspace::startKompmgr()
+{
+    // See if the desktop is loaded yet
+    Atom type;
+    int format;
+    unsigned long length, after;
+    unsigned char* data_root;
+    Atom prop_root;
+    prop_root = XInternAtom(qt_xdisplay(), "_XROOTPMAP_ID", False);
+    if( XGetWindowProperty( qt_xdisplay(), qt_xrootwin(), prop_root, 0L, 1L, False, AnyPropertyType, &type, &format, &length, &after, &data_root) == Success && data_root != NULL ) {
+        // Root pixmap is available; OK to load...
+    }
+    else {
+        // Try again a bit later!
+        TQTimer::singleShot( 200, this, TQT_SLOT(startKompmgr()) );
+        return;
+    }
+    if (!kompmgr || kompmgr->isRunning())
+        return;
+    if (!kompmgr->start(KProcess::OwnGroup, KProcess::Stderr))
+    {
+        options->useTranslucency = FALSE;
+        KProcess proc;
+        proc << "kdialog" << "--error"
+            << i18n("The Composite Manager could not be started.\\nMake sure you have \"kompmgr\" in a $PATH directory.")
+            << "--title" << "Composite Manager Failure";
+        proc.start(KProcess::DontCare);
+    }
+    else
+    {
+        delete kompmgr_selection;
+        char selection_name[ 100 ];
+        sprintf( selection_name, "_NET_WM_CM_S%d", DefaultScreen( qt_xdisplay()));
+        kompmgr_selection = new KSelectionOwner( selection_name );
+        connect( kompmgr_selection, TQT_SIGNAL( lostOwnership()), TQT_SLOT( stopKompmgr()));
+        kompmgr_selection->claim( true );
+        connect(kompmgr, TQT_SIGNAL(processExited(KProcess*)), TQT_SLOT(restartKompmgr(KProcess*)));
+        options->useTranslucency = TRUE;
+        //allowKompmgrRestart = FALSE;
+        //TQTimer::singleShot( 60000, this, TQT_SLOT(unblockKompmgrRestart()) );
+        TQByteArray ba;
+        TQDataStream arg(ba, IO_WriteOnly);
+        arg << "";
+        kapp->dcopClient()->emitDCOPSignal("default", "kompmgrStarted()", ba);
+    }
+    if (popup){ delete popup; popup = 0L; } // to add/remove opacity slider
+}
+
+void Workspace::stopKompmgr()
+{
+    if (!kompmgr || !kompmgr->isRunning()) {
+        return;
+    }
+    delete kompmgr_selection;
+    kompmgr_selection = NULL;
+    kompmgr->disconnect(this, TQT_SLOT(restartKompmgr(KProcess*)));
+    options->useTranslucency = FALSE;
+    if (popup){ delete popup; popup = 0L; } // to add/remove opacity slider
+    kompmgr->kill();
+    TQByteArray ba;
+    TQDataStream arg(ba, IO_WriteOnly);
+    arg << "";
+    kapp->dcopClient()->emitDCOPSignal("default", "kompmgrStopped()", ba);
+}
+
+bool Workspace::kompmgrIsRunning()
+{
+   return kompmgr && kompmgr->isRunning();
+}
+
+void Workspace::unblockKompmgrRestart()
+{
+    allowKompmgrRestart = TRUE;
+}
+
+void Workspace::restartKompmgr( KProcess *proc )
+// this is for inernal purpose (crashhandling) only, usually you want to use workspace->stopKompmgr(); TQTimer::singleShot(200, workspace, TQT_SLOT(startKompmgr()));
+{
+    bool crashed;
+    if (proc->signalled()) {	// looks like kompmgr may have crashed
+      int exit_signal_number = proc->exitSignal();
+      if ( (exit_signal_number == SIGILL) || (exit_signal_number == SIGTRAP) || (exit_signal_number == SIGABRT) || (exit_signal_number == SIGSYS) || (exit_signal_number == SIGFPE) || (exit_signal_number == SIGBUS) || (exit_signal_number == SIGSEGV) ) {
+        crashed = true;
+      }
+      else {
+        crashed = false;
+      }
+      if (!allowKompmgrRestart)   // uh oh, it exited recently already
+      {
+          delete kompmgr_selection;
+          kompmgr_selection = NULL;
+          options->useTranslucency = FALSE;
+          if (crashed) {
+            KProcess proc;
+            proc << "kdialog" << "--error"
+                << i18n( "The Composite Manager crashed twice within a minute and is therefore disabled for this session.")
+                << "--title" << i18n("Composite Manager Failure");
+            proc.start(KProcess::DontCare);
+          }
+          return;
+      }
+      if (!kompmgr)
+            return;
+// this should be useless, i keep it for maybe future need
+//         if (!kcompmgr)
+//             {
+//             kompmgr = new KProcess;
+//             kompmgr->clearArguments();
+//             *kompmgr << "kompmgr";
+//             }
+// -------------------
+        if (!kompmgr->start(KProcess::NotifyOnExit, KProcess::Stderr))
+        {
+            delete kompmgr_selection;
+            kompmgr_selection = NULL;
+            options->useTranslucency = FALSE;
+            KProcess proc;
+            proc << "kdialog" << "--error"
+                << i18n("The Composite Manager could not be started.\\nMake sure you have \"kompmgr\" in a $PATH directory.")
+                << "--title" << i18n("Composite Manager Failure");
+            proc.start(KProcess::DontCare);
+        }
+        else
+        {
+            allowKompmgrRestart = FALSE;
+            TQTimer::singleShot( 60000, this, TQT_SLOT(unblockKompmgrRestart()) );
+        }
+    }
+}
+
+void Workspace::handleKompmgrOutput( KProcess* , char *buffer, int buflen)
+{
+    TQString message;
+    TQString output = TQString::fromLocal8Bit( buffer, buflen );
+    if (output.contains("Started",false))
+        ; // don't do anything, just pass to the connection release
+    else if (output.contains("Can't open display",false))
+        message = i18n("<qt><b>kompmgr failed to open the display</b><br>There is probably an invalid display entry in your ~/.xcompmgrrc.</qt>");
+    else if (output.contains("No render extension",false))
+        message = i18n("<qt><b>kompmgr cannot find the Xrender extension</b><br>You are using either an outdated or a crippled version of XOrg.<br>Get XOrg &ge; 6.8 from www.freedesktop.org.<br></qt>");
+    else if (output.contains("No composite extension",false))
+        message = i18n("<qt><b>Composite extension not found</b><br>You <i>must</i> use XOrg &ge; 6.8 for translucency and shadows to work.<br>Additionally, you need to add a new section to your X config file:<br>"
+        "<i>Section \"Extensions\"<br>"
+        "Option \"Composite\" \"Enable\"<br>"
+        "EndSection</i></qt>");
+    else if (output.contains("No damage extension",false))
+        message = i18n("<qt><b>Damage extension not found</b><br>You <i>must</i> use XOrg &ge; 6.8 for translucency and shadows to work.</qt>");
+    else if (output.contains("No XFixes extension",false))
+        message = i18n("<qt><b>XFixes extension not found</b><br>You <i>must</i> use XOrg &ge; 6.8 for translucency and shadows to work.</qt>");
+    else return; //skip others
+    // kompmgr startup failed or succeeded, release connection
+    kompmgr->closeStderr();
+    disconnect(kompmgr, TQT_SIGNAL(receivedStderr(KProcess*, char*, int)), this, TQT_SLOT(handleKompmgrOutput(KProcess*, char*, int)));
+    if( !message.isEmpty())
+        {
+        KProcess proc;
+        proc << "kdialog" << "--error"
+            << message
+            << "--title" << i18n("Composite Manager Failure");
+        proc.start(KProcess::DontCare);
+        }
+}
+    
+        
+void Workspace::setOpacity(unsigned long winId, unsigned int opacityPercent)
+{
+    if (opacityPercent > 100) opacityPercent = 100;
+    for( ClientList::ConstIterator it = stackingOrder().begin(); it != stackingOrder().end(); it++ )
+        if (winId == (*it)->window())
+            {
+            (*it)->setOpacity(opacityPercent < 100, (unsigned int)((opacityPercent/100.0)*0xFFFFFFFF));
+            return;
+            }
+}
+
+void Workspace::setShadowSize(unsigned long winId, unsigned int shadowSizePercent)
+{
+    //this is open to the user by dcop - to avoid stupid trials, we limit the max shadow size to 400%
+    if (shadowSizePercent > 400) shadowSizePercent = 400;
+    for( ClientList::ConstIterator it = stackingOrder().begin(); it != stackingOrder().end(); it++ )
+        if (winId == (*it)->window())
+            {
+            (*it)->setShadowSize(shadowSizePercent);
+            return;
+            }
+}
+
+void Workspace::setUnshadowed(unsigned long winId)
+{
+    for( ClientList::ConstIterator it = stackingOrder().begin(); it != stackingOrder().end(); it++ )
+        if (winId == (*it)->window())
+            {
+            (*it)->setShadowSize(0);
+            return;
+            }
+}
+
+void Workspace::setShowingDesktop( bool showing )
+    {
+    rootInfo->setShowingDesktop( showing );
+    showing_desktop = showing;
+    ++block_showing_desktop;
+    if( showing_desktop )
+        {
+        showing_desktop_clients.clear();
+        ++block_focus;
+        ClientList cls = stackingOrder();
+        // find them first, then minimize, otherwise transients may get minimized with the window
+        // they're transient for
+        for( ClientList::ConstIterator it = cls.begin();
+             it != cls.end();
+             ++it )
+            {
+            if( (*it)->isOnCurrentDesktop() && (*it)->isShown( true ) && !(*it)->isSpecialWindow())
+                showing_desktop_clients.prepend( *it ); // topmost first to reduce flicker
+            }
+        for( ClientList::ConstIterator it = showing_desktop_clients.begin();
+             it != showing_desktop_clients.end();
+             ++it )
+            (*it)->minimize(true);
+        --block_focus;
+        if( Client* desk = findDesktop( true, currentDesktop()))
+            requestFocus( desk );
+        }
+    else
+        {
+        for( ClientList::ConstIterator it = showing_desktop_clients.begin();
+             it != showing_desktop_clients.end();
+             ++it )
+            (*it)->unminimize(true);
+        if( showing_desktop_clients.count() > 0 )
+            requestFocus( showing_desktop_clients.first());
+        showing_desktop_clients.clear();
+        }
+    --block_showing_desktop;
+    }
+
+// Following Kicker's behavior:
+// Changing a virtual desktop resets the state and shows the windows again.
+// Unminimizing a window resets the state but keeps the windows hidden (except
+// the one that was unminimized).
+// A new window resets the state and shows the windows again, with the new window
+// being active. Due to popular demand (#67406) by people who apparently
+// don't see a difference between "show desktop" and "minimize all", this is not
+// true if "showDesktopIsMinimizeAll" is set in twinrc. In such case showing
+// a new window resets the state but doesn't show windows.
+void Workspace::resetShowingDesktop( bool keep_hidden )
+    {
+    if( block_showing_desktop > 0 )
+        return;
+    rootInfo->setShowingDesktop( false );
+    showing_desktop = false;
+    ++block_showing_desktop;
+    if( !keep_hidden )
+        {
+        for( ClientList::ConstIterator it = showing_desktop_clients.begin();
+             it != showing_desktop_clients.end();
+             ++it )
+            (*it)->unminimize(true);
+        }
+    showing_desktop_clients.clear();
+    --block_showing_desktop;
+    }
+
+// Activating/deactivating this feature works like this:
+// When nothing is active, and the shortcut is pressed, global shortcuts are disabled
+//   (using global_shortcuts_disabled)
+// When a window that has disabling forced is activated, global shortcuts are disabled.
+//   (using global_shortcuts_disabled_for_client)
+// When a shortcut is pressed and global shortcuts are disabled (either by a shortcut
+// or for a client), they are enabled again.
+void Workspace::slotDisableGlobalShortcuts()
+    {
+    if( global_shortcuts_disabled || global_shortcuts_disabled_for_client )
+        disableGlobalShortcuts( false );
+    else
+        disableGlobalShortcuts( true );
+    }
+
+static bool pending_dfc = false;
+
+void Workspace::disableGlobalShortcutsForClient( bool disable )
+    {
+    if( global_shortcuts_disabled_for_client == disable )
+        return;
+    if( !global_shortcuts_disabled )
+        {
+        if( disable )
+            pending_dfc = true;
+        KIPC::sendMessageAll( KIPC::BlockShortcuts, disable );
+        // twin will get the kipc message too
+        }
+    }
+
+void Workspace::disableGlobalShortcuts( bool disable )
+    {
+    KIPC::sendMessageAll( KIPC::BlockShortcuts, disable );
+    // twin will get the kipc message too
+    }
+
+void Workspace::kipcMessage( int id, int data )
+    {
+    if( id != KIPC::BlockShortcuts )
+        return;
+    if( pending_dfc && data )
+        {
+        global_shortcuts_disabled_for_client = true;
+        pending_dfc = false;
+        }
+    else
+        {
+        global_shortcuts_disabled = data;
+        global_shortcuts_disabled_for_client = false;
+        }
+    // update also Alt+LMB actions etc.
+    for( ClientList::ConstIterator it = clients.begin();
+         it != clients.end();
+         ++it )
+        (*it)->updateMouseGrab();
+    }
+
+} // namespace
+
+#include "workspace.moc"