• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

Plasma

positioningruler.cpp

Go to the documentation of this file.
00001  /*
00002  *   Copyright 2008 Marco Martin <notmart@gmail.com>
00003  *
00004  *   This program is free software; you can redistribute it and/or modify
00005  *   it under the terms of the GNU Library General Public License as
00006  *   published by the Free Software Foundation; either version 2, or
00007  *   (at your option) any later version.
00008  *
00009  *   This program is distributed in the hope that it will be useful,
00010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *   GNU General Public License for more details
00013  *
00014  *   You should have received a copy of the GNU Library General Public
00015  *   License along with this program; if not, write to the
00016  *   Free Software Foundation, Inc.,
00017  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00018  */
00019 
00020 #include "positioningruler.h"
00021 
00022 #include <QPainter>
00023 #include <QBoxLayout>
00024 #include <QMouseEvent>
00025 #include <QToolButton>
00026 #include <QApplication>
00027 #include <QDesktopWidget>
00028 #include <QToolTip>
00029 
00030 #include <KIcon>
00031 #include <KColorUtils>
00032 #include <KWindowSystem>
00033 
00034 #include <plasma/theme.h>
00035 #include <plasma/panelsvg.h>
00036 #include <plasma/containment.h>
00037 
00038 
00039 class PositioningRuler::Private
00040 {
00041 public:
00042     Private()
00043        : location(Plasma::BottomEdge),
00044          alignment(Qt::AlignLeft),
00045          dragging(NoElement),
00046          startDragPos(0,0),
00047          offset(0),
00048          minLength(0),
00049          maxLength(0),
00050          availableLength(0),
00051          leftMaxSliderRect(QRect(0,0,0,0)),
00052          rightMaxSliderRect(QRect(0,0,0,0)),
00053          leftMinSliderRect(QRect(0,0,0,0)),
00054          rightMinSliderRect(QRect(0,0,0,0)),
00055          offsetSliderRect(QRect(0,0,0,0)),
00056          sliderGraphics(0),
00057          elementPrefix(QString())
00058     {
00059     }
00060 
00061     ~Private()
00062     {
00063     }
00064 
00065     bool moveSlider(QRect &sliderRect, QRect &symmetricSliderRect, const QPoint &newPos)
00066     {
00067         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00068             if (newPos.y() < 0 || newPos.y() > availableLength) {
00069                 return false;
00070             }
00071 
00072             if (alignment == Qt::AlignCenter) {
00073                 const int newTop = offsetSliderRect.center().y() + (offsetSliderRect.center().y() - newPos.y());
00074                 if (newTop < 0 || newTop > availableLength) {
00075                     return false;
00076                 }
00077                 symmetricSliderRect.moveCenter(QPoint(symmetricSliderRect.center().x(), newTop));
00078             }
00079             sliderRect.moveCenter(QPoint(sliderRect.center().x(), newPos.y()));
00080         } else {
00081             if (newPos.x() < 0 || newPos.x() > availableLength) {
00082                 return false;
00083             }
00084 
00085             if (alignment == Qt::AlignCenter) {
00086                 const int newLeft = offsetSliderRect.center().x() + (offsetSliderRect.center().x() - newPos.x());
00087                 if (newLeft < 0 || newLeft > availableLength) {
00088                     return false;
00089                 }
00090                 symmetricSliderRect.moveCenter(QPoint(newLeft, symmetricSliderRect.center().y()));
00091             }
00092             sliderRect.moveCenter(QPoint(newPos.x(), sliderRect.center().y()));
00093         }
00094 
00095         return true;
00096     }
00097 
00098     int sliderRectToLength(const QRect &sliderRect)
00099     {
00100         int sliderPos;
00101         int offsetPos;
00102 
00103         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00104             sliderPos = sliderRect.center().y();
00105             offsetPos = offsetSliderRect.center().y();
00106         } else {
00107             sliderPos = sliderRect.center().x();
00108             offsetPos = offsetSliderRect.center().x();
00109         }
00110 
00111         if (alignment == Qt::AlignCenter) {
00112             return 2 * qAbs(sliderPos - offsetPos);
00113         } else {
00114             return qAbs(sliderPos - offsetPos);
00115         }
00116     }
00117 
00118     void loadSlidersGraphics()
00119     {
00120         QString elementPrefix;
00121 
00122         switch (location) {
00123         case Plasma::LeftEdge:
00124             elementPrefix = "west-";
00125             break;
00126         case Plasma::RightEdge:
00127             elementPrefix = "east-";
00128             break;
00129         case Plasma::TopEdge:
00130             elementPrefix = "north-";
00131             break;
00132         case Plasma::BottomEdge:
00133         default:
00134             elementPrefix = "south-";
00135             break;
00136         }
00137 
00138         leftMaxSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "maxslider"));
00139         rightMaxSliderRect.setSize(leftMaxSliderRect.size());
00140         leftMinSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "minslider"));
00141         rightMinSliderRect.setSize(leftMinSliderRect.size());
00142         offsetSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "offsetslider"));
00143     }
00144 
00145     void setupSliders(const QSize &totalSize)
00146     {
00147         //FIXME: the following is waay too clumsy...
00148 
00149         int rightMaxPos;
00150         int leftMaxPos;
00151         int rightMinPos;
00152         int leftMinPos;
00153         int offsetPos;
00154 
00155         int totalLength;
00156         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00157             totalLength = totalSize.height();
00158         } else {
00159             totalLength = totalSize.width();
00160         }
00161 
00162         switch (alignment) {
00163         case Qt::AlignLeft:
00164             //Here substracting one to everything because QRect.moveCenter(pos) moves the rect with
00165             //the width/2 th pixel at pos.x (and so for y) resulting in the painted image moved
00166             //one pixel to the right
00167             rightMaxPos = offset + maxLength - 1;
00168             leftMaxPos = 0;
00169             rightMinPos = offset + minLength - 1;
00170             leftMinPos = 0;
00171             offsetPos = offset - 1;
00172             break;
00173         case Qt::AlignRight:
00174             leftMaxPos = totalLength - offset - maxLength - 1;
00175             rightMaxPos = 0;
00176             leftMinPos = totalLength - offset - minLength - 1;
00177             rightMinPos = 0;
00178             offsetPos = totalLength - offset - 1;
00179             break;
00180         case Qt::AlignCenter:
00181         default:
00182             leftMaxPos = totalLength/2 + offset - maxLength/2 - 1;
00183             rightMaxPos = totalLength/2 + offset + maxLength/2 - 1;
00184 
00185             leftMinPos = totalLength/2 + offset - minLength/2 - 1;
00186             rightMinPos = totalLength/2 + offset + minLength/2 - 1;
00187 
00188             offsetPos = totalLength/2 + offset - 1;
00189             break;
00190         }
00191     
00192         switch (location) {
00193         case Plasma::LeftEdge:
00194             leftMaxSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), leftMaxPos));
00195             rightMaxSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), rightMaxPos));
00196         
00197             leftMinSliderRect.moveCenter(QPoint(totalSize.width()/4, leftMinPos));
00198             rightMinSliderRect.moveCenter(QPoint(totalSize.width()/4, rightMinPos));
00199         
00200             offsetSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), offsetPos));
00201             break;
00202         case Plasma::RightEdge:
00203             leftMaxSliderRect.moveCenter(QPoint(totalSize.width()/4, leftMaxPos));
00204             rightMaxSliderRect.moveCenter(QPoint(totalSize.width()/4, rightMaxPos));
00205         
00206             leftMinSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), leftMinPos));
00207             rightMinSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), rightMinPos));
00208         
00209             offsetSliderRect.moveCenter(QPoint(totalSize.width()/4, offsetPos));
00210             break;
00211         case Plasma::TopEdge:
00212             leftMaxSliderRect.moveCenter(QPoint(leftMaxPos, 3*(totalSize.height()/4)));
00213             rightMaxSliderRect.moveCenter(QPoint(rightMaxPos, 3*(totalSize.height()/4)));
00214         
00215             leftMinSliderRect.moveCenter(QPoint(leftMinPos, totalSize.height()/4));
00216             rightMinSliderRect.moveCenter(QPoint(rightMinPos, totalSize.height()/4));
00217         
00218             offsetSliderRect.moveCenter(QPoint(offsetPos, 3*(totalSize.height()/4)));
00219             break;
00220         case Plasma::BottomEdge:
00221         default:
00222             leftMaxSliderRect.moveCenter(QPoint(leftMaxPos, totalSize.height()/4));
00223             rightMaxSliderRect.moveCenter(QPoint(rightMaxPos, totalSize.height()/4));
00224         
00225             leftMinSliderRect.moveCenter(QPoint(leftMinPos, 3*(totalSize.height()/4)));
00226             rightMinSliderRect.moveCenter(QPoint(rightMinPos, 3*(totalSize.height()/4)));
00227         
00228             offsetSliderRect.moveCenter(QPoint(offsetPos, totalSize.height()/4));
00229             break;
00230         }
00231     }
00232 
00233     enum SubElement { NoElement = 0,
00234                        LeftMaxSlider,
00235                        RightMaxSlider,
00236                        LeftMinSlider,
00237                        RightMinSlider,
00238                        OffsetSlider
00239                      };
00240 
00241     Plasma::Location location;
00242     Qt::Alignment alignment;
00243     SubElement dragging;
00244     QPoint startDragPos;
00245     int offset;
00246     int minLength;
00247     int maxLength;
00248     int availableLength;
00249     QRect leftMaxSliderRect;
00250     QRect rightMaxSliderRect;
00251     QRect leftMinSliderRect;
00252     QRect rightMinSliderRect;
00253     QRect offsetSliderRect;
00254     Plasma::PanelSvg *sliderGraphics;
00255     QString elementPrefix;
00256 };
00257 
00258 PositioningRuler::PositioningRuler(QWidget* parent)
00259    : QWidget(parent),
00260      d(new Private())
00261 {
00262    d->sliderGraphics = new Plasma::PanelSvg(this);
00263    d->sliderGraphics->setImagePath("widgets/containment-controls");
00264 
00265    d->loadSlidersGraphics();
00266 }
00267 
00268 PositioningRuler::~PositioningRuler()
00269 {
00270    delete d;
00271 }
00272 
00273 QSize PositioningRuler::sizeHint() const
00274 {
00275     //FIXME:why must add 6 pixels????
00276     
00277     switch (d->location) {
00278     case Plasma::LeftEdge:
00279     case Plasma::RightEdge:
00280         return QSize(d->leftMaxSliderRect.width() + d->leftMinSliderRect.width() + 6, d->availableLength);
00281         break;
00282     case Plasma::TopEdge:
00283     case Plasma::BottomEdge:
00284     default:
00285         return QSize(d->availableLength, d->leftMaxSliderRect.height() + d->leftMinSliderRect.height() + 6);
00286         break;
00287     }
00288     
00289 }
00290 
00291 void PositioningRuler::setLocation(const Plasma::Location &loc)
00292 {
00293     if (d->location == loc) {
00294         return;
00295     }
00296 
00297     d->location = loc;
00298 
00299     d->setupSliders(size());
00300     d->loadSlidersGraphics();
00301 
00302     update();
00303 }
00304 
00305 Plasma::Location PositioningRuler::location() const
00306 {
00307     return d->location;
00308 }
00309 
00310 void PositioningRuler::setAlignment(const Qt::Alignment &align)
00311 {
00312     if (d->alignment == align) {
00313         return;
00314     }
00315 
00316     d->alignment = align;
00317 
00318     d->setupSliders(size());
00319 
00320     update();
00321 }
00322 
00323 Qt::Alignment PositioningRuler::alignment() const
00324 {
00325     return d->alignment;
00326 }
00327 
00328 void PositioningRuler::setOffset(int newOffset)
00329 {
00330     d->offset = newOffset;
00331 
00332     d->setupSliders(size());
00333 }
00334 
00335 int PositioningRuler::offset() const
00336 {
00337     return d->offset;
00338 }
00339 
00340 void PositioningRuler::setMaxLength(int newMax)
00341 {
00342     int deltaX;
00343     int deltaY;
00344 
00345     switch (d->location) {
00346     case Plasma::LeftEdge:
00347     case Plasma::RightEdge:
00348         deltaX = 0;
00349         deltaY = newMax - d->maxLength;
00350         break;
00351     case Plasma::TopEdge:
00352     case Plasma::BottomEdge:
00353     default:
00354         deltaX = newMax - d->maxLength;
00355         deltaY = 0;
00356         break;
00357     }
00358 
00359     if (d->alignment == Qt::AlignLeft) {
00360         d->rightMaxSliderRect.moveCenter(QPoint(d->rightMaxSliderRect.center().x() + deltaX,
00361                                          d->rightMaxSliderRect.center().y() + deltaY));
00362     } else if (d->alignment == Qt::AlignRight) {
00363         d->leftMaxSliderRect.moveCenter(QPoint(d->leftMaxSliderRect.center().x() - deltaX,
00364                                         d->leftMaxSliderRect.center().y() - deltaY));
00365     //center
00366     } else {
00367         d->rightMaxSliderRect.moveCenter(QPoint(d->rightMaxSliderRect.center().x() + deltaX/2,
00368                                          d->rightMaxSliderRect.center().y() + deltaY/2));
00369         d->leftMaxSliderRect.moveCenter(QPoint(d->leftMaxSliderRect.center().x() - deltaX/2,
00370                                         d->leftMaxSliderRect.center().y() - deltaY/2));
00371     }
00372 
00373     d->maxLength = newMax;
00374     if (d->minLength > d->maxLength) {
00375         setMinLength(newMax);
00376     }
00377 }
00378 
00379 int PositioningRuler::maxLength() const
00380 {
00381     return d->maxLength;
00382 }
00383 
00384 void PositioningRuler::setMinLength(int newMin)
00385 {
00386     int deltaX;
00387     int deltaY;
00388 
00389     switch (d->location) {
00390     case Plasma::LeftEdge:
00391     case Plasma::RightEdge:
00392         deltaX = 0;
00393         deltaY = newMin - d->minLength;
00394         break;
00395     case Plasma::TopEdge:
00396     case Plasma::BottomEdge:
00397     default:
00398         deltaX = newMin - d->minLength;
00399         deltaY = 0;
00400         break;
00401     }
00402 
00403 
00404     if (d->alignment == Qt::AlignLeft) {
00405         d->rightMinSliderRect.moveCenter(QPoint(d->rightMinSliderRect.center().x() + deltaX,
00406                                          d->rightMinSliderRect.center().y() + deltaY));
00407     } else if (d->alignment == Qt::AlignRight) {
00408         d->leftMinSliderRect.moveCenter(QPoint(d->leftMinSliderRect.center().x() - deltaX,
00409                                         d->leftMinSliderRect.center().y() - deltaY));
00410     //center
00411     } else {
00412         d->rightMinSliderRect.moveCenter(QPoint(d->rightMinSliderRect.center().x() + deltaX/2,
00413                                          d->rightMinSliderRect.center().y() + deltaY/2));
00414         d->leftMinSliderRect.moveCenter(QPoint(d->leftMinSliderRect.center().x() - deltaX/2,
00415                                         d->leftMinSliderRect.center().y() - deltaY/2));
00416     }
00417 
00418     d->minLength = newMin;
00419     if (d->minLength > d->minLength) {
00420         setMaxLength(newMin);
00421     }
00422 }
00423 
00424 int PositioningRuler::minLength() const
00425 {
00426     return d->minLength;
00427 }
00428 
00429 void PositioningRuler::setAvailableLength(int newAvail)
00430 {
00431     d->availableLength = newAvail;
00432     
00433     if (d->maxLength > newAvail) {
00434         setMaxLength(newAvail);
00435     }
00436 
00437     if (d->minLength > newAvail) {
00438         setMinLength(newAvail);
00439     }
00440 }
00441 
00442 int PositioningRuler::availableLength() const
00443 {
00444     return d->availableLength;
00445 }
00446 
00447 bool PositioningRuler::event(QEvent *ev)
00448 {
00449     //Show a different tooltip on each slider
00450     if (ev->type() == QEvent::ToolTip) {
00451         QHelpEvent *helpEvent = static_cast<QHelpEvent *>(ev);
00452         if (d->offsetSliderRect.contains(helpEvent->pos())) {
00453             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the panel position"), this);
00454         } else if ((d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.contains(helpEvent->pos())) ||
00455                    (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.contains(helpEvent->pos()))) {
00456             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the maximum panel size"), this);
00457         } else if ((d->alignment != Qt::AlignLeft && d->leftMinSliderRect.contains(helpEvent->pos())) ||
00458                    (d->alignment != Qt::AlignRight && d->rightMinSliderRect.contains(helpEvent->pos()))) {
00459             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the minimum panel size"), this);
00460         }
00461 
00462         return true;
00463     } else {
00464         return QWidget::event(ev);
00465     }
00466 }
00467 
00468 void PositioningRuler::paintEvent(QPaintEvent *event)
00469 {
00470     //Draw background
00471     d->sliderGraphics->setElementPrefix(d->location);
00472 
00473     QPainter painter(this);
00474     painter.setCompositionMode(QPainter::CompositionMode_Source);
00475 
00476     d->sliderGraphics->resizePanel(event->rect().size());
00477     d->sliderGraphics->paintPanel(&painter, event->rect());
00478     painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
00479 
00480     //Draw center indicators
00481     if (d->alignment == Qt::AlignCenter && (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge)) {
00482         d->sliderGraphics->paint(&painter, QPoint(event->rect().left(), event->rect().center().y()), "vertical-centerindicator");
00483     } else if (d->alignment == Qt::AlignCenter) {
00484         d->sliderGraphics->paint(&painter, QPoint(event->rect().center().x(), event->rect().top()), "horizontal-centerindicator");
00485     }
00486 
00487     //Draw handles
00488     QString elementPrefix;
00489 
00490     switch (d->location) {
00491     case Plasma::LeftEdge:
00492         elementPrefix = "west-";
00493         break;
00494     case Plasma::RightEdge:
00495         elementPrefix = "east-";
00496         break;
00497     case Plasma::TopEdge:
00498         elementPrefix = "north-";
00499         break;
00500     case Plasma::BottomEdge:
00501     default:
00502         elementPrefix = "south-";
00503         break;
00504     }
00505 
00506     if (d->alignment != Qt::AlignLeft) {
00507         d->sliderGraphics->paint(&painter, d->leftMaxSliderRect, elementPrefix + "maxslider");
00508         d->sliderGraphics->paint(&painter, d->leftMinSliderRect, elementPrefix + "minslider");
00509     }
00510 
00511     if (d->alignment != Qt::AlignRight) {
00512         d->sliderGraphics->paint(&painter, d->rightMaxSliderRect, elementPrefix + "maxslider");
00513         d->sliderGraphics->paint(&painter, d->rightMinSliderRect, elementPrefix + "minslider");
00514     }
00515 
00516     d->sliderGraphics->paint(&painter, d->offsetSliderRect, elementPrefix + "offsetslider");
00517 }
00518 
00519 void PositioningRuler::wheelEvent(QWheelEvent *event)
00520 {
00521     QPoint movement;
00522     int hMargins = 0;
00523     int vMargins = 0;
00524 
00525     if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00526         vMargins = 200;
00527         if (event->delta() < 0) {
00528             movement = QPoint(0, 20);
00529         } else {
00530             movement = QPoint(0, -20);
00531         }
00532     } else {
00533         hMargins = 100;
00534         if (event->delta() < 0) {
00535             movement = QPoint(20, 0);
00536         } else {
00537             movement = QPoint(-20, 0);
00538         }
00539     }
00540 
00541     if (d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00542         d->dragging = Private::LeftMaxSlider;
00543         movement += d->leftMaxSliderRect.center();
00544     } else if (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00545         d->dragging = Private::RightMaxSlider;
00546         movement += d->rightMaxSliderRect.center();
00547     } else if (d->alignment != Qt::AlignLeft && d->leftMinSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00548         d->dragging = Private::LeftMinSlider;
00549         movement += d->leftMinSliderRect.center();
00550     } else if (d->alignment != Qt::AlignRight && d->rightMinSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00551         d->dragging = Private::RightMinSlider;
00552         movement += d->rightMinSliderRect.center();
00553     } else if (d->offsetSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00554         d->dragging = Private::OffsetSlider;
00555         movement += d->offsetSliderRect.center();
00556     } else {
00557         d->dragging = Private::NoElement;
00558     }
00559 
00560     //do a fake mouse move event that drags the slider around
00561     if (d->dragging != Private::NoElement) {
00562         d->startDragPos = QPoint(0,0);
00563         QMouseEvent mouseEvent(QEvent::MouseMove, movement, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
00564         mouseMoveEvent(&mouseEvent);
00565         d->dragging = Private::NoElement;
00566     }
00567 }
00568 
00569 void PositioningRuler::mousePressEvent(QMouseEvent *event)
00570 {
00571     if (d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.contains(event->pos())) {
00572         d->dragging = Private::LeftMaxSlider;
00573         d->startDragPos = QPoint(event->pos().x() - d->leftMaxSliderRect.center().x(), event->pos().y() - d->leftMaxSliderRect.center().y());
00574     } else if (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.contains(event->pos())) {
00575         d->dragging = Private::RightMaxSlider;
00576         d->startDragPos = QPoint(event->pos().x() - d->rightMaxSliderRect.center().x(), event->pos().y() - d->rightMaxSliderRect.center().y());
00577     } else if (d->alignment != Qt::AlignLeft && d->leftMinSliderRect.contains(event->pos())) {
00578         d->dragging = Private::LeftMinSlider;
00579         d->startDragPos = QPoint(event->pos().x() - d->leftMinSliderRect.center().x(), event->pos().y() - d->leftMinSliderRect.center().y());
00580     } else if (d->alignment != Qt::AlignRight && d->rightMinSliderRect.contains(event->pos())) {
00581         d->dragging = Private::RightMinSlider;
00582         d->startDragPos = QPoint(event->pos().x() - d->rightMinSliderRect.center().x(), event->pos().y() - d->rightMinSliderRect.center().y());
00583     } else if (d->offsetSliderRect.contains(event->pos())) {
00584         d->dragging = Private::OffsetSlider;
00585         d->startDragPos = QPoint(event->pos().x() - d->offsetSliderRect.center().x(), event->pos().y() - d->offsetSliderRect.center().y());
00586     } else {
00587         d->dragging = Private::NoElement;
00588     }
00589 
00590     QWidget::mousePressEvent(event);
00591 }
00592 
00593 void PositioningRuler::mouseReleaseEvent(QMouseEvent *event)
00594 {
00595     Q_UNUSED(event)
00596 
00597     d->startDragPos = QPoint(0, 0);
00598     d->dragging = Private::NoElement;
00599 }
00600 
00601 void PositioningRuler::mouseMoveEvent(QMouseEvent *event)
00602 {
00603     if (d->dragging == Private::NoElement) {
00604         return;
00605     }
00606 
00607     //bound to width, height
00608     QPoint newPos = QPoint(qMin(event->pos().x() - d->startDragPos.x(), width()),
00609                            qMin(event->pos().y() - d->startDragPos.y(), height()));
00610     //bound to 0,0
00611     newPos = QPoint(qMax(newPos.x(), 0), qMax(newPos.y(), 0));
00612 
00613 
00614     const bool horizontal = (d->location == Plasma::TopEdge || d->location == Plasma::BottomEdge);
00615     const int widthBound = 20;
00616     const int snapSize = 5;
00617 
00618     //Snap
00619     if (horizontal) {
00620         if (newPos.x() <= snapSize) {
00621             newPos.setX(0);
00622         } else if (qAbs(newPos.x() - d->availableLength/2) <= snapSize) {
00623             newPos.setX(d->availableLength/2);
00624         } else if (d->availableLength - newPos.x() <= snapSize) {
00625             newPos.setX(d->availableLength);
00626         }
00627     } else {
00628         if (newPos.y() <= snapSize) {
00629             newPos.setY(0);
00630         } else if (qAbs(newPos.y() - d->availableLength/2) <= snapSize) {
00631             newPos.setY(d->availableLength/2);
00632         } else if (d->availableLength - newPos.y() <= snapSize) {
00633             newPos.setY(d->availableLength);
00634         }
00635     }
00636     
00637     switch (d->dragging) {
00638     case Private::LeftMaxSlider:
00639         //don't let the slider "cross" with the offset slider
00640         if (horizontal && newPos.x() > d->offsetSliderRect.left() - widthBound) {
00641             return;
00642         } else if (!horizontal && newPos.y() > d->offsetSliderRect.top() - widthBound) {
00643             return;
00644         }
00645 
00646         if (!d->moveSlider(d->leftMaxSliderRect, d->rightMaxSliderRect, newPos)) {
00647             return;
00648         }
00649 
00650         d->maxLength = d->sliderRectToLength(d->leftMaxSliderRect);
00651 
00652         if (d->minLength > d->maxLength) {
00653             d->moveSlider(d->leftMinSliderRect, d->rightMinSliderRect, newPos);
00654             d->minLength = d->maxLength;
00655         }
00656         break;
00657     case Private::RightMaxSlider:
00658         if (horizontal && newPos.x() < d->offsetSliderRect.left() + widthBound) {
00659             return;
00660         } else if (!horizontal && newPos.y() < d->offsetSliderRect.top() + widthBound) {
00661             return;
00662         }
00663 
00664         if (!d->moveSlider(d->rightMaxSliderRect, d->leftMaxSliderRect, newPos)) {
00665             return;
00666         }
00667 
00668         d->maxLength = d->sliderRectToLength(d->rightMaxSliderRect);
00669 
00670         if (d->minLength > d->maxLength) {
00671             d->moveSlider(d->rightMinSliderRect, d->leftMinSliderRect, newPos);
00672             d->minLength = d->maxLength;
00673         }
00674         break;
00675     case Private::LeftMinSlider:
00676         if (horizontal && newPos.x() > d->offsetSliderRect.left() - widthBound) {
00677             return;
00678         } else if (!horizontal && newPos.y() > d->offsetSliderRect.top() - widthBound) {
00679             return;
00680         }
00681 
00682         if (!d->moveSlider(d->leftMinSliderRect, d->rightMinSliderRect, newPos)) {
00683             return;
00684         }
00685 
00686         d->minLength = d->sliderRectToLength(d->leftMinSliderRect);
00687 
00688         if (d->minLength > d->maxLength) {
00689             d->moveSlider(d->leftMaxSliderRect, d->rightMaxSliderRect, newPos);
00690             d->maxLength = d->minLength;
00691         }
00692         break;
00693     case Private::RightMinSlider:
00694         if (horizontal && newPos.x() < d->offsetSliderRect.left() + widthBound) {
00695             return;
00696         } else if (!horizontal && newPos.y() < d->offsetSliderRect.top() + widthBound) {
00697             return;
00698         }
00699 
00700         if (!d->moveSlider(d->rightMinSliderRect, d->leftMinSliderRect, newPos)) {
00701             return;
00702         }
00703 
00704         d->minLength = d->sliderRectToLength(d->rightMinSliderRect);
00705 
00706         if (d->minLength > d->maxLength) {
00707             d->moveSlider(d->rightMaxSliderRect, d->leftMaxSliderRect, newPos);
00708             d->maxLength = d->minLength;
00709         }
00710         break;
00711     case Private::OffsetSlider:
00712     {
00713         if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00714             d->offsetSliderRect.moveCenter(QPoint(d->offsetSliderRect.center().x(), newPos.y()));
00715             d->offset = d->offsetSliderRect.center().y();
00716         } else {
00717             d->offsetSliderRect.moveCenter(QPoint(newPos.x(), d->offsetSliderRect.center().y()));
00718             d->offset = d->offsetSliderRect.center().x();
00719         }
00720 
00721         if (d->alignment == Qt::AlignCenter) {
00722             d->offset -= d->availableLength/2;
00723         } else if (d->alignment == Qt::AlignRight) {
00724             d->offset = d->availableLength - d->offset;
00725         }
00726 
00727         int centerFactor = 1;
00728         if (d->alignment == Qt::AlignCenter) {
00729             centerFactor = 2;
00730         }
00731 
00732         d->maxLength = centerFactor*qMin(d->maxLength/centerFactor, d->availableLength/centerFactor - qAbs(d->offset));
00733         d->minLength = centerFactor*qMin(d->minLength/centerFactor, d->availableLength/centerFactor - qAbs(d->offset));
00734 
00735         if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00736              d->leftMaxSliderRect.moveTop(d->offsetSliderRect.top() - d->maxLength/centerFactor);
00737              d->leftMinSliderRect.moveTop(d->offsetSliderRect.top() - d->minLength/centerFactor);
00738              d->rightMaxSliderRect.moveTop(d->offsetSliderRect.top() + d->maxLength/centerFactor);
00739              d->rightMinSliderRect.moveTop(d->offsetSliderRect.top() + d->minLength/centerFactor);
00740         } else {
00741              d->leftMaxSliderRect.moveLeft(d->offsetSliderRect.left() - d->maxLength/centerFactor);
00742              d->leftMinSliderRect.moveLeft(d->offsetSliderRect.left() - d->minLength/centerFactor);
00743              d->rightMaxSliderRect.moveLeft(d->offsetSliderRect.left() + d->maxLength/centerFactor);
00744              d->rightMinSliderRect.moveLeft(d->offsetSliderRect.left() + d->minLength/centerFactor);
00745         }
00746 
00747         break;
00748     }
00749     default:
00750         break;
00751     }
00752 
00753     emit rulersMoved(d->offset, d->minLength, d->maxLength);
00754     update();
00755 }
00756 
00757 void PositioningRuler::resizeEvent(QResizeEvent *event)
00758 {
00759     switch (d->location) {
00760     case Plasma::LeftEdge:
00761     case Plasma::RightEdge:
00762         setAvailableLength(event->size().height());
00763         break;
00764     default:
00765         setAvailableLength(event->size().width());
00766         break;
00767     }
00768 
00769     d->setupSliders(event->size());
00770 
00771     event->accept();
00772 }
00773 
00774 #include "positioningruler.moc"

Plasma

Skip menu "Plasma"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members

API Reference

Skip menu "API Reference"
  • KWin
  •   KWin Libraries
  • Libraries
  •   libkworkspace
  •   libplasma
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal