00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
00164
00165
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
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
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
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
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
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
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
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
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
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
00635 QPoint newPos = QPoint(qMin(event->pos().x() - d->startDragPos.x(), width()),
00636 qMin(event->pos().y() - d->startDragPos.y(), height()));
00637
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
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
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"