• Skip to content
  • Skip to link menu
KDE 4.2 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>
00035 #include <Plasma/FrameSvg>
00036 #include <Plasma/Containment>
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          minimumBound(40)
00059     {
00060     }
00061 
00062     ~Private()
00063     {
00064     }
00065 
00066     bool moveSlider(QRect &sliderRect, QRect &symmetricSliderRect, const QPoint &newPos)
00067     {
00068         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00069             if (newPos.y() < 0 || newPos.y() > availableLength) {
00070                 return false;
00071             }
00072 
00073             if (alignment == Qt::AlignCenter) {
00074                 int newTop = offsetSliderRect.center().y() + (offsetSliderRect.center().y() - newPos.y());
00075                 newTop = qBound(0, newTop, availableLength);
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                 int newLeft = offsetSliderRect.center().x() + (offsetSliderRect.center().x() - newPos.x());
00087                 newLeft = qBound(0, newLeft, availableLength);
00088 
00089                 symmetricSliderRect.moveCenter(QPoint(newLeft, symmetricSliderRect.center().y()));
00090             }
00091             sliderRect.moveCenter(QPoint(newPos.x(), sliderRect.center().y()));
00092         }
00093 
00094         return true;
00095     }
00096 
00097     int sliderRectToLength(const QRect &sliderRect)
00098     {
00099         int sliderPos;
00100         int offsetPos;
00101 
00102         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00103             sliderPos = sliderRect.center().y();
00104             offsetPos = offsetSliderRect.center().y();
00105         } else {
00106             sliderPos = sliderRect.center().x();
00107             offsetPos = offsetSliderRect.center().x();
00108         }
00109 
00110         if (alignment == Qt::AlignCenter) {
00111             return 2 * qAbs(sliderPos - offsetPos);
00112         } else {
00113             return qAbs(sliderPos - offsetPos);
00114         }
00115     }
00116 
00117     void loadSlidersGraphics()
00118     {
00119         QString elementPrefix;
00120 
00121         switch (location) {
00122         case Plasma::LeftEdge:
00123             elementPrefix = "west-";
00124             break;
00125         case Plasma::RightEdge:
00126             elementPrefix = "east-";
00127             break;
00128         case Plasma::TopEdge:
00129             elementPrefix = "north-";
00130             break;
00131         case Plasma::BottomEdge:
00132         default:
00133             elementPrefix = "south-";
00134             break;
00135         }
00136 
00137         leftMaxSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "maxslider"));
00138         leftMinSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "minslider"));
00139         rightMaxSliderRect.setSize(leftMinSliderRect.size());
00140         rightMinSliderRect.setSize(leftMaxSliderRect.size());
00141         offsetSliderRect.setSize(sliderGraphics->elementSize(elementPrefix + "offsetslider"));
00142     }
00143 
00144     void setupSliders(const QSize &totalSize)
00145     {
00146         //FIXME: the following is waay too clumsy...
00147 
00148         int rightMaxPos;
00149         int leftMaxPos;
00150         int rightMinPos;
00151         int leftMinPos;
00152         int offsetPos;
00153 
00154         int totalLength;
00155         if (location == Plasma::LeftEdge || location == Plasma::RightEdge) {
00156             totalLength = totalSize.height();
00157         } else {
00158             totalLength = totalSize.width();
00159         }
00160 
00161         switch (alignment) {
00162         case Qt::AlignLeft:
00163             // Here subtracting one to everything because QRect.moveCenter(pos) moves the rect with
00164             // the width/2 th pixel at pos.x (and so for y) resulting in the painted image moved
00165             // one pixel to the right
00166             rightMaxPos = offset + maxLength;
00167             leftMaxPos = 0;
00168             rightMinPos = offset + minLength;
00169             leftMinPos = 0;
00170             offsetPos = offset;
00171             break;
00172         case Qt::AlignRight:
00173             leftMaxPos = totalLength - offset - maxLength;
00174             rightMaxPos = 0;
00175             leftMinPos = totalLength - offset - minLength;
00176             rightMinPos = 0;
00177             offsetPos = totalLength - offset;
00178             break;
00179         case Qt::AlignCenter:
00180         default:
00181             leftMaxPos = totalLength/2 + offset - maxLength/2;
00182             rightMaxPos = totalLength/2 + offset + maxLength/2;
00183 
00184             leftMinPos = totalLength/2 + offset - minLength/2;
00185             rightMinPos = totalLength/2 + offset + minLength/2;
00186 
00187             offsetPos = totalLength/2 + offset;
00188             break;
00189         }
00190 
00191         switch (location) {
00192         case Plasma::LeftEdge:
00193             leftMaxSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), leftMaxPos));
00194             rightMaxSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), rightMaxPos));
00195 
00196             leftMinSliderRect.moveCenter(QPoint(totalSize.width()/4, leftMinPos));
00197             rightMinSliderRect.moveCenter(QPoint(totalSize.width()/4, rightMinPos));
00198 
00199             offsetSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), offsetPos));
00200             break;
00201         case Plasma::RightEdge:
00202             leftMaxSliderRect.moveCenter(QPoint(totalSize.width()/4, leftMaxPos));
00203             rightMaxSliderRect.moveCenter(QPoint(totalSize.width()/4, rightMaxPos));
00204 
00205             leftMinSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), leftMinPos));
00206             rightMinSliderRect.moveCenter(QPoint(3*(totalSize.width()/4), rightMinPos));
00207 
00208             offsetSliderRect.moveCenter(QPoint(totalSize.width()/4, offsetPos));
00209             break;
00210         case Plasma::TopEdge:
00211             leftMaxSliderRect.moveCenter(QPoint(leftMaxPos, 3*(totalSize.height()/4)));
00212             rightMaxSliderRect.moveCenter(QPoint(rightMaxPos, 3*(totalSize.height()/4)));
00213 
00214             leftMinSliderRect.moveCenter(QPoint(leftMinPos, totalSize.height()/4));
00215             rightMinSliderRect.moveCenter(QPoint(rightMinPos, totalSize.height()/4));
00216 
00217             offsetSliderRect.moveCenter(QPoint(offsetPos, 3*(totalSize.height()/4)));
00218             break;
00219         case Plasma::BottomEdge:
00220         default:
00221             leftMaxSliderRect.moveCenter(QPoint(leftMaxPos, totalSize.height()/4));
00222             rightMaxSliderRect.moveCenter(QPoint(rightMaxPos, totalSize.height()/4));
00223 
00224             leftMinSliderRect.moveCenter(QPoint(leftMinPos, 3*(totalSize.height()/4)));
00225             rightMinSliderRect.moveCenter(QPoint(rightMinPos, 3*(totalSize.height()/4)));
00226 
00227             offsetSliderRect.moveCenter(QPoint(offsetPos, totalSize.height()/4));
00228             break;
00229         }
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::FrameSvg *sliderGraphics;
00255     QString elementPrefix;
00256 
00257     int minimumBound;
00258 };
00259 
00260 PositioningRuler::PositioningRuler(QWidget* parent)
00261    : QWidget(parent),
00262      d(new Private())
00263 {
00264    d->sliderGraphics = new Plasma::FrameSvg(this);
00265    d->sliderGraphics->setImagePath("widgets/containment-controls");
00266 
00267    d->loadSlidersGraphics();
00268 }
00269 
00270 PositioningRuler::~PositioningRuler()
00271 {
00272    delete d;
00273 }
00274 
00275 QSize PositioningRuler::sizeHint() const
00276 {
00277     //FIXME:why must add 6 pixels????
00278 
00279     switch (d->location) {
00280     case Plasma::LeftEdge:
00281     case Plasma::RightEdge:
00282         return QSize(d->leftMaxSliderRect.width() + d->leftMinSliderRect.width() + 6, d->availableLength);
00283         break;
00284     case Plasma::TopEdge:
00285     case Plasma::BottomEdge:
00286     default:
00287         return QSize(d->availableLength, d->leftMaxSliderRect.height() + d->leftMinSliderRect.height() + 6);
00288         break;
00289     }
00290 
00291 }
00292 
00293 void PositioningRuler::setLocation(const Plasma::Location &loc)
00294 {
00295     if (d->location == loc) {
00296         return;
00297     }
00298 
00299     d->location = loc;
00300 
00301     d->setupSliders(size());
00302     d->loadSlidersGraphics();
00303 
00304     update();
00305 }
00306 
00307 Plasma::Location PositioningRuler::location() const
00308 {
00309     return d->location;
00310 }
00311 
00312 void PositioningRuler::setAlignment(const Qt::Alignment &align)
00313 {
00314     if (d->alignment == align) {
00315         return;
00316     }
00317 
00318     d->alignment = align;
00319 
00320     d->setupSliders(size());
00321 
00322     update();
00323 }
00324 
00325 Qt::Alignment PositioningRuler::alignment() const
00326 {
00327     return d->alignment;
00328 }
00329 
00330 void PositioningRuler::setOffset(int newOffset)
00331 {
00332     d->offset = newOffset;
00333 
00334     d->setupSliders(size());
00335     update();
00336 }
00337 
00338 int PositioningRuler::offset() const
00339 {
00340     return d->offset;
00341 }
00342 
00343 void PositioningRuler::setMaxLength(int newMax)
00344 {
00345     int deltaX;
00346     int deltaY;
00347 
00348     switch (d->location) {
00349     case Plasma::LeftEdge:
00350     case Plasma::RightEdge:
00351         deltaX = 0;
00352         deltaY = newMax - d->maxLength;
00353         break;
00354     case Plasma::TopEdge:
00355     case Plasma::BottomEdge:
00356     default:
00357         deltaX = newMax - d->maxLength;
00358         deltaY = 0;
00359         break;
00360     }
00361 
00362     if (d->alignment == Qt::AlignLeft) {
00363         d->rightMaxSliderRect.moveCenter(QPoint(d->rightMaxSliderRect.center().x() + deltaX,
00364                                          d->rightMaxSliderRect.center().y() + deltaY));
00365     } else if (d->alignment == Qt::AlignRight) {
00366         d->leftMaxSliderRect.moveCenter(QPoint(d->leftMaxSliderRect.center().x() - deltaX,
00367                                         d->leftMaxSliderRect.center().y() - deltaY));
00368     //center
00369     } else {
00370         d->rightMaxSliderRect.moveCenter(QPoint(d->rightMaxSliderRect.center().x() + deltaX/2,
00371                                          d->rightMaxSliderRect.center().y() + deltaY/2));
00372         d->leftMaxSliderRect.moveCenter(QPoint(d->leftMaxSliderRect.center().x() - deltaX/2,
00373                                         d->leftMaxSliderRect.center().y() - deltaY/2));
00374     }
00375 
00376     d->maxLength = newMax;
00377     if (d->minLength > d->maxLength) {
00378         setMinLength(newMax);
00379     }
00380     update();
00381 }
00382 
00383 int PositioningRuler::maxLength() const
00384 {
00385     return d->maxLength;
00386 }
00387 
00388 void PositioningRuler::setMinLength(int newMin)
00389 {
00390     int deltaX;
00391     int deltaY;
00392 
00393     int min = qMax(d->minimumBound, newMin);
00394 
00395     switch (d->location) {
00396     case Plasma::LeftEdge:
00397     case Plasma::RightEdge:
00398         deltaX = 0;
00399         deltaY = min - d->minLength;
00400         break;
00401     case Plasma::TopEdge:
00402     case Plasma::BottomEdge:
00403     default:
00404         deltaX = min - d->minLength;
00405         deltaY = 0;
00406         break;
00407     }
00408 
00409 
00410     if (d->alignment == Qt::AlignLeft) {
00411         d->rightMinSliderRect.moveCenter(QPoint(d->rightMinSliderRect.center().x() + deltaX,
00412                                          d->rightMinSliderRect.center().y() + deltaY));
00413     } else if (d->alignment == Qt::AlignRight) {
00414         d->leftMinSliderRect.moveCenter(QPoint(d->leftMinSliderRect.center().x() - deltaX,
00415                                         d->leftMinSliderRect.center().y() - deltaY));
00416     //center
00417     } else {
00418         d->rightMinSliderRect.moveCenter(QPoint(d->rightMinSliderRect.center().x() + deltaX/2,
00419                                          d->rightMinSliderRect.center().y() + deltaY/2));
00420         d->leftMinSliderRect.moveCenter(QPoint(d->leftMinSliderRect.center().x() - deltaX/2,
00421                                         d->leftMinSliderRect.center().y() - deltaY/2));
00422     }
00423 
00424     d->minLength = min;
00425     if (d->minLength > d->maxLength) {
00426         setMaxLength(min);
00427     }
00428     update();
00429 }
00430 
00431 int PositioningRuler::minLength() const
00432 {
00433     return d->minLength;
00434 }
00435 
00436 void PositioningRuler::setAvailableLength(int newAvail)
00437 {
00438     d->availableLength = newAvail;
00439 
00440     if (d->maxLength > newAvail) {
00441         setMaxLength(newAvail);
00442     }
00443 
00444     if (d->minLength > newAvail) {
00445         setMinLength(newAvail);
00446     }
00447 }
00448 
00449 int PositioningRuler::availableLength() const
00450 {
00451     return d->availableLength;
00452 }
00453 
00454 bool PositioningRuler::event(QEvent *ev)
00455 {
00456     //Show a different tooltip on each slider
00457     if (ev->type() == QEvent::ToolTip) {
00458         QHelpEvent *helpEvent = static_cast<QHelpEvent *>(ev);
00459         if (d->offsetSliderRect.contains(helpEvent->pos())) {
00460             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the panel position"), this);
00461         } else if ((d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.contains(helpEvent->pos())) ||
00462                    (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.contains(helpEvent->pos()))) {
00463             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the maximum panel size"), this);
00464         } else if ((d->alignment != Qt::AlignLeft && d->leftMinSliderRect.contains(helpEvent->pos())) ||
00465                    (d->alignment != Qt::AlignRight && d->rightMinSliderRect.contains(helpEvent->pos()))) {
00466             QToolTip::showText(helpEvent->globalPos(), i18n("Move this slider to set the minimum panel size"), this);
00467         }
00468 
00469         return true;
00470     } else {
00471         return QWidget::event(ev);
00472     }
00473 }
00474 
00475 void PositioningRuler::paintEvent(QPaintEvent *event)
00476 {
00477     //Draw background
00478     d->sliderGraphics->setElementPrefix(d->location);
00479 
00480     QPainter painter(this);
00481 
00482     d->sliderGraphics->resizeFrame(event->rect().size());
00483     d->sliderGraphics->paintFrame(&painter);
00484 
00485     //Draw center indicators
00486     if (d->alignment == Qt::AlignCenter && (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge)) {
00487         QSize indicatorSize = d->sliderGraphics->elementSize("vertical-centerindicator");
00488         d->sliderGraphics->paint(&painter, QRect(QPoint(event->rect().left(), event->rect().center().y()), indicatorSize), "vertical-centerindicator");
00489         //this because rect.moveCenter will cause a rect moved one pixel off respect where we need it
00490         painter.translate(0, -1);
00491     } else if (d->alignment == Qt::AlignCenter) {
00492         QSize indicatorSize = d->sliderGraphics->elementSize("horizontal-centerindicator");
00493         d->sliderGraphics->paint(&painter, QRect(QPoint(event->rect().center().x(), event->rect().top()), indicatorSize), "horizontal-centerindicator");
00494         painter.translate(-1, 0);
00495     }
00496 
00497     //Draw handles
00498     QString elementPrefix;
00499 
00500     switch (d->location) {
00501     case Plasma::LeftEdge:
00502         elementPrefix = "west-";
00503         break;
00504     case Plasma::RightEdge:
00505         elementPrefix = "east-";
00506         break;
00507     case Plasma::TopEdge:
00508         elementPrefix = "north-";
00509         break;
00510     case Plasma::BottomEdge:
00511     default:
00512         elementPrefix = "south-";
00513         break;
00514     }
00515 
00516     if (d->alignment != Qt::AlignLeft) {
00517         painter.save();
00518         QTransform transform;
00519 
00520         switch (d->location) {
00521         case Plasma::LeftEdge:
00522         case Plasma::RightEdge:
00523             transform.scale(1, -1);
00524             break;
00525         case Plasma::TopEdge:
00526         case Plasma::BottomEdge:
00527         default:
00528             transform.scale(-1, 1);
00529             break;
00530         }
00531 
00532         painter.setTransform(transform);
00533         d->sliderGraphics->paint(&painter, transform.mapRect(d->leftMaxSliderRect), elementPrefix + "maxslider");
00534         d->sliderGraphics->paint(&painter, transform.mapRect(d->leftMinSliderRect), elementPrefix + "minslider");
00535         painter.restore();
00536     }
00537 
00538     if (d->alignment != Qt::AlignRight) {
00539         d->sliderGraphics->paint(&painter, d->rightMaxSliderRect, elementPrefix + "maxslider");
00540         d->sliderGraphics->paint(&painter, d->rightMinSliderRect, elementPrefix + "minslider");
00541     }
00542 
00543     d->sliderGraphics->paint(&painter, d->offsetSliderRect, elementPrefix + "offsetslider");
00544 }
00545 
00546 void PositioningRuler::wheelEvent(QWheelEvent *event)
00547 {
00548     QPoint movement;
00549     int hMargins = 0;
00550     int vMargins = 0;
00551 
00552     if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00553         vMargins = 200;
00554         if (event->delta() < 0) {
00555             movement = QPoint(0, 20);
00556         } else {
00557             movement = QPoint(0, -20);
00558         }
00559     } else {
00560         hMargins = 100;
00561         if (event->delta() < 0) {
00562             movement = QPoint(20, 0);
00563         } else {
00564             movement = QPoint(-20, 0);
00565         }
00566     }
00567 
00568     if (d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00569         d->dragging = Private::LeftMaxSlider;
00570         movement += d->leftMaxSliderRect.center();
00571     } else if (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00572         d->dragging = Private::RightMaxSlider;
00573         movement += d->rightMaxSliderRect.center();
00574     } else if (d->alignment != Qt::AlignLeft && d->leftMinSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00575         d->dragging = Private::LeftMinSlider;
00576         movement += d->leftMinSliderRect.center();
00577     } else if (d->alignment != Qt::AlignRight && d->rightMinSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00578         d->dragging = Private::RightMinSlider;
00579         movement += d->rightMinSliderRect.center();
00580     } else if (d->offsetSliderRect.adjusted(-hMargins, -vMargins, hMargins, vMargins).contains(event->pos())) {
00581         d->dragging = Private::OffsetSlider;
00582         movement += d->offsetSliderRect.center();
00583     } else {
00584         d->dragging = Private::NoElement;
00585     }
00586 
00587     //do a fake mouse move event that drags the slider around
00588     if (d->dragging != Private::NoElement) {
00589         d->startDragPos = QPoint(0,0);
00590         QMouseEvent mouseEvent(QEvent::MouseMove, movement, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
00591         mouseMoveEvent(&mouseEvent);
00592         d->dragging = Private::NoElement;
00593     }
00594 }
00595 
00596 void PositioningRuler::mousePressEvent(QMouseEvent *event)
00597 {
00598     if (d->alignment != Qt::AlignLeft && d->leftMaxSliderRect.contains(event->pos())) {
00599         d->dragging = Private::LeftMaxSlider;
00600         d->startDragPos = QPoint(event->pos().x() - d->leftMaxSliderRect.center().x(), event->pos().y() - d->leftMaxSliderRect.center().y());
00601     } else if (d->alignment != Qt::AlignRight && d->rightMaxSliderRect.contains(event->pos())) {
00602         d->dragging = Private::RightMaxSlider;
00603         d->startDragPos = QPoint(event->pos().x() - d->rightMaxSliderRect.center().x(), event->pos().y() - d->rightMaxSliderRect.center().y());
00604     } else if (d->alignment != Qt::AlignLeft && d->leftMinSliderRect.contains(event->pos())) {
00605         d->dragging = Private::LeftMinSlider;
00606         d->startDragPos = QPoint(event->pos().x() - d->leftMinSliderRect.center().x(), event->pos().y() - d->leftMinSliderRect.center().y());
00607     } else if (d->alignment != Qt::AlignRight && d->rightMinSliderRect.contains(event->pos())) {
00608         d->dragging = Private::RightMinSlider;
00609         d->startDragPos = QPoint(event->pos().x() - d->rightMinSliderRect.center().x(), event->pos().y() - d->rightMinSliderRect.center().y());
00610     } else if (d->offsetSliderRect.contains(event->pos())) {
00611         d->dragging = Private::OffsetSlider;
00612         d->startDragPos = QPoint(event->pos().x() - d->offsetSliderRect.center().x(), event->pos().y() - d->offsetSliderRect.center().y());
00613     } else {
00614         d->dragging = Private::NoElement;
00615     }
00616 
00617     QWidget::mousePressEvent(event);
00618 }
00619 
00620 void PositioningRuler::mouseReleaseEvent(QMouseEvent *event)
00621 {
00622     Q_UNUSED(event)
00623 
00624     d->startDragPos = QPoint(0, 0);
00625     d->dragging = Private::NoElement;
00626 }
00627 
00628 void PositioningRuler::mouseMoveEvent(QMouseEvent *event)
00629 {
00630     if (d->dragging == Private::NoElement) {
00631         return;
00632     }
00633 
00634     //bound to width, height
00635     QPoint newPos = QPoint(qMin(event->pos().x() - d->startDragPos.x(), width()),
00636                            qMin(event->pos().y() - d->startDragPos.y(), height()));
00637     //bound to 0,0
00638     newPos = QPoint(qMax(newPos.x(), 0), qMax(newPos.y(), 0));
00639 
00640 
00641     const bool horizontal = (d->location == Plasma::TopEdge || d->location == Plasma::BottomEdge);
00642     const int widthBound = d->minimumBound;
00643     const int snapSize = 5;
00644 
00645     //Snap
00646     if (horizontal) {
00647         if (newPos.x() <= snapSize) {
00648             newPos.setX(0);
00649         } else if (qAbs(newPos.x() - d->availableLength/2) <= snapSize) {
00650             newPos.setX(d->availableLength/2);
00651         } else if (d->availableLength - newPos.x() <= snapSize) {
00652             newPos.setX(d->availableLength);
00653         }
00654     } else {
00655         if (newPos.y() <= snapSize) {
00656             newPos.setY(0);
00657         } else if (qAbs(newPos.y() - d->availableLength/2) <= snapSize) {
00658             newPos.setY(d->availableLength/2);
00659         } else if (d->availableLength - newPos.y() <= snapSize) {
00660             newPos.setY(d->availableLength);
00661         }
00662     }
00663 
00664     switch (d->dragging) {
00665     case Private::LeftMaxSlider:
00666         //don't let the slider "cross" with the offset slider
00667         if (horizontal && newPos.x() > d->offsetSliderRect.left() - widthBound) {
00668             return;
00669         } else if (!horizontal && newPos.y() > d->offsetSliderRect.top() - widthBound) {
00670             return;
00671         }
00672 
00673         if (!d->moveSlider(d->leftMaxSliderRect, d->rightMaxSliderRect, newPos)) {
00674             return;
00675         }
00676 
00677         d->maxLength = d->sliderRectToLength(d->leftMaxSliderRect);
00678 
00679         if (d->minLength > d->maxLength) {
00680             d->moveSlider(d->leftMinSliderRect, d->rightMinSliderRect, newPos);
00681             d->minLength = d->maxLength;
00682         }
00683         break;
00684     case Private::RightMaxSlider:
00685         if (horizontal && newPos.x() < d->offsetSliderRect.left() + widthBound) {
00686             return;
00687         } else if (!horizontal && newPos.y() < d->offsetSliderRect.top() + widthBound) {
00688             return;
00689         }
00690 
00691         if (!d->moveSlider(d->rightMaxSliderRect, d->leftMaxSliderRect, newPos)) {
00692             return;
00693         }
00694 
00695         d->maxLength = d->sliderRectToLength(d->rightMaxSliderRect);
00696 
00697         if (d->minLength > d->maxLength) {
00698             d->moveSlider(d->rightMinSliderRect, d->leftMinSliderRect, newPos);
00699             d->minLength = d->maxLength;
00700         }
00701         break;
00702     case Private::LeftMinSlider:
00703         if (horizontal && newPos.x() > d->offsetSliderRect.left() - widthBound) {
00704             return;
00705         } else if (!horizontal && newPos.y() > d->offsetSliderRect.top() - widthBound) {
00706             return;
00707         }
00708 
00709         if (!d->moveSlider(d->leftMinSliderRect, d->rightMinSliderRect, newPos)) {
00710             return;
00711         }
00712 
00713         d->minLength = d->sliderRectToLength(d->leftMinSliderRect);
00714 
00715         if (d->minLength > d->maxLength) {
00716             d->moveSlider(d->leftMaxSliderRect, d->rightMaxSliderRect, newPos);
00717             d->maxLength = d->minLength;
00718         }
00719         break;
00720     case Private::RightMinSlider:
00721         if (horizontal && newPos.x() < d->offsetSliderRect.left() + widthBound) {
00722             return;
00723         } else if (!horizontal && newPos.y() < d->offsetSliderRect.top() + widthBound) {
00724             return;
00725         }
00726 
00727         if (!d->moveSlider(d->rightMinSliderRect, d->leftMinSliderRect, newPos)) {
00728             return;
00729         }
00730 
00731         d->minLength = d->sliderRectToLength(d->rightMinSliderRect);
00732 
00733         if (d->minLength > d->maxLength) {
00734             d->moveSlider(d->rightMaxSliderRect, d->leftMaxSliderRect, newPos);
00735             d->maxLength = d->minLength;
00736         }
00737         break;
00738     case Private::OffsetSlider:
00739     {
00740         if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00741             d->offsetSliderRect.moveCenter(QPoint(d->offsetSliderRect.center().x(), newPos.y()));
00742             d->offset = d->offsetSliderRect.center().y();
00743         } else {
00744             d->offsetSliderRect.moveCenter(QPoint(newPos.x(), d->offsetSliderRect.center().y()));
00745             d->offset = d->offsetSliderRect.center().x();
00746         }
00747 
00748         if (d->alignment == Qt::AlignCenter) {
00749             d->offset -= d->availableLength/2;
00750         } else if (d->alignment == Qt::AlignRight) {
00751             d->offset = d->availableLength - d->offset;
00752         }
00753 
00754         int centerFactor = 1;
00755         if (d->alignment == Qt::AlignCenter) {
00756             centerFactor = 2;
00757         }
00758 
00759         d->maxLength = centerFactor*qMin(d->maxLength/centerFactor, d->availableLength/centerFactor - qAbs(d->offset));
00760         d->minLength = centerFactor*qMin(d->minLength/centerFactor, d->availableLength/centerFactor - qAbs(d->offset));
00761 
00762         if (d->location == Plasma::LeftEdge || d->location == Plasma::RightEdge) {
00763              d->leftMaxSliderRect.moveTop(d->offsetSliderRect.top() - d->maxLength/centerFactor);
00764              d->leftMinSliderRect.moveTop(d->offsetSliderRect.top() - d->minLength/centerFactor);
00765              d->rightMaxSliderRect.moveTop(d->offsetSliderRect.top() + d->maxLength/centerFactor);
00766              d->rightMinSliderRect.moveTop(d->offsetSliderRect.top() + d->minLength/centerFactor);
00767         } else {
00768              d->leftMaxSliderRect.moveLeft(d->offsetSliderRect.left() - d->maxLength/centerFactor);
00769              d->leftMinSliderRect.moveLeft(d->offsetSliderRect.left() - d->minLength/centerFactor);
00770              d->rightMaxSliderRect.moveLeft(d->offsetSliderRect.left() + d->maxLength/centerFactor);
00771              d->rightMinSliderRect.moveLeft(d->offsetSliderRect.left() + d->minLength/centerFactor);
00772         }
00773 
00774         break;
00775     }
00776     default:
00777         break;
00778     }
00779 
00780     emit rulersMoved(d->offset, d->minLength, d->maxLength);
00781     update();
00782 }
00783 
00784 void PositioningRuler::resizeEvent(QResizeEvent *event)
00785 {
00786     switch (d->location) {
00787     case Plasma::LeftEdge:
00788     case Plasma::RightEdge:
00789         setAvailableLength(event->size().height());
00790         break;
00791     default:
00792         setAvailableLength(event->size().width());
00793         break;
00794     }
00795 
00796     d->setupSliders(event->size());
00797 
00798     event->accept();
00799 }
00800 
00801 #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
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.7
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