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.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
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
00165
00166
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
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
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
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
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
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
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
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
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
00608 QPoint newPos = QPoint(qMin(event->pos().x() - d->startDragPos.x(), width()),
00609 qMin(event->pos().y() - d->startDragPos.y(), height()));
00610
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
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
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"