workspace/libs/taskmanager/taskgroup.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 // Own
  25 #include "taskgroup.h"
  26 #include "taskmanager.h"
  27 #include "taskitem.h"
  28 #include "groupmanager.h"
  29
  30 // Qt
  31 #include <QColor>
  32 #include <QMimeData>
  33
  34 // KDE
  35 #include <KDebug>
  36 #include <KIcon>
  37 #include <ksharedptr.h>
  38
  39
  40
  41 namespace TaskManager
  42 {
  43
  44
  45 class TaskGroup::Private
  46 {
  47 public:
  48     Private()
  49     {
  50     }
  51
  52     QList<WId> winIds() const;
  53
  54     ItemList members;
  55     QString groupName;
  56     QColor groupColor;
  57     QIcon groupIcon;
  58     bool aboutToDie;
  59     GroupManager *groupingStrategy;
  60 };
  61
  62 TaskGroup::TaskGroup(GroupManager *parent,const QString &name, const QColor &color)
  63 :   AbstractGroupableItem(parent),
  64     d(new Private)
  65 {
  66     d->groupingStrategy = parent;
  67     d->groupName = name;
  68     d->groupColor = color;
  69     d->groupIcon = KIcon("xorg");
  70     connect(this, SLOT(editRequest()), this, SIGNAL(groupEditRequest()));
  71     //kDebug() << "Group Created: Name: " << d->groupName << "Color: " << d->groupColor;
  72 }
  73
  74 TaskGroup::TaskGroup(GroupManager *parent)
  75 :   AbstractGroupableItem(parent),
  76     d(new Private)
  77 {
  78     d->groupingStrategy = parent;
  79 //    d->groupName = "default";
  80     d->groupColor = Qt::red;
  81     d->groupIcon = KIcon("xorg");
  82     connect(this, SLOT(editRequest()), this, SIGNAL(groupEditRequest()));
  83     //kDebug() << "Group Created: Name: " << d->groupName << "Color: " << d->groupColor;
  84 }
  85
  86
  87 TaskGroup::~TaskGroup()
  88 {
  89     //kDebug() << name();
  90     delete d;
  91 }
  92
  93
  94 void TaskGroup::add(AbstractItemPtr item)
  95 {
  96 /*    if (!item->isGroupItem()) {
  97         if ((dynamic_cast<TaskItem*>(item))->task()) {
  98             kDebug() << "Add item" << (dynamic_cast<TaskItem*>(item))->task()->visibleName();
  99         }
 100         kDebug() << " to Group " << name();
 101     }
 102 */
 103
 104     if (d->members.contains(item)) {
 105         //kDebug() << "already in this group";
 106         return;
 107     }
 108
 109     if (d->groupName.isEmpty()) {
 110         TaskItem *taskItem = qobject_cast<TaskItem*>(item);
 111         if (taskItem) {
 112             d->groupName = taskItem->task()->classClass();
 113         }
 114     }
 115
 116     if (item->parentGroup()) {
 117         item->parentGroup()->remove(item);
 118     }
 119
 120     d->members.append(item);
 121     item->setParentGroup(this);
 122
 123     connect(item, SIGNAL(changed(::TaskManager::TaskChanges)),
 124             this, SIGNAL(changed(::TaskManager::TaskChanges)));
 125     //For debug
 126    /* foreach (AbstractGroupableItem *item, d->members) {
 127         if (item->isGroupItem()) {
 128             kDebug() << (dynamic_cast<TaskGroup*>(item))->name();
 129         } else {
 130             kDebug() << (dynamic_cast<TaskItem*>(item))->task()->visibleName();
 131         }
 132     }*/
 133     emit itemAdded(item);
 134 }
 135
 136 void TaskGroup::remove(AbstractItemPtr item)
 137 {
 138     Q_ASSERT(item);
 139
 140     /*
 141     if (item->isGroupItem()) {
 142         kDebug() << "Remove group" << (dynamic_cast<TaskGroup*>(item))->name();
 143     } else if ((dynamic_cast<TaskItem*>(item))->task()) {
 144         kDebug() << "Remove item" << (dynamic_cast<TaskItem*>(item))->task()->visibleName();
 145     }
 146     kDebug() << "from Group: " << name();
 147     */
 148
 149    /* kDebug() << "GroupMembers: ";
 150     foreach (AbstractGroupableItem *item, d->members) {
 151         if (item->isGroupItem()) {
 152             kDebug() << (dynamic_cast<TaskGroup*>(item))->name();
 153         } else {
 154             kDebug() << (dynamic_cast<TaskItem*>(item))->task()->visibleName();
 155         }
 156     }*/
 157
 158     if (!d->members.contains(item)) {
 159         //kDebug() << "couldn't find item";
 160         return;
 161     }
 162
 163     disconnect(item, 0, this, 0);
 164
 165     d->members.removeAll(item);
 166     item->setParentGroup(0);
 167     /*if(d->members.isEmpty()){
 168         kDebug() << "empty";
 169         emit empty(this);
 170     }*/
 171     emit itemRemoved(item);
 172 }
 173
 174 void TaskGroup::clear()
 175 {
 176    // kDebug() << "size " << d->members.size();
 177     foreach(AbstractGroupableItem *item, d->members) {
 178     //    kDebug();
 179         Q_ASSERT(item);
 180         if (item->isGroupItem()) {
 181             (dynamic_cast<GroupPtr>(item))->clear();
 182         }
 183         remove(item);
 184     }
 185
 186     if (!d->members.isEmpty()) {
 187         kDebug() << "clear doesn't work";
 188     }
 189 }
 190
 191 ItemList TaskGroup::members() const
 192 {
 193     return d->members;
 194 }
 195
 196 void TaskGroup::setColor(const QColor &color)
 197 {
 198     d->groupColor = color;
 199     emit changed(ColorChanged);
 200 }
 201
 202 QColor TaskGroup::color() const
 203 {
 204     return d->groupColor;
 205 }
 206
 207 QString TaskGroup::name() const
 208 {
 209     return d->groupName;
 210 }
 211
 212 void TaskGroup::setName(const QString &newName)
 213 {
 214     d->groupName = newName;
 215     emit changed(NameChanged);
 216 }
 217
 218 QIcon TaskGroup::icon() const
 219 {
 220     return d->groupIcon;
 221 }
 222
 223 void TaskGroup::setIcon(const QIcon &newIcon)
 224 {
 225     d->groupIcon = newIcon;
 226     emit changed(IconChanged);
 227 }
 228
 229 bool TaskGroup::isRootGroup() const
 230 {
 231     return !parentGroup();
 232 }
 233
 234 /** only true if item is in this group */
 235 bool TaskGroup::hasDirectMember(AbstractItemPtr item) const
 236 {
 237     return d->members.contains(item);
 238 }
 239
 240 /** true if item is in this or any sub group */
 241 bool TaskGroup::hasMember(AbstractItemPtr item) const
 242 {
 243     //kDebug();
 244     TaskGroup *group = item->parentGroup();
 245     while (group) {
 246         if (group == this) {
 247             return true;
 248         }
 249         group = group->parentGroup();
 250     }
 251     return false;
 252 }
 253
 254 /** Returns Direct Member group if the passed item is in a subgroup */
 255 AbstractItemPtr TaskGroup::directMember(AbstractItemPtr item) const
 256 {
 257     AbstractItemPtr tempItem = item;
 258     while (tempItem) {
 259         if (d->members.contains(item)) {
 260             return item;
 261         }
 262         tempItem = tempItem->parentGroup();
 263     }
 264
 265     kDebug() << "item not found";
 266     return AbstractItemPtr();
 267 }
 268
 269 void TaskGroup::setShaded(bool state)
 270 {
 271     foreach (AbstractItemPtr item, d->members) {
 272         item->setShaded(state);
 273     }
 274 }
 275
 276 void TaskGroup::toggleShaded()
 277 {
 278     setShaded(!isShaded());
 279 }
 280
 281 bool TaskGroup::isShaded() const
 282 {
 283     foreach (AbstractItemPtr item, d->members) {
 284         if (!item->isShaded()) {
 285             return false;
 286         }
 287     }
 288     return true;
 289 }
 290
 291 void TaskGroup::toDesktop(int desk)
 292 {
 293     foreach (AbstractItemPtr item, d->members) {
 294         item->toDesktop(desk);
 295     }
 296     emit movedToDesktop(desk);
 297 }
 298
 299 bool TaskGroup::isOnCurrentDesktop() const
 300 {
 301     foreach (AbstractItemPtr item, d->members) {
 302         if (!item->isOnCurrentDesktop()) {
 303             return false;
 304         }
 305     }
 306     return true;
 307 }
 308
 309 QList<WId> TaskGroup::Private::winIds() const
 310 {
 311     QList<WId> ids;
 312
 313     foreach (AbstractGroupableItem *groupable, members) {
 314         if (groupable->isGroupItem()) {
 315             TaskGroup *group = dynamic_cast<TaskGroup*>(groupable);
 316             if (group) {
 317                 ids << group->d->winIds();
 318             }
 319         } else {
 320             TaskItem * item = dynamic_cast<TaskItem*>(groupable);
 321             if (item) {
 322                 ids << item->task()->info().win();
 323             }
 324         }
 325     }
 326
 327     return ids;
 328 }
 329
 330 void TaskGroup::addMimeData(QMimeData *mimeData) const
 331 {
 332     //kDebug() << d->members.count();
 333     if (d->members.isEmpty()) {
 334         return;
 335     }
 336
 337     QByteArray data;
 338     QList<WId> ids = d->winIds();
 339     int count = ids.count();
 340     data.resize(sizeof(int) + sizeof(WId) * count);
 341     memcpy(data.data(), &count, sizeof(int));
 342     int i = 0;
 343     foreach (WId id, ids) {
 344         //kDebug() << "adding" << id;
 345         memcpy(data.data() + sizeof(int) + sizeof(WId) * i, &id, sizeof(WId));
 346         ++i;
 347     }
 348
 349     //kDebug() << "done:" << data.size() << count;
 350     mimeData->setData(Task::groupMimetype(), data);
 351 }
 352
 353 bool TaskGroup::isOnAllDesktops() const
 354 {
 355     foreach (AbstractItemPtr item, d->members) {
 356         if (!item->isOnAllDesktops()) {
 357             return false;
 358         }
 359     }
 360     return true;
 361 }
 362
 363 //return 0 if tasks are on different desktops or on all dektops
 364 int TaskGroup::desktop() const
 365 {
 366     if (d->members.isEmpty()) {
 367         return 0;
 368     }
 369
 370     int desk = d->members.first()->desktop();
 371     foreach (AbstractItemPtr item, d->members) {
 372         if (item->desktop() != desk) {
 373             return 0;
 374         }
 375         desk = item->desktop();
 376     }
 377     return desk;
 378 }
 379
 380 void TaskGroup::setMaximized(bool state)
 381 {
 382     foreach (AbstractItemPtr item, d->members) {
 383         item->setMaximized(state);
 384     }
 385 }
 386
 387 void TaskGroup::toggleMaximized()
 388 {
 389     setMaximized(!isMaximized());
 390 }
 391
 392 bool TaskGroup::isMaximized() const
 393 {
 394     foreach (AbstractItemPtr item, d->members) {
 395         if (!item->isMaximized()) {
 396             return false;
 397         }
 398     }
 399     return true;
 400 }
 401
 402 void TaskGroup::setMinimized(bool state)
 403 {
 404     foreach (AbstractItemPtr item, d->members) {
 405         item->setMinimized(state);
 406     }
 407 }
 408
 409 void TaskGroup::toggleMinimized()
 410 {
 411     setMinimized(!isMinimized());
 412 }
 413
 414 bool TaskGroup::isMinimized() const
 415 {
 416     foreach (AbstractItemPtr item, d->members) {
 417         if (!item->isMinimized()) {
 418             return false;
 419         }
 420     }
 421     return true;
 422 }
 423
 424 void TaskGroup::setFullScreen(bool state)
 425 {
 426     foreach (AbstractItemPtr item, d->members) {
 427         item->setFullScreen(state);
 428     }
 429 }
 430
 431 void TaskGroup::toggleFullScreen()
 432 {
 433     setFullScreen(!isFullScreen());
 434 }
 435
 436 bool TaskGroup::isFullScreen() const
 437 {
 438     foreach (AbstractItemPtr item, d->members) {
 439         if (!item->isFullScreen()) {
 440             return false;
 441         }
 442     }
 443     return true;
 444 }
 445
 446 void TaskGroup::setKeptBelowOthers(bool state)
 447 {
 448     foreach (AbstractItemPtr item, d->members) {
 449         item->setKeptBelowOthers(state);
 450     }
 451 }
 452
 453 void TaskGroup::toggleKeptBelowOthers()
 454 {
 455     setKeptBelowOthers(!isKeptBelowOthers());
 456 }
 457
 458 bool TaskGroup::isKeptBelowOthers() const
 459 {
 460     foreach (AbstractItemPtr item, d->members) {
 461         if (!item->isKeptBelowOthers()) {
 462             return false;
 463         }
 464     }
 465     return true;
 466 }
 467
 468 void TaskGroup::setAlwaysOnTop(bool state)
 469 {
 470     foreach (AbstractItemPtr item, d->members) {
 471         item->setAlwaysOnTop(state);
 472     }
 473 }
 474
 475 void TaskGroup::toggleAlwaysOnTop()
 476 {
 477     setAlwaysOnTop(!isAlwaysOnTop());
 478 }
 479
 480 bool TaskGroup::isAlwaysOnTop() const
 481 {
 482     foreach (AbstractItemPtr item, d->members) {
 483         if (!item->isAlwaysOnTop()) {
 484             return false;
 485         }
 486     }
 487     return true;
 488 }
 489
 490 bool TaskGroup::isActionSupported(NET::Action action) const
 491 {
 492     if (KWindowSystem::allowedActionsSupported()) {
 493         foreach (AbstractItemPtr item, d->members) {
 494             if (!item->isActionSupported(action)) {
 495                 return false;
 496             }
 497         }
 498         return true;
 499     }
 500     return false;
 501 }
 502
 503 void TaskGroup::close()
 504 {
 505     foreach (AbstractItemPtr item, d->members) {
 506         item->close();
 507     }
 508 }
 509
 510 bool TaskGroup::isActive() const
 511 {
 512     foreach (AbstractItemPtr item, d->members) {
 513         if (item->isActive()) {
 514             return true;
 515         }
 516     }
 517
 518     return false;
 519 }
 520
 521 bool TaskGroup::demandsAttention() const
 522 {
 523     foreach (AbstractItemPtr item, d->members) {
 524         if (item->demandsAttention()) {
 525             return true;
 526         }
 527     }
 528
 529     return false;
 530 }
 531
 532 bool TaskGroup::moveItem(int oldIndex, int newIndex)
 533 {
 534     //kDebug() << oldIndex << newIndex;
 535     if ((d->members.count() <= newIndex) || (newIndex < 0) ||
 536         (d->members.count() <= oldIndex || oldIndex < 0)) {
 537         kDebug() << "index out of bounds";
 538         return false;
 539     }
 540
 541     AbstractItemPtr item = d->members.at(oldIndex);
 542     d->members.move(oldIndex, newIndex);
 543     //kDebug() << "new index " << d->members.indexOf(item);
 544     emit itemPositionChanged(item);
 545     return true;
 546 }
 547
 548 } // TaskManager namespace
 549
 550 #include "taskgroup.moc"