workspace/libs/taskmanager/taskmanager.cpp

   1 /*****************************************************************
   2
   3 Copyright (c) 2000 Matthias Elter <elter@kde.org>
   4
   5 Permission is hereby granted, free of charge, to any person obtaining a copy
   6 of this software and associated documentation files (the "Software"), to deal
   7 in the Software without restriction, including without limitation the rights
   8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 copies of the Software, and to permit persons to whom the Software is
  10 furnished to do so, subject to the following conditions:
  11
  12 The above copyright notice and this permission notice shall be included in
  13 all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  18 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 ******************************************************************/
  23
  24 // Own
  25 #include "taskmanager.h"
  26
  27 // Qt
  28 #include <QApplication>
  29 #include <QDesktopWidget>
  30 #include <QUuid>
  31
  32 // KDE
  33 #include <KConfig>
  34 #include <KConfigGroup>
  35 #include <KDebug>
  36 #include <KGlobal>
  37 #include <KLocale>
  38
  39 #ifdef Q_WS_X11
  40 #include <QX11Info>
  41 #endif
  42
  43 namespace TaskManager
  44 {
  45
  46 class TaskManagerSingleton
  47 {
  48 public:
  49    TaskManager self;
  50 };
  51
  52 K_GLOBAL_STATIC( TaskManagerSingleton, privateTaskManagerSelf )
  53
  54 TaskManager* TaskManager::self()
  55 {
  56     return &privateTaskManagerSelf->self;
  57 }
  58
  59 class TaskManager::Private
  60 {
  61 public:
  62     Private()
  63         : active(0),
  64           startupInfo(0)
  65     {
  66     }
  67
  68     TaskPtr active;
  69     KStartupInfo* startupInfo;
  70     TaskDict tasksByWId;
  71     StartupList startups;
  72     WindowList skiptaskbarWindows;
  73     QSet<QUuid> trackGeometryTokens;
  74 };
  75
  76 TaskManager::TaskManager()
  77     : QObject(),
  78       d(new Private)
  79 {
  80     KGlobal::locale()->insertCatalog("libtaskmanager");
  81     connect(KWindowSystem::self(), SIGNAL(windowAdded(WId)),
  82             this,       SLOT(windowAdded(WId)));
  83     connect(KWindowSystem::self(), SIGNAL(windowRemoved(WId)),
  84             this,       SLOT(windowRemoved(WId)));
  85     connect(KWindowSystem::self(), SIGNAL(activeWindowChanged(WId)),
  86             this,       SLOT(activeWindowChanged(WId)));
  87     connect(KWindowSystem::self(), SIGNAL(currentDesktopChanged(int)),
  88             this,       SLOT(currentDesktopChanged(int)));
  89     connect(KWindowSystem::self(), SIGNAL(windowChanged(WId,unsigned int)),
  90             this,       SLOT(windowChanged(WId,unsigned int)));
  91
  92     // register existing windows
  93     const QList<WId> windows = KWindowSystem::windows();
  94     QList<WId>::ConstIterator end(windows.end());
  95     for (QList<WId>::ConstIterator it = windows.begin(); it != end; ++it)
  96     {
  97         windowAdded(*it);
  98     }
  99
 100     // set active window
 101     WId win = KWindowSystem::activeWindow();
 102     activeWindowChanged(win);
 103     configureStartup();
 104 }
 105
 106 TaskManager::~TaskManager()
 107 {
 108     KGlobal::locale()->removeCatalog("libtaskmanager");
 109     delete d;
 110 }
 111
 112 void TaskManager::configureStartup()
 113 {
 114     KConfig _c("klaunchrc");
 115     KConfigGroup c(&_c, "FeedbackStyle");
 116     if (!c.readEntry("TaskbarButton", true)) {
 117         return;
 118     }
 119
 120     d->startupInfo = new KStartupInfo( KStartupInfo::CleanOnCantDetect, this );
 121     connect( d->startupInfo,
 122         SIGNAL( gotNewStartup( const KStartupInfoId&, const KStartupInfoData& )),
 123         SLOT( gotNewStartup( const KStartupInfoId&, const KStartupInfoData& )));
 124     connect( d->startupInfo,
 125         SIGNAL( gotStartupChange( const KStartupInfoId&, const KStartupInfoData& )),
 126         SLOT( gotStartupChange( const KStartupInfoId&, const KStartupInfoData& )));
 127     connect( d->startupInfo,
 128         SIGNAL( gotRemoveStartup( const KStartupInfoId&, const KStartupInfoData& )),
 129         SLOT( killStartup( const KStartupInfoId& )));
 130
 131     c = KConfigGroup(&_c, "TaskbarButtonSettings");
 132     d->startupInfo->setTimeout(c.readEntry( "Timeout", 30 ));
 133 }
 134
 135 TaskPtr TaskManager::findTask(WId w)
 136 {
 137     TaskDict::const_iterator it = d->tasksByWId.constBegin();
 138     TaskDict::const_iterator itEnd = d->tasksByWId.constEnd();
 139
 140     for (; it != itEnd; ++it) {
 141         if (it.key() == w || it.value()->hasTransient(w)) {
 142             return it.value();
 143         }
 144     }
 145
 146     return TaskPtr();
 147 }
 148
 149 TaskPtr TaskManager::findTask(int desktop, const QPoint& p)
 150 {
 151     QList<WId> list = KWindowSystem::stackingOrder();
 152
 153     TaskPtr task;
 154     int currentIndex = -1;
 155     TaskDict::iterator itEnd = d->tasksByWId.end();
 156     for (TaskDict::iterator it = d->tasksByWId.begin(); it != itEnd; ++it)
 157     {
 158         TaskPtr t = it.value();
 159         if (!t->isOnAllDesktops() && t->desktop() != desktop)
 160         {
 161             continue;
 162         }
 163
 164         if (t->isIconified() || t->isShaded())
 165         {
 166             continue;
 167         }
 168
 169         if (t->geometry().contains(p))
 170         {
 171             int index = list.indexOf(t->window());
 172             if (index > currentIndex)
 173             {
 174                 currentIndex = index;
 175                 task = t;
 176             }
 177         }
 178     }
 179
 180     return task;
 181 }
 182
 183 void TaskManager::windowAdded(WId w )
 184 {
 185     NETWinInfo info(QX11Info::display(), w, QX11Info::appRootWindow(),
 186                     NET::WMWindowType | NET::WMPid | NET::WMState);
 187
 188     // ignore NET::Tool and other special window types
 189     NET::WindowType wType = info.windowType(NET::NormalMask | NET::DesktopMask | NET::DockMask |
 190                                             NET::ToolbarMask | NET::MenuMask | NET::DialogMask |
 191                                             NET::OverrideMask | NET::TopMenuMask |
 192                                             NET::UtilityMask | NET::SplashMask);
 193
 194     if (wType != NET::Normal && wType != NET::Override && wType != NET::Unknown &&
 195         wType != NET::Dialog && wType != NET::Utility) {
 196         return;
 197     }
 198
 199     // ignore windows that want to be ignored by the taskbar
 200     if ((info.state() & NET::SkipTaskbar) != 0) {
 201         d->skiptaskbarWindows.insert(w); // remember them though
 202         return;
 203     }
 204
 205     Window transient_for_tmp;
 206     if (XGetTransientForHint(QX11Info::display(), (Window)w, &transient_for_tmp)) {
 207         WId transient_for = (WId)transient_for_tmp;
 208
 209         // check if it's transient for a skiptaskbar window
 210         if (d->skiptaskbarWindows.contains( transient_for )) {
 211             return;
 212         }
 213
 214         // lets see if this is a transient for an existing task
 215         if (transient_for != QX11Info::appRootWindow() &&
 216             transient_for != 0 && wType != NET::Utility) {
 217             TaskPtr t = findTask(transient_for);
 218             if (t) {
 219                 if (t->window() != w) {
 220                     t->addTransient(w, info);
 221                     // kDebug() << "TM: Transient " << w << " added for Task: " << t->window();
 222                 }
 223                 return;
 224             }
 225         }
 226     }
 227
 228     TaskPtr t(new Task(w, 0));
 229     d->tasksByWId[w] = t;
 230
 231     connect(t.data(), SIGNAL(changed(::TaskManager::TaskChanges)),
 232             this, SLOT(taskChanged(::TaskManager::TaskChanges)));
 233
 234     if (d->startupInfo) {
 235         KStartupInfoId startupInfoId;
 236         // checkStartup modifies startupInfoId
 237         d->startupInfo->checkStartup(w, startupInfoId);
 238         foreach (StartupPtr startup, d->startups) {
 239             if (startup->id() == startupInfoId) {
 240                 startup->addWindowMatch(w);
 241             }
 242         }
 243     }
 244
 245     // kDebug() << "TM: Task added for WId: " << w;
 246     emit taskAdded(t);
 247 }
 248
 249 void TaskManager::windowRemoved(WId w)
 250 {
 251     d->skiptaskbarWindows.remove(w);
 252
 253     // find task
 254     TaskPtr t = findTask(w);
 255     if (!t)
 256     {
 257         return;
 258     }
 259
 260     if (t->window() == w)
 261     {
 262         d->tasksByWId.remove(w);
 263         emit taskRemoved(t);
 264
 265         if (t == d->active)
 266         {
 267             d->active = 0;
 268         }
 269
 270         //kDebug() << "TM: Task for WId " << w << " removed.";
 271     }
 272     else
 273     {
 274         t->removeTransient(w);
 275         //kDebug() << "TM: Transient " << w << " for Task " << t->window() << " removed.";
 276     }
 277 }
 278
 279 void TaskManager::windowChanged(WId w, unsigned int dirty)
 280 {
 281     if (dirty & NET::WMState) {
 282         NETWinInfo info (QX11Info::display(), w, QX11Info::appRootWindow(),
 283                          NET::WMState | NET::XAWMState);
 284
 285         if (info.state() & NET::SkipTaskbar) {
 286             windowRemoved(w);
 287             d->skiptaskbarWindows.insert(w);
 288             return;
 289         } else {
 290             d->skiptaskbarWindows.remove(w);
 291             if (info.mappingState() != NET::Withdrawn && !findTask(w)) {
 292                 // skipTaskBar state was removed and the window is still
 293                 // mapped, so add this window
 294                 windowAdded(w);
 295             }
 296         }
 297     }
 298
 299     // check if any state we are interested in is marked dirty
 300     if (!(dirty & (NET::WMVisibleName | NET::WMName |
 301                    NET::WMState | NET::WMIcon |
 302                    NET::XAWMState | NET::WMDesktop) ||
 303           (trackGeometry() && dirty & NET::WMGeometry))) {
 304         return;
 305     }
 306
 307     // find task
 308     TaskPtr t = findTask(w);
 309     if (!t) {
 310         return;
 311     }
 312
 313     //kDebug() << "TaskManager::windowChanged " << w << " " << dirty;
 314
 315     if (dirty & NET::WMState) {
 316         t->updateDemandsAttentionState(w);
 317     }
 318
 319     //kDebug() << "got changes, but will we refresh?" << dirty;
 320     if (dirty) {
 321         // only refresh this stuff if we have other changes besides icons
 322         t->refresh(dirty);
 323     }
 324 }
 325
 326 void TaskManager::taskChanged(::TaskManager::TaskChanges changes)
 327 {
 328     Task *t = qobject_cast<Task*>(sender());
 329
 330     if (!t || changes == TaskUnchanged || !d->tasksByWId.contains(t->info().win())) {
 331         return;
 332     }
 333
 334     emit windowChanged(d->tasksByWId[t->info().win()], changes);
 335 }
 336
 337 void TaskManager::activeWindowChanged(WId w)
 338 {
 339     //kDebug() << "TaskManager::activeWindowChanged" << w;
 340     TaskPtr t = findTask(w);
 341     if (!t) {
 342         if (d->active) {
 343             d->active->setActive(false);
 344             d->active = 0;
 345         }
 346         //kDebug() << "no active window";
 347     } else {
 348         if (t->info().windowType(NET::UtilityMask) == NET::Utility) {
 349             // we don't want to mark utility windows as active since task managers
 350             // actually care about the main window and skip utility windows; utility
 351             // windows are hidden when their associated window loses focus anyways
 352             // see http://bugs.kde.org/show_bug.cgi?id=178509
 353             return;
 354         }
 355
 356         if (d->active) {
 357             d->active->setActive(false);
 358         }
 359
 360         d->active = t;
 361         d->active->setActive(true);
 362         //kDebug() << "active window is" << t->name();
 363     }
 364 }
 365
 366 void TaskManager::currentDesktopChanged(int desktop)
 367 {
 368     emit desktopChanged(desktop);
 369 }
 370
 371 void TaskManager::gotNewStartup( const KStartupInfoId& id, const KStartupInfoData& data )
 372 {
 373     StartupPtr s( new Startup( id, data, 0 ) );
 374     d->startups.append(s);
 375
 376     emit startupAdded(s);
 377 }
 378
 379 void TaskManager::gotStartupChange( const KStartupInfoId& id, const KStartupInfoData& data )
 380 {
 381     StartupList::iterator itEnd = d->startups.end();
 382     for (StartupList::iterator sIt = d->startups.begin(); sIt != itEnd; ++sIt)
 383     {
 384         if ((*sIt)->id() == id)
 385         {
 386             (*sIt)->update(data);
 387             return;
 388         }
 389     }
 390 }
 391
 392 void TaskManager::killStartup( const KStartupInfoId& id )
 393 {
 394     StartupList::iterator sIt = d->startups.begin();
 395     StartupList::iterator itEnd = d->startups.end();
 396     StartupPtr s;
 397     for (; sIt != itEnd; ++sIt)
 398     {
 399         if ((*sIt)->id() == id)
 400         {
 401             s = *sIt;
 402             break;
 403         }
 404     }
 405
 406     if (!s) {
 407         return;
 408     }
 409
 410     d->startups.erase(sIt);
 411     emit startupRemoved(s);
 412 }
 413
 414 void TaskManager::killStartup(StartupPtr s)
 415 {
 416     if (!s)
 417     {
 418         return;
 419     }
 420
 421     StartupList::iterator sIt = d->startups.begin();
 422     StartupList::iterator itEnd = d->startups.end();
 423     for (; sIt != itEnd; ++sIt)
 424     {
 425         if ((*sIt) == s)
 426         {
 427             d->startups.erase(sIt);
 428             break;
 429         }
 430     }
 431
 432     emit startupRemoved(s);
 433 }
 434
 435 QString TaskManager::desktopName(int desk) const
 436 {
 437     return KWindowSystem::desktopName(desk);
 438 }
 439
 440 TaskDict TaskManager::tasks() const
 441 {
 442     return d->tasksByWId;
 443 }
 444
 445 StartupList TaskManager::startups() const
 446 {
 447     return d->startups;
 448 }
 449
 450 int TaskManager::numberOfDesktops() const
 451 {
 452     return KWindowSystem::numberOfDesktops();
 453 }
 454
 455 bool TaskManager::isOnTop(const Task* task) const
 456 {
 457     if (!task) {
 458         return false;
 459     }
 460
 461     QList<WId> list = KWindowSystem::stackingOrder();
 462     QList<WId>::const_iterator begin(list.constBegin());
 463     QList<WId>::const_iterator it = list.constBegin() + (list.size() - 1);
 464     do {
 465         TaskDict::const_iterator taskItEnd = d->tasksByWId.constEnd();
 466         for (TaskDict::const_iterator taskIt = d->tasksByWId.constBegin(); taskIt != taskItEnd; ++taskIt) {
 467             TaskPtr t = taskIt.value();
 468             if ((*it) == t->window()) {
 469                 if (t == task) {
 470                     return true;
 471                 }
 472
 473                 if (!t->isIconified() && (t->isAlwaysOnTop() == task->isAlwaysOnTop())) {
 474                     return false;
 475                 }
 476
 477                 break;
 478             }
 479         }
 480     } while (it-- != begin);
 481
 482     return false;
 483 }
 484
 485 void TaskManager::setTrackGeometry(bool track, const QUuid &token)
 486 {
 487     if (track) {
 488         if (!d->trackGeometryTokens.contains(token)) {
 489             d->trackGeometryTokens.insert(token);
 490         }
 491     } else {
 492         d->trackGeometryTokens.remove(token);
 493     }
 494 }
 495
 496 bool TaskManager::trackGeometry() const
 497 {
 498     return !d->trackGeometryTokens.isEmpty();
 499 }
 500
 501 bool TaskManager::isOnScreen(int screen, const WId wid)
 502 {
 503     if (screen == -1) {
 504         return true;
 505     }
 506
 507     KWindowInfo wi = KWindowSystem::windowInfo(wid, NET::WMFrameExtents);
 508
 509     // for window decos that fudge a bit and claim to extend beyond the
 510     // edge of the screen, we just contract a bit.
 511     QRect window = wi.frameGeometry();
 512     QRect desktop = QApplication::desktop()->screenGeometry(screen);
 513     desktop.adjust(5, 5, -5, -5);
 514     return window.intersects(desktop);
 515 }
 516
 517 int TaskManager::currentDesktop() const
 518 {
 519     return KWindowSystem::currentDesktop();
 520 }
 521
 522 } // TaskManager namespace
 523
 524
 525 #include "taskmanager.moc"