workspace/libs/taskmanager/groupmanager.cpp

   1 /*****************************************************************
   2
   3 Copyright 2008 Christian Mollekopf <chrigi_1@hotmail.com>
   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 #include "groupmanager.h"
  25
  26 #include <QList>
  27 #include <KDebug>
  28 #include <QTimer>
  29 #include <QUuid>
  30
  31 #include "abstractsortingstrategy.h"
  32 #include "startup.h"
  33 #include "task.h"
  34 #include "taskitem.h"
  35 #include "taskgroup.h"
  36 #include "taskmanager.h"
  37 #include "strategies/alphasortingstrategy.h"
  38 #include "strategies/desktopsortingstrategy.h"
  39 #include "strategies/programgroupingstrategy.h"
  40 #include "strategies/manualgroupingstrategy.h"
  41 #include "strategies/manualsortingstrategy.h"
  42
  43 namespace TaskManager
  44 {
  45
  46 class GroupManagerPrivate
  47 {
  48 public:
  49     GroupManagerPrivate(GroupManager *manager)
  50         : q(manager),
  51           rootGroup(0),
  52           sortingStrategy(GroupManager::NoSorting),
  53           groupingStrategy(GroupManager::NoGrouping),
  54           lastGroupingStrategy(GroupManager::NoGrouping),
  55           abstractGroupingStrategy(0),
  56           abstractSortingStrategy(0),
  57           currentScreen(-1),
  58           groupIsFullLimit(0),
  59           showOnlyCurrentDesktop(false),
  60           showOnlyCurrentScreen(false),
  61           showOnlyMinimized(false),
  62           onlyGroupWhenFull(false),
  63           changingGroupingStragegy(false)
  64     {
  65     }
  66
  67     /** reload all tasks from TaskManager */
  68     void reloadTasks();
  69
  70     /**
  71     * Keep track of changes in Taskmanager
  72     */
  73     void currentDesktopChanged(int);
  74     void taskChanged(TaskPtr, ::TaskManager::TaskChanges);
  75
  76     void checkScreenChange();
  77
  78     void itemDestroyed();
  79     void checkIfFull();
  80
  81     GroupManager *q;
  82     QHash<TaskPtr, TaskItem*> itemList; //holds all tasks of the Taskmanager
  83     QHash<StartupPtr, TaskItem*> startupList;
  84     TaskGroup *rootGroup; //the current layout
  85     GroupManager::TaskSortingStrategy sortingStrategy;
  86     GroupManager::TaskGroupingStrategy groupingStrategy;
  87     GroupManager::TaskGroupingStrategy lastGroupingStrategy;
  88     AbstractGroupingStrategy *abstractGroupingStrategy;
  89     AbstractSortingStrategy *abstractSortingStrategy;
  90     int currentScreen;
  91     QTimer screenTimer;
  92     QList<TaskPtr> geometryTasks;
  93     int groupIsFullLimit;
  94     bool showOnlyCurrentDesktop : 1;
  95     bool showOnlyCurrentScreen : 1;
  96     bool showOnlyMinimized : 1;
  97     bool onlyGroupWhenFull : 1;
  98     bool changingGroupingStragegy : 1;
  99     QUuid configToken;
 100 };
 101
 102
 103
 104
 105 GroupManager::GroupManager(QObject *parent)
 106     : QObject(parent),
 107       d(new GroupManagerPrivate(this))
 108 {
 109     connect(TaskManager::self(), SIGNAL(taskAdded(TaskPtr)), this, SLOT(add(TaskPtr)));
 110     connect(TaskManager::self(), SIGNAL(taskRemoved(TaskPtr)), this, SLOT(remove(TaskPtr)));
 111     connect(TaskManager::self(), SIGNAL(startupAdded(StartupPtr)), this, SLOT(add(StartupPtr)));
 112     connect(TaskManager::self(), SIGNAL(startupRemoved(StartupPtr)), this, SLOT(remove(StartupPtr)));
 113     d->rootGroup = new TaskGroup(this, "RootGroup", Qt::transparent);
 114     //reloadTasks();
 115     d->screenTimer.setSingleShot(true);
 116     d->screenTimer.setInterval(100);
 117     connect(&d->screenTimer, SIGNAL(timeout()), this, SLOT(checkScreenChange()));
 118 }
 119
 120 GroupManager::~GroupManager()
 121 {
 122     TaskManager::TaskManager::self()->setTrackGeometry(false, d->configToken);
 123     delete d->abstractSortingStrategy;
 124     delete d->abstractGroupingStrategy;
 125     delete d->rootGroup;
 126     delete d;
 127 }
 128
 129 void GroupManagerPrivate::reloadTasks()
 130 {
 131     //kDebug() << "number of tasks available " << TaskManager::self()->tasks().size();
 132
 133     QList <TaskPtr> taskList = TaskManager::self()->tasks().values();
 134     foreach (const TaskPtr& task, taskList) { //Add all existing tasks
 135         if (!q->add(task)) {
 136             q->remove(task); //remove what isn't needed anymore
 137         }
 138         taskList.removeAll(task);
 139     }
 140
 141     foreach (const TaskPtr& task, taskList) { //Remove the remaining
 142         q->remove(task);
 143     }
 144
 145     emit q->reload();
 146 }
 147
 148 void GroupManager::add(StartupPtr task)
 149 {
 150     //kDebug();
 151     TaskItem *item;
 152     if (!d->startupList.contains(task)) {
 153         item = new TaskItem(this, task);
 154         d->startupList.insert(task, item);
 155         d->rootGroup->add(item);
 156     }
 157 }
 158
 159 void GroupManager::remove(StartupPtr task)
 160 {
 161     //kDebug() << "startup";
 162     if (!d->startupList.contains(task)) {
 163         kDebug() << "invalid startup task";
 164         return;
 165     }
 166
 167     AbstractItemPtr item = d->startupList.take(task);
 168     if (item->parentGroup()) {
 169         item->parentGroup()->remove(item);
 170     }
 171
 172     emit itemRemoved(item);
 173 }
 174
 175 bool GroupManager::add(TaskPtr task)
 176 {
 177     /* kDebug() << task->visibleName()
 178              << task->visibleNameWithState()
 179              << task->name()
 180              << task->className()
 181              << task->classClass(); */
 182
 183     if (!task->showInTaskbar()) {
 184         //kDebug() << "Do not show in taskbar";
 185         return false;
 186     }
 187
 188     if (showOnlyCurrentScreen() && !task->isOnScreen(d->currentScreen)) {
 189         //kDebug() << "Not on this screen and showOnlyCurrentScreen";
 190         return false;
 191     }
 192
 193     // Should the Task be displayed ? We always display if attention is demaded
 194     if (!task->demandsAttention()) {
 195         // As the Task doesn't demand attention
 196         // go through all filters whether the task should be displayed or not
 197         if (showOnlyCurrentDesktop() && !task->isOnCurrentDesktop()) {
 198             /* kDebug() << "Not on this desktop and showOnlyCurrentDesktop"
 199                      << KWindowSystem::currentDesktop() << task->desktop(); */
 200             return false;
 201         }
 202
 203         if (showOnlyMinimized() && !task->isMinimized()) {
 204             //kDebug() << "Not minimized and only showing minimized";
 205             return false;
 206         }
 207
 208         NET::WindowType type = task->info().windowType(NET::NormalMask | NET::DialogMask |
 209                                                     NET::OverrideMask | NET::UtilityMask);
 210         if (type == NET::Utility) {
 211             //kDebug() << "skipping utility window" << task->name();
 212             return false;
 213         }
 214
 215             //TODO: should we check for transiency? if so the following code can detect it.
 216         /*
 217             QHash <TaskPtr, TaskItem*>::iterator it = d->itemList.begin();
 218
 219             while (it != d->itemList.end()) {
 220                 TaskItem *item = it.value();
 221                 if (item->task()->hasTransient(task->window())) {
 222                     kDebug() << "TRANSIENT TRANSIENT TRANSIENT!";
 223                     return flase;
 224                 }
 225                 ++it;
 226             }
 227         */
 228     }
 229
 230     //Ok the Task should be displayed
 231     TaskItem *item = 0;
 232     if (!d->itemList.contains(task)) {
 233         //Lookout for existing startuptask of this task
 234         QMutableHashIterator<StartupPtr, TaskItem*> it(d->startupList);
 235         while (it.hasNext()) {
 236             it.next();
 237             if (it.key()->matchesWindow(task->window())) {
 238                 //kDebug() << "startup task";
 239                 item = it.value();
 240                 item->setTaskPointer(task);
 241                 it.remove();
 242                 break;
 243             }
 244         }
 245
 246         if (!item) {
 247             item = new TaskItem(this, task);
 248         }
 249
 250         connect(item, SIGNAL(destroyed()), this, SLOT(itemDestroyed()));
 251         d->itemList.insert(task, item);
 252     } else {
 253         item = d->itemList.value(task); //we add it again so the group is evaluated again
 254     }
 255
 256     //Find a fitting group for the task with GroupingStrategies
 257     if (d->abstractGroupingStrategy && !task->demandsAttention()) { //do not group attetion tasks
 258         d->abstractGroupingStrategy->handleItem(item);
 259     } else {
 260         d->rootGroup->add(item);
 261     }
 262
 263     return true;
 264 }
 265
 266
 267 void GroupManager::remove(TaskPtr task)
 268 {
 269     //kDebug() << "remove: " << task->visibleName();
 270     if (!d->geometryTasks.isEmpty()) {
 271         d->geometryTasks.removeAll(task);
 272     }
 273
 274     TaskItem *item = d->itemList.value(task);
 275     if (!item) {
 276         // this can happen if the window hasn't been caught previously,
 277         // of it its an ignored type such as a NET::Utility type window
 278         //kDebug() << "invalid item";
 279         return;
 280     }
 281
 282     if (item->parentGroup()) {
 283         item->parentGroup()->remove(item);
 284     }
 285
 286     emit itemRemoved(item);
 287     //the item must exist as long as the TaskPtr does because of activate calls so don't delete the item here, it will delete itself. We keep it in the itemlist because it may return
 288 }
 289
 290 void GroupManagerPrivate::itemDestroyed()
 291 {
 292     TaskItem *taskItem = qobject_cast<TaskItem*>(q->sender());
 293     TaskItem *item = itemList.take(itemList.key(taskItem));
 294     if (!item) {
 295         kDebug() << "invalid item";
 296         return;
 297     }
 298     QObject::disconnect(item, 0, q, 0);
 299 }
 300
 301
 302 bool GroupManager::manualGroupingRequest(AbstractGroupableItem* item, TaskGroup* groupItem)
 303 {
 304     //kDebug();
 305     if (d->abstractGroupingStrategy) {
 306         return d->abstractGroupingStrategy->addItemToGroup(item, groupItem);
 307     //    kDebug() << d->abstractGroupingStrategy->type() << ManualGrouping;
 308         /*if (d->abstractGroupingStrategy->type() == ManualGrouping) {
 309    //         kDebug();
 310             return (qobject_cast<ManualGroupingStrategy*>(d->abstractGroupingStrategy))->addItemToGroup(item,groupItem);
 311         }*/
 312     }
 313     return false;
 314 }
 315
 316 bool GroupManager::manualGroupingRequest(ItemList items)
 317 {
 318     // kDebug();
 319     if (d->abstractGroupingStrategy) {
 320      //   kDebug() << d->abstractGroupingStrategy->type() << ManualGrouping;
 321         if (d->abstractGroupingStrategy->type() == ManualGrouping) {
 322       //      kDebug();
 323             return (qobject_cast<ManualGroupingStrategy*>(d->abstractGroupingStrategy))->groupItems(items);
 324         }
 325     }
 326     return false;
 327 }
 328
 329 bool GroupManager::manualSortingRequest(AbstractGroupableItem* taskItem, int newIndex)
 330 {
 331     //kDebug();
 332     if (d->abstractSortingStrategy) {
 333         if (d->abstractSortingStrategy->type() == ManualSorting) {
 334             return (qobject_cast<ManualSortingStrategy*>(d->abstractSortingStrategy))->moveItem(taskItem, newIndex);
 335         }
 336     }
 337     return false;
 338 }
 339
 340
 341 GroupPtr GroupManager::rootGroup() const
 342 {
 343     return d->rootGroup;
 344 }
 345
 346
 347 void GroupManagerPrivate::currentDesktopChanged(int newDesktop)
 348 {
 349     //kDebug();
 350     if (!showOnlyCurrentDesktop) {
 351         return;
 352     }
 353
 354     if (abstractSortingStrategy) {
 355         abstractSortingStrategy->desktopChanged(newDesktop);
 356     }
 357
 358     if (abstractGroupingStrategy) {
 359         abstractGroupingStrategy->desktopChanged(newDesktop);
 360     }
 361
 362     reloadTasks();
 363 }
 364
 365
 366 void GroupManagerPrivate::taskChanged(TaskPtr task, ::TaskManager::TaskChanges changes)
 367 {
 368     //kDebug();
 369     bool takeAction = false;
 370     bool show = true;
 371
 372     if (showOnlyCurrentDesktop && changes & ::TaskManager::DesktopChanged) {
 373         takeAction = true;
 374         show = task->isOnCurrentDesktop();
 375         //kDebug() << task->visibleName() << "on" << TaskManager::self()->currentDesktop();
 376     }
 377
 378     if (showOnlyMinimized && changes & ::TaskManager::StateChanged) {
 379         //TODO: wouldn't it be nice to get notification of JUST minimization?
 380         takeAction = true;
 381         show = task->isMinimized();
 382     }
 383
 384     if (changes & ::TaskManager::GeometryChanged) {
 385         if (!geometryTasks.contains(task)) {
 386             geometryTasks.append(task);
 387         }
 388
 389         if (!screenTimer.isActive()) {
 390             screenTimer.start();
 391         }
 392     }
 393
 394     //show tasks anyway if they demand attention
 395     if (changes & ::TaskManager::StateChanged && task->demandsAttention()) {
 396         takeAction = true;
 397         show = true;
 398     }
 399
 400     if (!takeAction) {
 401         return;
 402     }
 403
 404     if (show) {
 405         //kDebug() << "add(task);";
 406         q->add(task);
 407     } else {
 408         //kDebug() << "remove(task);";
 409         q->remove(task);
 410     }
 411 }
 412
 413 void GroupManager::setScreen(int screen)
 414 {
 415     //kDebug() << "new Screen: " << screen;
 416     d->currentScreen = screen;
 417 }
 418
 419
 420 void GroupManagerPrivate::checkScreenChange()
 421 {
 422     //kDebug();
 423     foreach (const TaskPtr &task, geometryTasks) {
 424         if (task->isOnScreen(currentScreen)) {
 425             q->add(task);
 426         } else {
 427             q->remove(task);
 428         }
 429     }
 430
 431     geometryTasks.clear();
 432 }
 433
 434
 435 void GroupManager::reconnect()
 436 {
 437     //kDebug();
 438     disconnect(TaskManager::self(), SIGNAL(desktopChanged(int)),
 439                this, SLOT(currentDesktopChanged(int)));
 440     disconnect(TaskManager::self(), SIGNAL(windowChanged(TaskPtr,::TaskManager::TaskChanges)),
 441                this, SLOT(taskChanged(TaskPtr,::TaskManager::TaskChanges)));
 442
 443     if (d->showOnlyCurrentDesktop || d->showOnlyMinimized || d->showOnlyCurrentScreen) {
 444         // listen to the relevant task manager signals
 445         if (d->showOnlyCurrentDesktop) {
 446             connect(TaskManager::TaskManager::self(), SIGNAL(desktopChanged(int)),
 447                     this, SLOT(currentDesktopChanged(int)));
 448         }
 449
 450         connect(TaskManager::self(), SIGNAL(windowChanged(TaskPtr,::TaskManager::TaskChanges)),
 451                 this, SLOT(taskChanged(TaskPtr,::TaskManager::TaskChanges)));
 452     }
 453
 454     TaskManager::TaskManager::self()->setTrackGeometry(d->showOnlyCurrentScreen, d->configToken);
 455
 456     if (!d->showOnlyCurrentScreen) {
 457         d->geometryTasks.clear();
 458     }
 459
 460     d->reloadTasks();
 461 }
 462
 463
 464 bool GroupManager::onlyGroupWhenFull() const
 465 {
 466     return d->onlyGroupWhenFull;
 467 }
 468
 469 void GroupManager::setOnlyGroupWhenFull(bool state)
 470 {
 471     //kDebug() << state;
 472     if (d->onlyGroupWhenFull == state) {
 473         return;
 474     }
 475
 476     d->onlyGroupWhenFull = state;
 477
 478     if (state) {
 479         connect(d->rootGroup, SIGNAL(itemAdded(AbstractItemPtr)), this, SLOT(checkIfFull()));
 480         connect(d->rootGroup, SIGNAL(itemRemoved(AbstractItemPtr)), this, SLOT(checkIfFull()));
 481         d->checkIfFull();
 482     } else {
 483         disconnect(d->rootGroup, SIGNAL(itemAdded(AbstractItemPtr)), this, SLOT(checkIfFull()));
 484         disconnect(d->rootGroup, SIGNAL(itemRemoved(AbstractItemPtr)), this, SLOT(checkIfFull()));
 485     }
 486 }
 487
 488 void GroupManager::setFullLimit(int limit)
 489 {
 490     //kDebug() << limit;
 491     d->groupIsFullLimit = limit;
 492     if (d->onlyGroupWhenFull) {
 493         d->checkIfFull();
 494     }
 495 }
 496
 497 void GroupManagerPrivate::checkIfFull()
 498 {
 499     //kDebug();
 500     if (!onlyGroupWhenFull || groupingStrategy != GroupManager::ProgramGrouping) {
 501         return;
 502     }
 503
 504     if (itemList.size() >= groupIsFullLimit) {
 505         if (!abstractGroupingStrategy) {
 506             q->setGroupingStrategy(GroupManager::ProgramGrouping);
 507         }
 508     } else if (abstractGroupingStrategy) {
 509         q->setGroupingStrategy(GroupManager::NoGrouping);
 510         //let the visualization thing we still use the programGrouping
 511         groupingStrategy = GroupManager::ProgramGrouping;
 512     }
 513 }
 514
 515 bool GroupManager::showOnlyCurrentScreen() const
 516 {
 517     return d->showOnlyCurrentScreen;
 518 }
 519
 520 void GroupManager::setShowOnlyCurrentScreen(bool showOnlyCurrentScreen)
 521 {
 522     d->showOnlyCurrentScreen = showOnlyCurrentScreen;
 523 }
 524
 525 bool GroupManager::showOnlyCurrentDesktop() const
 526 {
 527     return d->showOnlyCurrentDesktop;
 528 }
 529
 530 void GroupManager::setShowOnlyCurrentDesktop(bool showOnlyCurrentDesktop)
 531 {
 532     d->showOnlyCurrentDesktop = showOnlyCurrentDesktop;
 533 }
 534
 535 bool GroupManager::showOnlyMinimized() const
 536 {
 537     return d->showOnlyMinimized;
 538 }
 539
 540 void GroupManager::setShowOnlyMinimized(bool showOnlyMinimized)
 541 {
 542     d->showOnlyMinimized = showOnlyMinimized;
 543 }
 544
 545 GroupManager::TaskSortingStrategy GroupManager::sortingStrategy() const
 546 {
 547     return d->sortingStrategy;
 548 }
 549
 550 AbstractSortingStrategy* GroupManager::taskSorter() const
 551 {
 552     return d->abstractSortingStrategy;
 553 }
 554
 555 void GroupManager::setSortingStrategy(TaskSortingStrategy sortOrder)
 556 {
 557     //kDebug() << sortOrder;
 558
 559     if (d->abstractSortingStrategy) {
 560         if (d->abstractSortingStrategy->type() == sortOrder){
 561             return;
 562         } else {
 563             d->abstractSortingStrategy->deleteLater();
 564         }
 565     }
 566
 567     switch (sortOrder) {
 568         case NoSorting: //manual and no grouping result both in non automatic grouping
 569             d->abstractSortingStrategy = 0;
 570             break;
 571         case ManualSorting:
 572             d->abstractSortingStrategy = new ManualSortingStrategy(this);
 573             d->abstractSortingStrategy->handleGroup(d->rootGroup);
 574             break;
 575
 576         case AlphaSorting:
 577             d->abstractSortingStrategy = new AlphaSortingStrategy(this);
 578             d->abstractSortingStrategy->handleGroup(d->rootGroup);
 579             break;
 580
 581         case DesktopSorting:
 582             d->abstractSortingStrategy = new DesktopSortingStrategy(this);
 583             d->abstractSortingStrategy->handleGroup(d->rootGroup);
 584             break;
 585
 586         default:
 587             kDebug() << "Invalid Strategy";
 588             d->abstractSortingStrategy = 0;
 589     }
 590
 591     d->sortingStrategy = sortOrder;
 592     d->reloadTasks();
 593 }
 594
 595 GroupManager::TaskGroupingStrategy GroupManager::groupingStrategy() const
 596 {
 597     return d->groupingStrategy;
 598 }
 599
 600 AbstractGroupingStrategy* GroupManager::taskGrouper() const
 601 {
 602     return d->abstractGroupingStrategy;
 603 }
 604
 605 void GroupManager::setGroupingStrategy(TaskGroupingStrategy strategy)
 606 {
 607     if (d->changingGroupingStragegy ||
 608         (d->abstractGroupingStrategy && d->abstractGroupingStrategy->type() == strategy)) {
 609         return;
 610     }
 611
 612     d->changingGroupingStragegy = true;
 613
 614     //kDebug() << strategy << kBacktrace();
 615     if (d->onlyGroupWhenFull) {
 616         disconnect(d->rootGroup, SIGNAL(itemAdded(AbstractItemPtr)), this, SLOT(checkIfFull()));
 617         disconnect(d->rootGroup, SIGNAL(itemRemoved(AbstractItemPtr)), this, SLOT(checkIfFull()));
 618     }
 619
 620     delete d->abstractGroupingStrategy;
 621     d->abstractGroupingStrategy = 0;
 622
 623     switch (strategy) {
 624         case NoGrouping:
 625             d->abstractGroupingStrategy = 0;
 626             break;
 627         case ManualGrouping:
 628             d->abstractGroupingStrategy = new ManualGroupingStrategy(this);
 629             break;
 630
 631         case ProgramGrouping:
 632             d->abstractGroupingStrategy = new ProgramGroupingStrategy(this);
 633             break;
 634
 635         default:
 636             kDebug() << "Strategy not implemented";
 637             d->abstractGroupingStrategy = 0;
 638     }
 639
 640     d->groupingStrategy = strategy;
 641
 642     if (d->groupingStrategy) {
 643         connect(d->abstractGroupingStrategy, SIGNAL(groupRemoved(TaskGroup*)),
 644                 this, SIGNAL(groupRemoved(TaskGroup*)));
 645     }
 646
 647     d->reloadTasks();
 648
 649     if (d->onlyGroupWhenFull) {
 650         connect(d->rootGroup, SIGNAL(itemAdded(AbstractItemPtr)), this, SLOT(checkIfFull()));
 651         connect(d->rootGroup, SIGNAL(itemRemoved(AbstractItemPtr)), this, SLOT(checkIfFull()));
 652     }
 653
 654     d->changingGroupingStragegy = false;
 655 }
 656
 657 } // TaskManager namespace
 658
 659 #include "groupmanager.moc"
 660