kwin Library API Documentation

activation.cpp

00001 /*****************************************************************
00002  KWin - the KDE window manager
00003  This file is part of the KDE project.
00004 
00005 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
00006 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
00007 
00008 You can Freely distribute this program under the GNU General Public
00009 License. See the file "COPYING" for the exact licensing terms.
00010 ******************************************************************/
00011 
00012 /*
00013 
00014  This file contains things relevant to window activation and focus
00015  stealing prevention.
00016 
00017 */
00018 
00019 #include "client.h"
00020 #include "workspace.h"
00021 
00022 #include <fixx11h.h>
00023 #include <qpopupmenu.h>
00024 #include <kxerrorhandler.h>
00025 #include <kstartupinfo.h>
00026 
00027 #include "notifications.h"
00028 #include "atoms.h"
00029 #include "group.h"
00030 #include "rules.h"
00031 
00032 extern Time qt_x_time;
00033 
00034 namespace KWinInternal
00035 {
00036 
00037 /*
00038  Prevention of focus stealing:
00039 
00040  KWin tries to prevent unwanted changes of focus, that would result
00041  from mapping a new window. Also, some nasty applications may try
00042  to force focus change even in cases when ICCCM 4.2.7 doesn't allow it
00043  (e.g. they may try to activate their main window because the user
00044  definitely "needs" to see something happened - misusing
00045  of QWidget::setActiveWindow() may be such case).
00046 
00047  There are 4 ways how a window may become active:
00048  - the user changes the active window (e.g. focus follows mouse, clicking
00049    on some window's titlebar) - the change of focus will
00050    be done by KWin, so there's nothing to solve in this case
00051  - the change of active window will be requested using the _NET_ACTIVE_WINDOW
00052    message (handled in RootInfo::changeActiveWindow()) - such requests
00053    will be obeyed, because this request is meant mainly for e.g. taskbar
00054    asking the WM to change the active window as a result of some user action.
00055    Normal applications should use this request only rarely in special cases.
00056    See also below the discussion of _NET_ACTIVE_WINDOW_TRANSFER.
00057  - the change of active window will be done by performing XSetInputFocus()
00058    on a window that's not currently active. ICCCM 4.2.7 describes when
00059    the application may perform change of input focus. In order to handle
00060    misbehaving applications, KWin will try to detect focus changes to
00061    windows that don't belong to currently active application, and restore
00062    focus back to the currently active window, instead of activating the window
00063    that got focus (unfortunately there's no way to FocusChangeRedirect similar
00064    to e.g. SubstructureRedirect, so there will be short time when the focus
00065    will be changed). The check itself that's done is
00066    Workspace::allowClientActivation() (see below).
00067  - a new window will be mapped - this is the most complicated case. If
00068    the new window belongs to the currently active application, it may be safely
00069    mapped on top and activated. The same if there's no active window,
00070    or the active window is the desktop. These checks are done by
00071    Workspace::allowClientActivation().
00072     Following checks need to compare times. One time is the timestamp
00073    of last user action in the currently active window, the other time is
00074    the timestamp of the action that originally caused mapping of the new window
00075    (e.g. when the application was started). If the first time is newer than
00076    the second one, the window will not be activated, as that indicates
00077    futher user actions took place after the action leading to this new
00078    mapped window. This check is done by Workspace::allowClientActivation().
00079     There are several ways how to get the timestamp of action that caused
00080    the new mapped window (done in Client::readUserTimeMapTimestamp()) :
00081      - the window may have the _NET_WM_USER_TIME property. This way
00082        the application may either explicitly request that the window is not
00083        activated (by using 0 timestamp), or the property contains the time
00084        of last user action in the application.
00085      - KWin itself tries to detect time of last user action in every window,
00086        by watching KeyPress and ButtonPress events on windows. This way some
00087        events may be missed (if they don't propagate to the toplevel window),
00088        but it's good as a fallback for applications that don't provide
00089        _NET_WM_USER_TIME, and missing some events may at most lead
00090        to unwanted focus stealing.
00091      - the timestamp may come from application startup notification.
00092        Application startup notification, if it exists for the new mapped window,
00093        should include time of the user action that caused it.
00094      - if there's no timestamp available, it's checked whether the new window
00095        belongs to some already running application - if yes, the timestamp
00096        will be 0 (i.e. refuse activation)
00097      - if the window is from session restored window, the timestamp will
00098        be 0 too, unless this application was the active one at the time
00099        when the session was saved, in which case the window will be
00100        activated if there wasn't any user interaction since the time
00101        KWin was started.
00102      - as the last resort, the _KDE_NET_USER_CREATION_TIME timestamp
00103        is used. For every toplevel window that is created (see CreateNotify
00104        handling), this property is set to the at that time current time.
00105        Since at this time it's known that the new window doesn't belong
00106        to any existing application (better said, the application doesn't
00107        have any other window mapped), it is either the very first window
00108        of the application, or its the only window of the application
00109        that was hidden before. The latter case is handled by removing
00110        the property from windows before withdrawing them, making
00111        the timestamp empty for next mapping of the window. In the sooner
00112        case, the timestamp will be used. This helps in case when
00113        an application is launched without application startup notification,
00114        it creates its mainwindow, and starts its initialization (that
00115        may possibly take long time). The timestamp used will be older
00116        than any user action done after launching this application.
00117      - if no timestamp is found at all, the window is activated.
00118     The check whether two windows belong to the same application (same
00119    process) is done in Client::belongToSameApplication(). Not 100% reliable,
00120    but hopefully 99,99% reliable.
00121 
00122  As a somewhat special case, window activation is always enabled when
00123  session saving is in progress. When session saving, the session
00124  manager allows only one application to interact with the user.
00125  Not allowing window activation in such case would result in e.g. dialogs
00126  not becoming active, so focus stealing prevention would cause here
00127  more harm than good.
00128 
00129  Windows that attempted to become active but KWin prevented this will
00130  be marked as demanding user attention. They'll get
00131  the _NET_WM_STATE_DEMANDS_ATTENTION state, and the taskbar should mark
00132  them specially (blink, etc.). The state will be reset when the window
00133  eventually really becomes active.
00134 
00135  There are one more ways how a window can become obstrusive, window stealing
00136  focus: By showing above the active window, by either raising itself,
00137  or by moving itself on the active desktop.
00138      - KWin will refuse raising non-active window above the active one,
00139          unless they belong to the same application. Applications shouldn't
00140          raise their windows anyway (unless the app wants to raise one
00141          of its windows above another of its windows).
00142      - KWin activates windows moved to the current desktop (as that seems
00143          logical from the user's point of view, after sending the window
00144          there directly from KWin, or e.g. using pager). This means
00145          applications shouldn't send their windows to another desktop
00146          (SELI TODO - but what if they do?)
00147 
00148  Special cases I can think of:
00149     - konqueror reusing, i.e. kfmclient tells running Konqueror instance
00150         to open new window
00151         - without focus stealing prevention - no problem
00152         - with ASN (application startup notification) - ASN is forwarded,
00153             and because it's newer than the instance's user timestamp,
00154             it takes precedence
00155         - without ASN - user timestamp needs to be reset, otherwise it would
00156             be used, and it's old; moreover this new window mustn't be detected
00157             as window belonging to already running application, or it wouldn't
00158             be activated - see Client::sameAppWindowRoleMatch() for the (rather ugly)
00159             hack
00160     - konqueror preloading, i.e. window is created in advance, and kfmclient
00161         tells this Konqueror instance to show it later
00162         - without focus stealing prevention - no problem
00163         - with ASN - ASN is forwarded, and because it's newer than the instance's
00164             user timestamp, it takes precedence
00165         - without ASN - user timestamp needs to be reset, otherwise it would
00166             be used, and it's old; also, creation timestamp is changed to
00167             the time the instance starts (re-)initializing the window,
00168             this ensures creation timestamp will still work somewhat even in this case
00169     - KUniqueApplication - when the window is already visible, and the new instance
00170         wants it to activate
00171         - without focus stealing prevention - _NET_ACTIVE_WINDOW - no problem
00172         - with ASN - ASN is forwarded, and set on the already visible window, KWin
00173             treats the window as new with that ASN
00174         - without ASN - _NET_ACTIVE_WINDOW as application request is used,
00175                 and there's no really usable timestamp, only timestamp
00176                 from the time the (new) application instance was started,
00177                 so KWin will activate the window *sigh*
00178                 - the bad thing here is that there's absolutely no chance to recognize
00179                     the case of starting this KUniqueApp from Konsole (and thus wanting
00180                     the already visible window to become active) from the case
00181                     when something started this KUniqueApp without ASN (in which case
00182                     the already visible window shouldn't become active)
00183                 - the only solution is using ASN for starting applications, at least silent
00184                     (i.e. without feedback)
00185     - when one application wants to activate another application's window (e.g. KMail
00186         activating already running KAddressBook window ?)
00187         - without focus stealing prevention - _NET_ACTIVE_WINDOW - no problem
00188         - with ASN - can't be here, it's the KUniqueApp case then
00189         - without ASN - _NET_ACTIVE_WINDOW as application request should be used,
00190             KWin will activate the new window depending on the timestamp and
00191             whether it belongs to the currently active application
00192 
00193  _NET_ACTIVE_WINDOW usage:
00194  data.l[0]= 1 ->app request
00195           = 2 ->pager request
00196           = 0 - backwards compatibility
00197  data.l[1]= timestamp
00198 */
00199 
00200 
00201 //****************************************
00202 // Workspace
00203 //****************************************
00204 
00205 
00214 void Workspace::setActiveClient( Client* c, allowed_t )
00215     {
00216     if ( active_client == c )
00217         return;
00218     if( active_popup && active_popup_client != c && set_active_client_recursion == 0 ) 
00219         closeActivePopup();
00220     StackingUpdatesBlocker blocker( this );
00221     ++set_active_client_recursion;
00222     if( active_client != NULL )
00223         { // note that this may call setActiveClient( NULL ), therefore the recursion counter
00224             active_client->setActive( false, !c || !c->isModal() || c != active_client->transientFor() );
00225     }
00226     active_client = c;
00227     Q_ASSERT( c == NULL || c->isActive());
00228     if( active_client != NULL )
00229         last_active_client = active_client;
00230     if ( active_client ) 
00231         {
00232         focus_chain.remove( c );
00233         if ( c->wantsTabFocus() )
00234             focus_chain.append( c );
00235         active_client->demandAttention( false );
00236         }
00237     pending_take_activity = NULL;
00238 
00239     updateCurrentTopMenu();
00240     updateToolWindows( false );
00241 
00242     updateStackingOrder(); // e.g. fullscreens have different layer when active/not-active
00243 
00244     rootInfo->setActiveWindow( active_client? active_client->window() : 0 );
00245     updateColormap();
00246     --set_active_client_recursion;
00247     }
00248 
00260 void Workspace::activateClient( Client* c, bool force )
00261     {
00262     if( c == NULL )
00263         {
00264         setActiveClient( NULL, Allowed );
00265         return;
00266         }
00267     raiseClient( c );
00268     if (!c->isOnDesktop(currentDesktop()) )
00269         {
00270         ++block_focus;
00271         setCurrentDesktop( c->desktop() );
00272         --block_focus;
00273         // popupinfo->showInfo( desktopName(currentDesktop()) ); // AK - not sure
00274         }
00275     if( c->isMinimized())
00276         c->unminimize();
00277 
00278 // TODO force should perhaps allow this only if the window already contains the mouse
00279     if( options->focusPolicyIsReasonable() || force )
00280         requestFocus( c, force );
00281 
00282     // Don't update user time for clients that have focus stealing workaround.
00283     // As they usually belong to the current active window but fail to provide
00284     // this information, updating their user time would make the user time
00285     // of the currently active window old, and reject further activation for it.
00286     // E.g. typing URL in minicli which will show kio_uiserver dialog (with workaround),
00287     // and then kdesktop shows dialog about SSL certificate.
00288     // This needs also avoiding user creation time in Client::readUserTimeMapTimestamp().
00289     if( !c->ignoreFocusStealing())
00290         c->updateUserTime();
00291     }
00292 
00300 void Workspace::requestFocus( Client* c, bool force )
00301     {
00302     takeActivity( c, ActivityFocus | ( force ? ActivityFocusForce : 0 ), false);
00303     }
00304     
00305 void Workspace::takeActivity( Client* c, int flags, bool handled )
00306     {
00307      // the 'if( c == active_client ) return;' optimization mustn't be done here
00308     if (!focusChangeEnabled() && ( c != active_client) )
00309         flags &= ~ActivityFocus;
00310 
00311     if ( !c ) 
00312         {
00313         focusToNull();
00314         return;
00315         }
00316 
00317     if( flags & ActivityFocus )
00318         {
00319         Client* modal = c->findModal();
00320         if( modal != NULL && modal != c )   
00321             { 
00322             if( !modal->isOnDesktop( c->desktop()))
00323                 {
00324                 modal->setDesktop( c->desktop());
00325                 if( modal->desktop() != c->desktop()) // forced desktop
00326                     activateClient( modal );
00327                 }
00328             // if the click was inside the window (i.e. handled is set),
00329             // but it has a modal, there's no need to use handled mode, because
00330             // the modal doesn't get the click anyway
00331             // raising of the original window needs to be still done
00332             if( flags & ActivityRaise )
00333                 raiseClient( c );
00334             c = modal;
00335             handled = false;
00336             }
00337         cancelDelayFocus();
00338         }
00339     if ( !( flags & ActivityFocusForce ) && ( c->isTopMenu() || c->isDock() || c->isSplash()) )
00340         flags &= ~ActivityFocus; // toplevel menus and dock windows don't take focus if not forced
00341     if( c->isShade())
00342         {
00343         if( c->wantsInput() && ( flags & ActivityFocus ))
00344             {
00345         // client cannot accept focus, but at least the window should be active (window menu, et. al. )
00346             c->setActive( true );
00347             focusToNull();
00348             }
00349         flags &= ~ActivityFocus;
00350         handled = false; // no point, can't get clicks
00351         }
00352     if( !c->isShown( true )) // shouldn't happen, call activateClient() if needed
00353         {
00354         kdWarning( 1212 ) << "takeActivity: not shown" << endl;
00355         return;
00356         }
00357     c->takeActivity( flags, handled, Allowed );
00358     }
00359 
00360 void Workspace::handleTakeActivity( Client* c, Time /*timestamp*/, int flags )
00361     {
00362     if( pending_take_activity != c ) // pending_take_activity is reset when doing restack or activation
00363         return;
00364     if(( flags & ActivityRaise ) != 0 )
00365         raiseClient( c );
00366     if(( flags & ActivityFocus ) != 0 && c->isShown( false ))
00367         c->takeFocus( Allowed );
00368     pending_take_activity = NULL;
00369     }
00370 
00378 void Workspace::clientHidden( Client* c )
00379     {
00380     assert( !c->isShown( true ) || !c->isOnCurrentDesktop());
00381     activateNextClient( c );
00382     }
00383 
00384 // deactivates 'c' and activates next client
00385 bool Workspace::activateNextClient( Client* c )
00386     {
00387     // if 'c' is not the active or the to-become active one, do nothing
00388     if( !( c == active_client
00389             || ( should_get_focus.count() > 0 && c == should_get_focus.last())))
00390         return false;
00391     closeActivePopup();
00392     if( c != NULL )
00393         {
00394         if( c == active_client )
00395             setActiveClient( NULL, Allowed );
00396         should_get_focus.remove( c );
00397         }
00398     if( focusChangeEnabled())
00399         {
00400         if ( c != NULL && c->wantsTabFocus() && focus_chain.contains( c ) )
00401             {
00402             focus_chain.remove( c );
00403             focus_chain.prepend( c );
00404             }
00405         if ( options->focusPolicyIsReasonable())
00406             { // search the focus_chain for a client to transfer focus to
00407           // if 'c' is transient, transfer focus to the first suitable mainwindow
00408             Client* get_focus = NULL;
00409             const ClientList mainwindows = ( c != NULL ? c->mainClients() : ClientList());
00410             for( ClientList::ConstIterator it = focus_chain.fromLast();
00411                  it != focus_chain.end();
00412                  --it )
00413                 {
00414                 if( !(*it)->isShown( false ) || !(*it)->isOnCurrentDesktop())
00415                     continue;
00416                 if( mainwindows.contains( *it ))
00417                     {
00418                     get_focus = *it;
00419                     break;
00420                     }
00421                 if( get_focus == NULL )
00422                     get_focus = *it;
00423                 }
00424             if( get_focus == NULL )
00425                 get_focus = findDesktop( true, currentDesktop());
00426             if( get_focus != NULL )
00427                 requestFocus( get_focus );
00428             else
00429                 focusToNull();
00430             }
00431             else
00432                 return false;
00433         }
00434     else
00435         // if blocking focus, move focus to the desktop later if needed
00436         // in order to avoid flickering
00437         focusToNull();
00438     return true;
00439     }
00440 
00441 
00442 void Workspace::gotFocusIn( const Client* c )
00443     {
00444     if( should_get_focus.contains( const_cast< Client* >( c )))
00445         { // remove also all sooner elements that should have got FocusIn,
00446       // but didn't for some reason (and also won't anymore, because they were sooner)
00447         while( should_get_focus.first() != c )
00448             should_get_focus.pop_front();
00449         should_get_focus.pop_front(); // remove 'c'
00450         }
00451     }
00452 
00453 void Workspace::setShouldGetFocus( Client* c )
00454     {
00455     should_get_focus.append( c );
00456     updateStackingOrder(); // e.g. fullscreens have different layer when active/not-active
00457     }
00458 
00459 // focus_in -> the window got FocusIn event
00460 // session_active -> the window was active when saving session
00461 bool Workspace::allowClientActivation( const Client* c, Time time, bool focus_in )
00462     {
00463     // options->focusStealingPreventionLevel :
00464     // 0 - none    - old KWin behaviour, new windows always get focus
00465     // 1 - low     - focus stealing prevention is applied normally, when unsure, activation is allowed
00466     // 2 - normal  - focus stealing prevention is applied normally, when unsure, activation is not allowed,
00467     //              this is the default
00468     // 3 - high    - new window gets focus only if it belongs to the active application,
00469     //              or when no window is currently active
00470     // 4 - extreme - no window gets focus without user intervention
00471     if( time == -1U )
00472         time = c->userTime();
00473     int level = c->rules()->checkFSP( options->focusStealingPreventionLevel );
00474     if( session_saving && level <= 2 ) // <= normal
00475         {
00476         return true;
00477         }
00478     Client* ac = mostRecentlyActivatedClient();
00479     if( focus_in )
00480         {
00481         if( should_get_focus.contains( const_cast< Client* >( c )))
00482             return true; // FocusIn was result of KWin's action
00483         // Before getting FocusIn, the active Client already
00484         // got FocusOut, and therefore got deactivated.
00485         ac = last_active_client;
00486         }
00487     if( time == 0 ) // explicitly asked not to get focus
00488         return false;
00489     if( level == 0 ) // none
00490         return true;
00491     if( level == 4 ) // extreme
00492         return false;
00493     if( !c->isOnCurrentDesktop())
00494         return false; // allow only with level == 0
00495     if( c->ignoreFocusStealing())
00496         return true;
00497     if( ac == NULL || ac->isDesktop())
00498         {
00499         kdDebug( 1212 ) << "Activation: No client active, allowing" << endl;
00500         return true; // no active client -> always allow
00501         }
00502     // TODO window urgency  -> return true?
00503     if( Client::belongToSameApplication( c, ac, true ))
00504         {
00505         kdDebug( 1212 ) << "Activation: Belongs to active application" << endl;
00506         return true;
00507         }
00508     if( level == 3 ) // high
00509         return false;
00510     if( time == -1U )  // no time known
00511         {
00512         kdDebug( 1212 ) << "Activation: No timestamp at all" << endl;
00513         if( level == 1 ) // low
00514             return true;
00515         // no timestamp at all, don't activate - because there's also creation timestamp
00516         // done on CreateNotify, this case should happen only in case application
00517         // maps again already used window, i.e. this won't happen after app startup
00518         return false; 
00519         }
00520     // level == 2 // normal
00521     Time user_time = ac->userTime();
00522     kdDebug( 1212 ) << "Activation, compared:" << c << ":" << time << ":" << user_time
00523         << ":" << ( timestampCompare( time, user_time ) >= 0 ) << endl;
00524     return timestampCompare( time, user_time ) >= 0; // time >= user_time
00525     }
00526 
00527 // basically the same like allowClientActivation(), this time allowing
00528 // a window to be fully raised upon its own request (XRaiseWindow),
00529 // if refused, it will be raised only on top of windows belonging
00530 // to the same application
00531 bool Workspace::allowFullClientRaising( const Client* c, Time time )
00532     {
00533     int level = c->rules()->checkFSP( options->focusStealingPreventionLevel );
00534     if( session_saving && level <= 2 ) // <= normal
00535         {
00536         return true;
00537         }
00538     Client* ac = mostRecentlyActivatedClient();
00539     if( level == 0 ) // none
00540         return true;
00541     if( level == 4 ) // extreme
00542         return false;
00543     if( ac == NULL || ac->isDesktop())
00544         {
00545         kdDebug( 1212 ) << "Raising: No client active, allowing" << endl;
00546         return true; // no active client -> always allow
00547         }
00548     if( c->ignoreFocusStealing())
00549         return true;
00550     // TODO window urgency  -> return true?
00551     if( Client::belongToSameApplication( c, ac, true ))
00552         {
00553         kdDebug( 1212 ) << "Raising: Belongs to active application" << endl;
00554         return true;
00555         }
00556     if( level == 3 ) // high
00557         return false;
00558     Time user_time = ac->userTime();
00559     kdDebug( 1212 ) << "Raising, compared:" << time << ":" << user_time
00560         << ":" << ( timestampCompare( time, user_time ) >= 0 ) << endl;
00561     return timestampCompare( time, user_time ) >= 0; // time >= user_time
00562     }
00563 
00564 // called from Client after FocusIn that wasn't initiated by KWin and the client
00565 // wasn't allowed to activate
00566 void Workspace::restoreFocus()
00567     {
00568     // this updateXTime() is necessary - as FocusIn events don't have
00569     // a timestamp *sigh*, kwin's timestamp would be older than the timestamp
00570     // that was used by whoever caused the focus change, and therefore
00571     // the attempt to restore the focus would fail due to old timestamp
00572     updateXTime();
00573     if( should_get_focus.count() > 0 )
00574         requestFocus( should_get_focus.last());
00575     else if( last_active_client )
00576         requestFocus( last_active_client );
00577     }
00578 
00579 void Workspace::clientAttentionChanged( Client* c, bool set )
00580     {
00581     if( set )
00582         {
00583         attention_chain.remove( c );
00584         attention_chain.prepend( c );
00585         }
00586     else
00587         attention_chain.remove( c );
00588     }
00589 
00590 // This is used when a client should be shown active immediately after requestFocus(),
00591 // without waiting for the matching FocusIn that will really make the window the active one.
00592 // Used only in special cases, e.g. for MouseActivateRaiseandMove with transparent windows,
00593 bool Workspace::fakeRequestedActivity( Client* c )
00594     {
00595     if( should_get_focus.count() > 0 && should_get_focus.last() == c )
00596         {
00597         if( c->isActive())
00598             return false;
00599         c->setActive( true );
00600         return true;
00601         }
00602     return false;
00603     }
00604 
00605 void Workspace::unfakeActivity( Client* c )
00606     {
00607     if( should_get_focus.count() > 0 && should_get_focus.last() == c )
00608         { // TODO this will cause flicker, and probably is not needed
00609         if( last_active_client != NULL )
00610             last_active_client->setActive( true );
00611         else
00612             c->setActive( false );
00613         }
00614     }
00615 
00616 
00617 //********************************************
00618 // Client
00619 //********************************************
00620 
00627 void Client::updateUserTime( Time time )
00628     { // copied in Group::updateUserTime
00629     if( time == CurrentTime )
00630         time = qt_x_time;
00631     if( time != -1U
00632         && ( user_time == CurrentTime
00633             || timestampCompare( time, user_time ) > 0 )) // time > user_time
00634         user_time = time;
00635     }
00636 
00637 Time Client::readUserCreationTime() const
00638     {
00639     long result = -1; // Time == -1 means none
00640     Atom type;
00641     int format, status;
00642     unsigned long nitems = 0;
00643     unsigned long extra = 0;
00644     unsigned char *data = 0;
00645     KXErrorHandler handler; // ignore errors?
00646     status = XGetWindowProperty( qt_xdisplay(), window(),
00647         atoms->kde_net_wm_user_creation_time, 0, 10000, FALSE, XA_CARDINAL,
00648         &type, &format, &nitems, &extra, &data );
00649     if (status  == Success )
00650         {
00651         if (data && nitems > 0)
00652             result = *((long*) data);
00653         XFree(data);
00654         }
00655     return result;       
00656     }
00657 
00658 void Client::demandAttention( bool set )
00659     {
00660     if( isActive())
00661         set = false;
00662     info->setState( set ? NET::DemandsAttention : 0, NET::DemandsAttention );
00663     workspace()->clientAttentionChanged( this, set );
00664     }
00665 
00666 // TODO I probably shouldn't be lazy here and do it without the macro, so that people can read it
00667 KWIN_COMPARE_PREDICATE( SameApplicationActiveHackPredicate, const Client*,
00668     // ignore already existing splashes, toolbars, utilities, menus and topmenus,
00669     // as the app may show those before the main window
00670     !cl->isSplash() && !cl->isToolbar() && !cl->isTopMenu() && !cl->isUtility() && !cl->isMenu()
00671     && Client::belongToSameApplication( cl, value, true ) && cl != value);
00672 
00673 Time Client::readUserTimeMapTimestamp( const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
00674     bool session ) const
00675     {
00676     Time time = info->userTime();
00677     kdDebug( 1212 ) << "User timestamp, initial:" << time << endl;
00678     // newer ASN timestamp always replaces user timestamp, unless user timestamp is 0
00679     // helps e.g. with konqy reusing
00680     if( asn_data != NULL && time != 0 )
00681         {
00682         // prefer timestamp from ASN id (timestamp from data is obsolete way)
00683         if( asn_id->timestamp() != 0
00684             && ( time == -1U || timestampCompare( asn_id->timestamp(), time ) > 0 ))
00685             {
00686             time = asn_id->timestamp();
00687             }
00688         else if( asn_data->timestamp() != -1U
00689             && ( time == -1U || timestampCompare( asn_data->timestamp(), time ) > 0 ))
00690             {
00691             time = asn_data->timestamp();
00692             }
00693         }
00694     kdDebug( 1212 ) << "User timestamp, ASN:" << time << endl;
00695     if( time == -1U )
00696         { // The window doesn't have any timestamp.
00697       // If it's the first window for its application
00698       // (i.e. there's no other window from the same app),
00699       // use the _KDE_NET_WM_USER_CREATION_TIME trick.
00700       // Otherwise, refuse activation of a window
00701       // from already running application if this application
00702       // is not the active one (unless focus stealing prevention is turned off).
00703         Client* act = workspace()->mostRecentlyActivatedClient();
00704         if( act != NULL && !belongToSameApplication( act, this, true ))
00705             {
00706             bool first_window = true;
00707             if( isTransient())
00708                 {
00709                 if( act->hasTransient( this, true ))
00710                     ; // is transient for currently active window, even though it's not
00711                       // the same app (e.g. kcookiejar dialog) -> allow activation
00712                 else if( groupTransient() &&
00713                     findClientInList( mainClients(), SameApplicationActiveHackPredicate( this )) == NULL )
00714                     ; // standalone transient
00715                 else
00716                     first_window = false;
00717                 }
00718             else
00719                 {
00720                 if( workspace()->findClient( SameApplicationActiveHackPredicate( this )))
00721                     first_window = false;
00722                 }
00723             // don't refuse if focus stealing prevention is turned off
00724             if( !first_window && rules()->checkFSP( options->focusStealingPreventionLevel ) > 0 )
00725                 {
00726                 kdDebug( 1212 ) << "User timestamp, already exists:" << 0 << endl;
00727                 return 0; // refuse activation
00728                 }
00729             }
00730         // Creation time would just mess things up during session startup,
00731         // as possibly many apps are started up at the same time.
00732         // If there's no active window yet, no timestamp will be needed,
00733         // as plain Workspace::allowClientActivation() will return true
00734         // in such case. And if there's already active window,
00735         // it's better not to activate the new one.
00736         // Unless it was the active window at the time
00737         // of session saving and there was no user interaction yet,
00738         // this check will be done in manage().
00739         if( session )
00740             return -1U;
00741         if( ignoreFocusStealing() && act != NULL )
00742             time = act->userTime();
00743         else
00744             time = readUserCreationTime();
00745         }
00746     kdDebug( 1212 ) << "User timestamp, final:" << this << ":" << time << endl;
00747     return time;
00748     }
00749 
00750 Time Client::userTime() const
00751     {
00752     Time time = user_time;
00753     if( time == 0 ) // doesn't want focus after showing
00754         return 0;
00755     assert( group() != NULL );
00756     if( time == -1U
00757          || ( group()->userTime() != -1U
00758                  && timestampCompare( group()->userTime(), time ) > 0 ))
00759         time = group()->userTime();
00760     return time;
00761     }
00762 
00774 void Client::setActive( bool act, bool updateOpacity_)
00775     {
00776     if ( active == act )
00777         return;
00778     active = act;
00779     workspace()->setActiveClient( act ? this : NULL, Allowed );
00780     
00781     if (updateOpacity_) updateOpacity();
00782     if (isModal() && transientFor())
00783     {
00784         if (!act) transientFor()->updateOpacity();
00785         else if (!transientFor()->custom_opacity) transientFor()->setOpacity(options->translucentActiveWindows, options->activeWindowOpacity);
00786     }
00787     updateShadowSize();
00788     
00789     if ( active )
00790         Notify::raise( Notify::Activate );
00791 
00792     if( !active )
00793         cancelAutoRaise();
00794 
00795     if( !active && shade_mode == ShadeActivated )
00796         setShade( ShadeNormal );
00797 
00798     StackingUpdatesBlocker blocker( workspace());
00799     workspace()->updateClientLayer( this ); // active windows may get different layer
00800     // TODO optimize? mainClients() may be a bit expensive
00801     ClientList mainclients = mainClients();
00802     for( ClientList::ConstIterator it = mainclients.begin();
00803          it != mainclients.end();
00804          ++it )
00805         if( (*it)->isFullScreen()) // fullscreens go high even if their transient is active
00806             workspace()->updateClientLayer( *it );
00807     if( decoration != NULL )
00808         decoration->activeChange();
00809     updateMouseGrab();
00810     updateUrgency(); // demand attention again if it's still urgent
00811     }
00812 
00813 void Client::startupIdChanged()
00814     {
00815     KStartupInfoId asn_id;
00816     KStartupInfoData asn_data;
00817     bool asn_valid = workspace()->checkStartupNotification( window(), asn_id, asn_data );
00818     if( !asn_valid )
00819         return;
00820     if( asn_data.desktop() != 0 )
00821         workspace()->sendClientToDesktop( this, asn_data.desktop(), true );
00822     Time timestamp = asn_id.timestamp();
00823     if( timestamp == 0 && asn_data.timestamp() != -1U )
00824         timestamp = asn_data.timestamp();
00825     if( timestamp != 0 )
00826         {
00827         bool activate = workspace()->allowClientActivation( this, timestamp );
00828         if( asn_data.desktop() != 0 && !isOnCurrentDesktop())
00829             activate = false; // it was started on different desktop than current one
00830         if( activate )
00831             workspace()->activateClient( this );
00832         else
00833             demandAttention();
00834         }
00835     }
00836 
00837 void Client::updateUrgency()
00838     {
00839     if( urgency )
00840         demandAttention();
00841     }
00842 
00843 void Client::shortcutActivated()
00844     {
00845     workspace()->activateClient( this, true ); // force
00846     }
00847 
00848 //****************************************
00849 // Group
00850 //****************************************
00851     
00852 void Group::startupIdChanged()
00853     {
00854     KStartupInfoId asn_id;
00855     KStartupInfoData asn_data;
00856     bool asn_valid = workspace()->checkStartupNotification( leader_wid, asn_id, asn_data );
00857     if( !asn_valid )
00858         return;
00859     if( asn_id.timestamp() != 0 && user_time != -1U
00860         && timestampCompare( asn_id.timestamp(), user_time ) > 0 )
00861         {
00862         user_time = asn_id.timestamp();
00863         }
00864     else if( asn_data.timestamp() != -1U && user_time != -1U
00865         && timestampCompare( asn_data.timestamp(), user_time ) > 0 )
00866         {
00867         user_time = asn_data.timestamp();
00868         }
00869     }
00870 
00871 void Group::updateUserTime( Time time )
00872     { // copy of Client::updateUserTime
00873     if( time == CurrentTime )
00874         time = qt_x_time;
00875     if( time != -1U
00876         && ( user_time == CurrentTime
00877             || timestampCompare( time, user_time ) > 0 )) // time > user_time
00878         user_time = time;
00879     }
00880 
00881 } // namespace
KDE Logo
This file is part of the documentation for kwin Library Version 3.4.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Jun 14 16:47:02 2006 by doxygen 1.4.4 written by Dimitri van Heesch, © 1997-2003