workspace/plasma/applets/tasks/tasks.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Robert Knight                                   *
   3  *   robertknight@gmail.com                                                *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  19  ***************************************************************************/
  20
  21 // Own
  22 #include "tasks.h"
  23 #include "taskgroupitem.h"
  24 #include "windowtaskitem.h"
  25 #include "ui_tasksConfig.h"
  26
  27 // KDE
  28 #include <KDialog>
  29
  30 // Qt
  31 #include <QGraphicsSceneWheelEvent>
  32 #include <QTimeLine>
  33
  34 // Plasma
  35 #include <plasma/containment.h>
  36 #include <plasma/theme.h>
  37 #include <plasma/layouts/boxlayout.h>
  38 #include <plasma/layouts/layoutanimator.h>
  39
  40 Tasks::Tasks(QObject* parent, const QVariantList &arguments)
  41  : Plasma::Applet(parent, arguments),
  42    m_dialog(0)
  43 {
  44     setHasConfigurationInterface(true);
  45     setAspectRatioMode(Qt::IgnoreAspectRatio);
  46     setContentSize(500, 48);
  47
  48     m_screenTimer.setSingleShot(true);
  49     m_screenTimer.setInterval(300);
  50     connect(&m_screenTimer, SIGNAL(timeout()), this, SLOT(checkScreenChange()));
  51     connect(Plasma::Theme::self(), SIGNAL(changed()), this, SLOT(themeRefresh()));
  52 }
  53
  54 Tasks::~Tasks()
  55 {
  56     delete m_dialog;
  57 }
  58
  59 void Tasks::init()
  60 {
  61     Plasma::BoxLayout *layout = new Plasma::BoxLayout(Plasma::BoxLayout::LeftToRight, this);
  62     layout->setMargin(0);
  63     m_rootTaskGroup = new TaskGroupItem(this, this);
  64     m_rootTaskGroup->resize(contentSize());
  65     connect(m_rootTaskGroup, SIGNAL(activated(AbstractTaskItem*)),
  66             this, SLOT(launchActivated()));
  67
  68     // set up the animator used in the root item
  69     m_animator = new Plasma::LayoutAnimator(this);
  70     m_animator->setAutoDeleteOnRemoval(true);
  71     m_animator->setEffect(Plasma::LayoutAnimator::InsertedState,
  72                           Plasma::LayoutAnimator::FadeEffect);
  73     m_animator->setEffect(Plasma::LayoutAnimator::StandardState,
  74                           Plasma::LayoutAnimator::MoveEffect);
  75     m_animator->setEffect(Plasma::LayoutAnimator::RemovedState,
  76                           Plasma::LayoutAnimator::FadeEffect);
  77     m_animator->setTimeLine(new QTimeLine(100, this));
  78
  79     layout->addItem(m_rootTaskGroup);
  80
  81     m_rootTaskGroup->setBorderStyle(TaskGroupItem::NoBorder);
  82     // m_rootTaskGroup->setColor( QColor(100,120,130) );
  83     m_rootTaskGroup->setText("Root Group");
  84
  85     KConfigGroup cg = config();
  86     m_showTooltip = cg.readEntry("showTooltip", true);
  87     m_showOnlyCurrentDesktop = cg.readEntry("showOnlyCurrentDesktop", false);
  88     m_showOnlyCurrentScreen = cg.readEntry("showOnlyCurrentScreen", false);
  89
  90     reconnect();
  91
  92     // listen for addition and removal of window tasks
  93     connect(TaskManager::TaskManager::self(), SIGNAL(taskAdded(TaskPtr)),
  94             this, SLOT(addWindowTask(TaskPtr)));
  95     connect(TaskManager::TaskManager::self(), SIGNAL(taskRemoved(TaskPtr)),
  96             this, SLOT(removeWindowTask(TaskPtr)));
  97
  98     // listen for addition and removal of starting tasks
  99     connect(TaskManager::TaskManager::self(), SIGNAL(startupAdded(StartupPtr)),
 100             this, SLOT(addStartingTask(StartupPtr)));
 101     connect(TaskManager::TaskManager::self(), SIGNAL(startupRemoved(StartupPtr)),
 102             this, SLOT(removeStartingTask(StartupPtr)));
 103
 104     // add the animator once we're initialized to avoid animating like mad on start up
 105     m_rootTaskGroup->layout()->setAnimator(m_animator);
 106 }
 107
 108 void Tasks::addStartingTask(StartupPtr task)
 109 {
 110     WindowTaskItem* item = new WindowTaskItem(m_rootTaskGroup, m_rootTaskGroup, m_showTooltip);
 111     item->setStartupTask(task);
 112     m_startupTaskItems.insert(task, item);
 113
 114     addItemToRootGroup(item);
 115 }
 116
 117 void Tasks::removeStartingTask(StartupPtr task)
 118 {
 119     if (m_startupTaskItems.contains(task)) {
 120         AbstractTaskItem *item = m_startupTaskItems.take(task);
 121         removeItemFromRootGroup(item);
 122     }
 123 }
 124
 125 void Tasks::registerWindowTasks()
 126 {
 127     TaskManager::TaskManager *manager = TaskManager::TaskManager::self();
 128
 129     TaskManager::TaskDict tasks = manager->tasks();
 130     QMapIterator<WId,TaskPtr> iter(tasks);
 131
 132     while (iter.hasNext()) {
 133         iter.next();
 134         addWindowTask(iter.value());
 135     }
 136 }
 137
 138 void Tasks::addItemToRootGroup(AbstractTaskItem *item)
 139 {
 140     item->setFlag(QGraphicsItem::ItemIsSelectable);
 141     m_rootTaskGroup->insertTask(item);
 142 }
 143
 144 void Tasks::removeItemFromRootGroup(AbstractTaskItem *item)
 145 {
 146     Q_ASSERT( item );
 147
 148     m_rootTaskGroup->removeTask(item);
 149
 150 // TEMPORARY
 151 //      scene()->removeItem(item);
 152 //    item->deleteLater();
 153 }
 154
 155 void Tasks::addWindowTask(TaskPtr task)
 156 {
 157     if (!task->showInTaskbar()) {
 158         return;
 159     }
 160
 161     if (m_showOnlyCurrentDesktop && !task->isOnCurrentDesktop()) {
 162         return;
 163     }
 164     if (m_showOnlyCurrentScreen && !isOnMyScreen(task)) {
 165         return;
 166     }
 167
 168     WindowTaskItem *item = 0;
 169     foreach (StartupPtr startup, m_startupTaskItems.keys()) {
 170         if (startup->matchesWindow(task->window())) {
 171             item = dynamic_cast<WindowTaskItem *>(m_startupTaskItems.take(startup));
 172             break;
 173         }
 174     }
 175
 176     if (!item) {
 177         item = new WindowTaskItem(m_rootTaskGroup, m_rootTaskGroup, m_showTooltip);
 178     }
 179
 180     item->setWindowTask(task);
 181     m_windowTaskItems.insert(task, item);
 182
 183     addItemToRootGroup(item);
 184 }
 185
 186 void Tasks::removeWindowTask(TaskPtr task)
 187 {
 188     if (m_windowTaskItems.contains(task)) {
 189         AbstractTaskItem *item = m_windowTaskItems.take(task);
 190         removeItemFromRootGroup(item);
 191     }
 192 }
 193
 194 void Tasks::removeAllWindowTasks()
 195 {
 196     while (!m_windowTaskItems.isEmpty()) {
 197         removeItemFromRootGroup(m_windowTaskItems.take(m_windowTaskItems.constBegin().key()));
 198     }
 199 }
 200
 201 void Tasks::constraintsUpdated(Plasma::Constraints constraints)
 202 {
 203     if (constraints & Plasma::LocationConstraint) {
 204         if (formFactor() == Plasma::Vertical) {
 205             m_rootTaskGroup->setDirection(Plasma::BoxLayout::TopToBottom);
 206         } else {
 207             m_rootTaskGroup->setDirection(Plasma::BoxLayout::LeftToRight);
 208         }
 209
 210         foreach (AbstractTaskItem *taskItem, m_windowTaskItems) {
 211             WindowTaskItem *windowTaskItem = dynamic_cast<WindowTaskItem *>(taskItem);
 212             if (windowTaskItem) {
 213                 windowTaskItem->publishIconGeometry();
 214             }
 215         }
 216     }
 217 }
 218
 219 void Tasks::wheelEvent(QGraphicsSceneWheelEvent *e)
 220 {
 221      m_rootTaskGroup->cycle(e->delta());
 222 }
 223
 224 void Tasks::currentDesktopChanged(int)
 225 {
 226     if (!m_showOnlyCurrentDesktop) {
 227         return;
 228     }
 229
 230     removeAllWindowTasks();
 231     registerWindowTasks();
 232 }
 233
 234 void Tasks::taskMovedDesktop(TaskPtr task)
 235 {
 236     if (!m_showOnlyCurrentDesktop) {
 237         return;
 238     }
 239
 240     if (!task->isOnCurrentDesktop()) {
 241         removeWindowTask(task);
 242     } else if (!m_windowTaskItems.contains(task)) {
 243         addWindowTask(task);
 244     }
 245 }
 246
 247 void Tasks::windowChangedGeometry(TaskPtr task)
 248 {
 249     if (!m_tasks.contains(task)) {
 250         m_tasks.append(task);
 251     }
 252     if (!m_screenTimer.isActive()) {
 253         m_screenTimer.start();
 254     }
 255 }
 256
 257 void Tasks::checkScreenChange()
 258 {
 259     foreach (TaskPtr task, m_tasks) {
 260         if (!isOnMyScreen(task)) {
 261             removeWindowTask(task);
 262         } else if (!m_windowTaskItems.contains(task)) {
 263             addWindowTask(task);
 264         }
 265     }
 266     m_tasks.clear();
 267 }
 268
 269 bool Tasks::isOnMyScreen(TaskPtr task)
 270 {
 271     Plasma::Containment* appletContainment = containment();
 272
 273     if (appletContainment) {
 274         if (appletContainment->screen() != -1) {
 275             if (!TaskManager::TaskManager::isOnScreen(appletContainment->screen(),
 276                 task->window())) {
 277                 return false;
 278             }
 279         }
 280     }
 281     return true;
 282 }
 283
 284 void Tasks::showConfigurationInterface()
 285 {
 286     if (m_dialog == 0) {
 287         m_dialog = new KDialog;
 288         m_dialog->setCaption(i18n("Configure Taskbar"));
 289
 290         QWidget *widget = new QWidget;
 291         m_ui.setupUi(widget);
 292         m_dialog->setMainWidget(widget);
 293         m_dialog->setButtons(KDialog::Ok | KDialog::Cancel | KDialog::Apply);
 294
 295         connect(m_dialog, SIGNAL(applyClicked()), this, SLOT(configAccepted()));
 296         connect(m_dialog, SIGNAL(okClicked()), this, SLOT(configAccepted()));
 297     }
 298
 299     m_ui.showTooltip->setChecked(m_showTooltip);
 300     m_ui.showOnlyCurrentDesktop->setChecked(m_showOnlyCurrentDesktop);
 301     m_ui.showOnlyCurrentScreen->setChecked(m_showOnlyCurrentScreen);
 302     m_dialog->show();
 303 }
 304
 305 void Tasks::configAccepted()
 306 {
 307     bool changed = false;
 308
 309     if (m_showOnlyCurrentDesktop != (m_ui.showOnlyCurrentDesktop->isChecked())) {
 310         m_showOnlyCurrentDesktop = !m_showOnlyCurrentDesktop;
 311         KConfigGroup cg = config();
 312         cg.writeEntry("showOnlyCurrentDesktop", m_showOnlyCurrentDesktop);
 313         changed = true;
 314     }
 315     if (m_showOnlyCurrentScreen != (m_ui.showOnlyCurrentScreen->isChecked())) {
 316         m_showOnlyCurrentScreen = !m_showOnlyCurrentScreen;
 317         KConfigGroup cg = config();
 318         cg.writeEntry("showOnlyCurrentScreen", m_showOnlyCurrentScreen);
 319         changed = true;
 320     }
 321
 322     if (changed) {
 323         reconnect();
 324     }
 325
 326     if (m_showTooltip != (m_ui.showTooltip->checkState() == Qt::Checked)) {
 327         m_showTooltip = !m_showTooltip;
 328         foreach (AbstractTaskItem *taskItem, m_windowTaskItems) {
 329             WindowTaskItem *windowTaskItem = dynamic_cast<WindowTaskItem *>(taskItem);
 330             if (windowTaskItem) {
 331                 windowTaskItem->setShowTooltip(m_showTooltip);
 332             }
 333         }
 334         KConfigGroup cg = config();
 335         cg.writeEntry("showTooltip", m_showTooltip);
 336         changed = true;
 337     }
 338
 339     if (changed) {
 340         update();
 341         emit configNeedsSaving();
 342     }
 343 }
 344
 345 void Tasks::reconnect()
 346 {
 347     disconnect(TaskManager::TaskManager::self(), SIGNAL(desktopChanged(int)),
 348                this, SLOT(currentDesktopChanged(int)));
 349     disconnect(TaskManager::TaskManager::self(), SIGNAL(windowChanged(TaskPtr)),
 350                this, SLOT(taskMovedDesktop(TaskPtr)));
 351     if (m_showOnlyCurrentDesktop) {
 352         // listen to the relevant task manager signals
 353         connect(TaskManager::TaskManager::self(), SIGNAL(desktopChanged(int)),
 354                 this, SLOT(currentDesktopChanged(int)));
 355         connect(TaskManager::TaskManager::self(), SIGNAL(windowChanged(TaskPtr)),
 356                 this, SLOT(taskMovedDesktop(TaskPtr)));
 357     }
 358
 359     disconnect(TaskManager::TaskManager::self(), SIGNAL(windowChangedGeometry(TaskPtr)),
 360                this, SLOT(windowChangedGeometry(TaskPtr)));
 361     if (m_showOnlyCurrentScreen) {
 362         // listen to the relevant task manager signals
 363         connect(TaskManager::TaskManager::self(), SIGNAL(windowChangedGeometry(TaskPtr)),
 364                 this, SLOT(windowChangedGeometry(TaskPtr)));
 365         TaskManager::TaskManager::self()->trackGeometry();
 366     }
 367
 368     removeAllWindowTasks();
 369     registerWindowTasks();
 370 }
 371
 372 void Tasks::themeRefresh()
 373 {
 374     foreach (AbstractTaskItem *taskItem, m_windowTaskItems) {
 375         taskItem->update();
 376     }
 377
 378 }
 379
 380 #include "tasks.moc"