workspace/plasma/containments/desktop/desktoplayout.cpp

   1 /*
   2   Copyright (c) 2008 Ambroz Bizjak <ambro@b4ever.net>
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8 */
   9
  10 #include <limits>
  11
  12 #include <QCoreApplication>
  13 #include <QGraphicsWidget>
  14 #include <QGraphicsProxyWidget>
  15 #include <QWaitCondition>
  16
  17 #include <KDebug>
  18
  19 #include <Plasma/Animator>
  20
  21 #include "desktoplayout.h"
  22
  23 DesktopLayout::DesktopLayout(QGraphicsLayoutItem *parent)
  24       : QObject(0),
  25         QGraphicsLayout(parent),
  26         autoWorkingArea(true),
  27         temporaryPlacement(false),
  28         visibilityTolerance(0),
  29         m_activated(false)
  30 {
  31     connect(Plasma::Animator::self(), SIGNAL(movementFinished(QGraphicsItem*)),
  32             this, SLOT(movementFinished(QGraphicsItem*)));
  33 }
  34
  35 void DesktopLayout::addItem(QGraphicsLayoutItem *item, bool pushBack, const QRectF &preferredGeom, const QRectF &lastGeom)
  36 {
  37     int key = newItemKey();
  38
  39     ItemSpace::ItemSpaceItem spaceItem;
  40     spaceItem.pushBack = pushBack;
  41     spaceItem.animateMovement = false;
  42     spaceItem.preferredGeometry = preferredGeom;
  43     spaceItem.lastGeometry = (lastGeom.isValid() ? lastGeom : preferredGeom);
  44     spaceItem.user = QVariant(key);
  45
  46     DesktopLayoutItem desktopItem;
  47     desktopItem.item = item;
  48     desktopItem.temporaryGeometry = QRectF(0, 0, -1, -1);
  49
  50     itemSpace.addItem(spaceItem);
  51     items.insert(key, desktopItem);
  52
  53     invalidate();
  54 }
  55
  56 void DesktopLayout::addItem(QGraphicsLayoutItem *item, bool pushBack, const QSizeF &size)
  57 {
  58     QSizeF itemSize = ( size.isValid() ? size : item->effectiveSizeHint(Qt::PreferredSize) );
  59
  60     // get possible positions
  61     QList<QPointF> possiblePositions = itemSpace.positionVertically(itemSize, itemSpace.spaceAlignment, false, true);
  62     //kDebug() << "possiblePositions" << possiblePositions;
  63
  64     // prefer free positions
  65     QRectF bestGeometry = QRectF();
  66     foreach (const QPointF &position, possiblePositions) {
  67         QRectF geom = QRectF(position, itemSize);
  68         if (itemSpace.positionedProperly(geom)) {
  69             bestGeometry = geom;
  70             break;
  71         }
  72     }
  73
  74     if (!bestGeometry.isValid()) {
  75         // choose the position that with the best resulting visibility
  76         QPointF bestPosition = QPointF();
  77         qreal bestVisibility = 0;
  78         foreach (const QPointF &position, possiblePositions) {
  79             // see how much the item can be pushed into the working area:
  80             // copy our ItemSpace, add the item to the copy, activate it
  81             // and check the resulting position's visibility
  82
  83             ItemSpace tempItemSpace(itemSpace);
  84
  85             ItemSpace::ItemSpaceItem spaceItem;
  86             spaceItem.pushBack = pushBack;
  87             spaceItem.animateMovement = false;
  88             spaceItem.preferredGeometry = QRectF(position, itemSize);
  89             spaceItem.lastGeometry = QRectF(position, itemSize);
  90             spaceItem.user = QVariant(-1);
  91
  92             tempItemSpace.addItem(spaceItem);
  93             tempItemSpace.activate();
  94             int tempGroup, tempItem;
  95             tempItemSpace.locateItemByUser(QVariant(-1), &tempGroup, &tempItem);
  96
  97             QRectF resultingGeom = tempItemSpace.m_groups[tempGroup].m_groupItems[tempItem].lastGeometry;
  98             qreal visibility = tempItemSpace.positionVisibility(resultingGeom);
  99
 100             //kDebug() << "Trying " << position << " visibility " << visibility;
 101
 102             if (visibility > bestVisibility) {
 103                 bestPosition = position;
 104                 bestVisibility = visibility;
 105                 if (visibility >= 1) {
 106                     break;
 107                 }
 108             }
 109         }
 110
 111         if (bestVisibility < (1.0-visibilityTolerance)) {
 112             bestPosition = QPointF(itemSpace.screenSpacing, itemSpace.screenSpacing);
 113         }
 114
 115         bestGeometry = QRectF(bestPosition, itemSize);
 116     }
 117
 118     addItem(item, pushBack, bestGeometry);
 119     kDebug() << "Positioned item to" << bestGeometry;
 120 }
 121
 122 bool DesktopLayout::getPushBack(int index)
 123 {
 124     int group;
 125     int item;
 126     itemSpace.locateItemByPosition(index, &group, &item);
 127
 128     return itemSpace.m_groups[group].m_groupItems[item].pushBack;
 129 }
 130
 131 QRectF DesktopLayout::getPreferredGeometry(int index)
 132 {
 133     int group;
 134     int item;
 135     itemSpace.locateItemByPosition(index, &group, &item);
 136
 137     return itemSpace.m_groups[group].m_groupItems[item].preferredGeometry;
 138 }
 139
 140 QRectF DesktopLayout::getLastGeometry(int index)
 141 {
 142     int group;
 143     int item;
 144     itemSpace.locateItemByPosition(index, &group, &item);
 145
 146     return itemSpace.m_groups[group].m_groupItems[item].lastGeometry;
 147 }
 148
 149 void DesktopLayout::setPlacementSpacing(qreal spacing)
 150 {
 151     itemSpace.placementSpacing = spacing;
 152 }
 153
 154 void DesktopLayout::setScreenSpacing(qreal spacing)
 155 {
 156     itemSpace.screenSpacing = spacing;
 157     invalidate();
 158 }
 159
 160 void DesktopLayout::setShiftingSpacing(qreal spacing)
 161 {
 162     itemSpace.shiftingSpacing = spacing;
 163     // NOTE: not wise to call that during operation yet
 164 }
 165
 166 void DesktopLayout::setVisibilityTolerance(qreal part)
 167 {
 168     visibilityTolerance = part;
 169     invalidate();
 170 }
 171
 172 void DesktopLayout::setWorkingArea(QRectF area)
 173 {
 174     // itemSpace positions are relative to working area start,
 175     // adjust them to correspond to the same on-screen positions
 176     itemSpace.offsetPositions(workingStart - area.topLeft());
 177     itemSpace.setWorkingArea(area.size());
 178     workingStart = area.topLeft();
 179     invalidate();
 180 }
 181
 182 void DesktopLayout::setAlignment(Qt::Alignment alignment)
 183 {
 184     itemSpace.spaceAlignment = alignment;
 185     invalidate();
 186 }
 187
 188 void DesktopLayout::setTemporaryPlacement(bool enabled)
 189 {
 190     temporaryPlacement = enabled;
 191     invalidate();
 192 }
 193
 194 void DesktopLayout::setAutoWorkingArea (bool value)
 195 {
 196     autoWorkingArea = value;
 197 }
 198
 199 int DesktopLayout::count () const
 200 {
 201     return items.size();
 202 }
 203
 204 QGraphicsLayoutItem *DesktopLayout::itemAt (int i) const
 205 {
 206     int group = -2, item = -2;
 207     itemSpace.locateItemByPosition(i, &group, &item);
 208     int itemKey = itemSpace.m_groups[group].m_groupItems[item].user.toInt();
 209
 210     return items[itemKey].item;
 211 }
 212
 213 void DesktopLayout::removeAt (int i)
 214 {
 215     int group, item;
 216     itemSpace.locateItemByPosition(i, &group, &item);
 217     int itemKey = itemSpace.m_groups[group].m_groupItems[item].user.toInt();
 218
 219     // remove from ItemSpace
 220     itemSpace.removeItem(group, item);
 221     // remove from local list
 222     items.remove(itemKey);
 223
 224     invalidate();
 225 }
 226
 227 void DesktopLayout::performTemporaryPlacement(int group, int itemInGroup)
 228 {
 229     ItemSpace::ItemSpaceItem &spaceItem = itemSpace.m_groups[group].m_groupItems[itemInGroup];
 230     DesktopLayoutItem &item = items[spaceItem.user.toInt()];
 231
 232     QRectF origGeom = spaceItem.lastGeometry;
 233     spaceItem.lastGeometry = QRectF();
 234
 235     QPointF newPos = QPointF(0, 0);
 236     QList<QPointF> possiblePositions = itemSpace.positionVertically(origGeom.size(), itemSpace.spaceAlignment, true, false);
 237     if (possiblePositions.count() > 0) {
 238         newPos = possiblePositions[0];
 239     }
 240
 241     spaceItem.lastGeometry = origGeom;
 242     item.temporaryGeometry = QRectF(newPos, origGeom.size());
 243     item.item->setGeometry(item.temporaryGeometry.translated(workingStart));
 244 }
 245
 246 void DesktopLayout::revertTemporaryPlacement(int group, int itemInGroup)
 247 {
 248     ItemSpace::ItemSpaceItem &spaceItem = itemSpace.m_groups[group].m_groupItems[itemInGroup];
 249     DesktopLayoutItem &item = items[spaceItem.user.toInt()];
 250
 251     item.temporaryGeometry = QRectF();
 252     item.item->setGeometry(spaceItem.lastGeometry.translated(workingStart));
 253 }
 254
 255 // update anything that needs updating
 256 void DesktopLayout::setGeometry(const QRectF &rect)
 257 {
 258     m_activated = true;
 259     QGraphicsLayout::setGeometry(rect);
 260
 261     if (autoWorkingArea || !itemSpace.workingGeom.isValid()) {
 262         setWorkingArea(rect);
 263     }
 264
 265     // activate the ItemSpace to perform motion as needed
 266     itemSpace.activate();
 267
 268     for (int groupId = 0; groupId < itemSpace.m_groups.size(); groupId++) {
 269         ItemSpace::ItemGroup &group = itemSpace.m_groups[groupId];
 270
 271         for (int itemId = 0; itemId < group.m_groupItems.size(); itemId++) {
 272             ItemSpace::ItemSpaceItem &spaceItem = group.m_groupItems[itemId];
 273             DesktopLayoutItem &desktopItem = items[spaceItem.user.toInt()];
 274
 275             //  Temporarily place the item if it could not be pushed inside the working area.
 276             //  Put it back if it fits again.
 277             if (itemSpace.positionVisibility(spaceItem.lastGeometry) < visibilityTolerance) {
 278                 performTemporaryPlacement(groupId, itemId);
 279             } else if (desktopItem.temporaryGeometry.isValid()) {
 280                 revertTemporaryPlacement(groupId, itemId);
 281             }
 282
 283             // Reset the absolute position if needed
 284             QRectF visibleGeom = (desktopItem.temporaryGeometry.isValid() ? desktopItem.temporaryGeometry : spaceItem.lastGeometry);
 285             QRectF absoluteGeom = visibleGeom.translated(workingStart);
 286             if (desktopItem.item->geometry() != absoluteGeom) {
 287                 QGraphicsWidget *w = dynamic_cast<QGraphicsWidget*>(desktopItem.item);
 288                 if (w && spaceItem.animateMovement)  {
 289                     Plasma::Animator *anim = Plasma::Animator::self();
 290                     bool animating = m_animatingItems.contains(w);
 291                     if (animating) {
 292                         anim->stopItemMovement(m_animatingItems.value(w));
 293                     }
 294                     int id = Plasma::Animator::self()->moveItem(w, Plasma::Animator::FastSlideInMovement,
 295                                                                 absoluteGeom.topLeft().toPoint());
 296                     if (id > 0) {
 297                         m_animatingItems.insert(w, id);
 298                     } else if (animating) {
 299                         m_animatingItems.remove(w);
 300                     }
 301
 302                     spaceItem.animateMovement = false;
 303                 } else {
 304                     desktopItem.item->setGeometry(absoluteGeom);
 305                 }
 306             }
 307         }
 308     }
 309     m_activated = false;
 310 }
 311
 312 // This should be called when the geometry of an item has been changed.
 313 // If the change was made by the user, the new position is used as the preferred position.
 314 void DesktopLayout::itemGeometryChanged(QGraphicsLayoutItem *layoutItem)
 315 {
 316     if (m_activated || m_animatingItems.contains(dynamic_cast<QGraphicsWidget*>(layoutItem))) {
 317         return;
 318     }
 319
 320     // get local item key
 321     int itemKey = -1;
 322     QMapIterator<int, DesktopLayoutItem> i(items);
 323     while (i.hasNext()) {
 324         i.next();
 325         if (i.value().item == layoutItem) {
 326             itemKey = i.key();
 327             break;
 328         }
 329     }
 330     if (itemKey == -1) {
 331         return;
 332     }
 333
 334     // locate item
 335     int group, item;
 336     itemSpace.locateItemByUser(itemKey, &group, &item);
 337     ItemSpace::ItemSpaceItem &spaceItem = itemSpace.m_groups[group].m_groupItems[item];
 338
 339     QRectF currentRelative = layoutItem->geometry().translated(-workingStart);
 340     if (spaceItem.lastGeometry != currentRelative) {
 341         spaceItem.lastGeometry = currentRelative;
 342         spaceItem.preferredGeometry = currentRelative;
 343
 344         itemSpace.updateItem(group, item);
 345         invalidate();
 346     }
 347 }
 348
 349 QSizeF DesktopLayout::sizeHint (Qt::SizeHint which, const QSizeF &constraint) const
 350 {
 351     Q_UNUSED(which)
 352     Q_UNUSED(constraint)
 353     return QSizeF();
 354 }
 355
 356 void DesktopLayout::movementFinished(QGraphicsItem* item)
 357 {
 358     if (m_animatingItems.contains(item)) {
 359         m_animatingItems.remove(item);
 360     }
 361 }
 362
 363 int DesktopLayout::newItemKey()
 364 {
 365     int from = -1;
 366     QList<int> usedKeys = items.keys();
 367     foreach (int key, usedKeys) {
 368         if (key - from > 1) {
 369             break;
 370         }
 371         from = key;
 372     }
 373     return from+1;
 374 }
 375
 376 #include <desktoplayout.moc>