• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kde-runtime API Reference
  • KDE Home
  • Contact Us
 

PlasmaComponents

  • sources
  • kde-4.14
  • kde-runtime
  • plasma
  • declarativeimports
  • plasmacomponents
qrangemodel.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the Qt Components project.
8 **
9 ** $QT_BEGIN_LICENSE:BSD$
10 ** You may use this file under the terms of the BSD license as follows:
11 **
12 ** "Redistribution and use in source and binary forms, with or without
13 ** modification, are permitted provided that the following conditions are
14 ** met:
15 ** * Redistributions of source code must retain the above copyright
16 ** notice, this list of conditions and the following disclaimer.
17 ** * Redistributions in binary form must reproduce the above copyright
18 ** notice, this list of conditions and the following disclaimer in
19 ** the documentation and/or other materials provided with the
20 ** distribution.
21 ** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
22 ** the names of its contributors may be used to endorse or promote
23 ** products derived from this software without specific prior written
24 ** permission.
25 **
26 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
37 ** $QT_END_LICENSE$
38 **
39 ****************************************************************************/
40 
58 #ifndef QT_NO_ACCESSIBILITY
59 #include <QAccessible>
60 #endif
61 
62 #include <QDebug>
63 
64 #include "qrangemodel.h"
65 #include "qrangemodel_p.h"
66 
67 namespace Plasma
68 {
69 
70 QRangeModelPrivate::QRangeModelPrivate(QRangeModel *qq)
71  : q_ptr(qq)
72 {
73 }
74 
75 QRangeModelPrivate::~QRangeModelPrivate()
76 {
77 }
78 
79 void QRangeModelPrivate::init()
80 {
81  minimum = 0;
82  maximum = 99;
83  stepSize = 0;
84  value = 0;
85  pos = 0;
86  posatmin = 0;
87  posatmax = 0;
88  inverted = false;
89 }
90 
98 qreal QRangeModelPrivate::publicPosition(qreal position) const
99 {
100  // Calculate the equivalent stepSize for the position property.
101  const qreal min = effectivePosAtMin();
102  const qreal max = effectivePosAtMax();
103  const qreal valueRange = maximum - minimum;
104  const qreal positionValueRatio = valueRange ? (max - min) / valueRange : 0;
105  const qreal positionStep = stepSize * positionValueRatio;
106 
107  if (positionStep == 0)
108  return (min < max) ? qBound(min, position, max) : qBound(max, position, min);
109 
110  const int stepSizeMultiplier = (position - min) / positionStep;
111 
112  // Test whether value is below minimum range
113  if (stepSizeMultiplier < 0)
114  return min;
115 
116  qreal leftEdge = (stepSizeMultiplier * positionStep) + min;
117  qreal rightEdge = ((stepSizeMultiplier + 1) * positionStep) + min;
118 
119  if (min < max) {
120  leftEdge = qMin(leftEdge, max);
121  rightEdge = qMin(rightEdge, max);
122  } else {
123  leftEdge = qMax(leftEdge, max);
124  rightEdge = qMax(rightEdge, max);
125  }
126 
127  if (qAbs(leftEdge - position) <= qAbs(rightEdge - position))
128  return leftEdge;
129  return rightEdge;
130 }
131 
139 qreal QRangeModelPrivate::publicValue(qreal value) const
140 {
141  // It is important to do value-within-range check this
142  // late (as opposed to during setPosition()). The reason is
143  // QML bindings; a position that is initially invalid because it lays
144  // outside the range, might become valid later if the range changes.
145 
146  if (stepSize == 0)
147  return qBound(minimum, value, maximum);
148 
149  const int stepSizeMultiplier = (value - minimum) / stepSize;
150 
151  // Test whether value is below minimum range
152  if (stepSizeMultiplier < 0)
153  return minimum;
154 
155  const qreal leftEdge = qMin(maximum, (stepSizeMultiplier * stepSize) + minimum);
156  const qreal rightEdge = qMin(maximum, ((stepSizeMultiplier + 1) * stepSize) + minimum);
157  const qreal middle = (leftEdge + rightEdge) / 2;
158 
159  return (value <= middle) ? leftEdge : rightEdge;
160 }
161 
167 void QRangeModelPrivate::emitValueAndPositionIfChanged(const qreal oldValue, const qreal oldPosition)
168 {
169  Q_Q(QRangeModel);
170 
171  // Effective value and position might have changed even in cases when e.g. d->value is
172  // unchanged. This will be the case when operating with values outside range:
173  const qreal newValue = q->value();
174  const qreal newPosition = q->position();
175  if (!qFuzzyCompare(newValue, oldValue))
176  emit q->valueChanged(newValue);
177  if (!qFuzzyCompare(newPosition, oldPosition))
178  emit q->positionChanged(newPosition);
179 }
180 
185 QRangeModel::QRangeModel(QObject *parent)
186  : QObject(parent), d_ptr(new QRangeModelPrivate(this))
187 {
188  Q_D(QRangeModel);
189  d->init();
190 }
191 
197 QRangeModel::QRangeModel(QRangeModelPrivate &dd, QObject *parent)
198  : QObject(parent), d_ptr(&dd)
199 {
200  Q_D(QRangeModel);
201  d->init();
202 }
203 
208 QRangeModel::~QRangeModel()
209 {
210  delete d_ptr;
211  d_ptr = 0;
212 }
213 
220 void QRangeModel::setPositionRange(qreal min, qreal max)
221 {
222  Q_D(QRangeModel);
223 
224  bool emitPosAtMinChanged = !qFuzzyCompare(min, d->posatmin);
225  bool emitPosAtMaxChanged = !qFuzzyCompare(max, d->posatmax);
226 
227  if (!(emitPosAtMinChanged || emitPosAtMaxChanged))
228  return;
229 
230  const qreal oldPosition = position();
231  d->posatmin = min;
232  d->posatmax = max;
233 
234  // When a new positionRange is defined, the position property must be updated based on the value property.
235  // For instance, imagine that you have a valueRange of [0,100] and a position range of [20,100],
236  // if a user set the value to 50, the position would be 60. If this positionRange is updated to [0,100], then
237  // the new position, based on the value (50), will be 50.
238  // If the newPosition is different than the old one, it must be updated, in order to emit
239  // the positionChanged signal.
240  d->pos = d->equivalentPosition(d->value);
241 
242  if (emitPosAtMinChanged)
243  emit positionAtMinimumChanged(d->posatmin);
244  if (emitPosAtMaxChanged)
245  emit positionAtMaximumChanged(d->posatmax);
246 
247  d->emitValueAndPositionIfChanged(value(), oldPosition);
248 }
255 void QRangeModel::setRange(qreal min, qreal max)
256 {
257  Q_D(QRangeModel);
258 
259  bool emitMinimumChanged = !qFuzzyCompare(min, d->minimum);
260  bool emitMaximumChanged = !qFuzzyCompare(max, d->maximum);
261 
262  if (!(emitMinimumChanged || emitMaximumChanged))
263  return;
264 
265  const qreal oldValue = value();
266  const qreal oldPosition = position();
267 
268  d->minimum = min;
269  d->maximum = qMax(min, max);
270 
271  // Update internal position if it was changed. It can occurs if internal value changes, due to range update
272  d->pos = d->equivalentPosition(d->value);
273 
274  if (emitMinimumChanged)
275  emit minimumChanged(d->minimum);
276  if (emitMaximumChanged)
277  emit maximumChanged(d->maximum);
278 
279  d->emitValueAndPositionIfChanged(oldValue, oldPosition);
280 }
281 
289 void QRangeModel::setMinimum(qreal min)
290 {
291  Q_D(const QRangeModel);
292  setRange(min, d->maximum);
293 }
294 
295 qreal QRangeModel::minimum() const
296 {
297  Q_D(const QRangeModel);
298  return d->minimum;
299 }
300 
308 void QRangeModel::setMaximum(qreal max)
309 {
310  Q_D(const QRangeModel);
311  // if the new maximum value is smaller than
312  // minimum, update minimum too
313  setRange(qMin(d->minimum, max), max);
314 }
315 
316 qreal QRangeModel::maximum() const
317 {
318  Q_D(const QRangeModel);
319  return d->maximum;
320 }
321 
330 void QRangeModel::setStepSize(qreal stepSize)
331 {
332  Q_D(QRangeModel);
333 
334  stepSize = qMax(qreal(0.0), stepSize);
335  if (qFuzzyCompare(stepSize, d->stepSize))
336  return;
337 
338  const qreal oldValue = value();
339  const qreal oldPosition = position();
340  d->stepSize = stepSize;
341 
342  emit stepSizeChanged(d->stepSize);
343  d->emitValueAndPositionIfChanged(oldValue, oldPosition);
344 }
345 
346 qreal QRangeModel::stepSize() const
347 {
348  Q_D(const QRangeModel);
349  return d->stepSize;
350 }
351 
358 qreal QRangeModel::positionForValue(qreal value) const
359 {
360  Q_D(const QRangeModel);
361 
362  const qreal unconstrainedPosition = d->equivalentPosition(value);
363  return d->publicPosition(unconstrainedPosition);
364 }
365 
376 qreal QRangeModel::position() const
377 {
378  Q_D(const QRangeModel);
379 
380  // Return the internal position but observe boundaries and
381  // stepSize restrictions.
382  return d->publicPosition(d->pos);
383 }
384 
385 void QRangeModel::setPosition(qreal newPosition)
386 {
387  Q_D(QRangeModel);
388 
389  if (qFuzzyCompare(newPosition, d->pos))
390  return;
391 
392  const qreal oldPosition = position();
393  const qreal oldValue = value();
394 
395  // Update position and calculate new value
396  d->pos = newPosition;
397  d->value = d->equivalentValue(d->pos);
398  d->emitValueAndPositionIfChanged(oldValue, oldPosition);
399 }
400 
408 void QRangeModel::setPositionAtMinimum(qreal min)
409 {
410  Q_D(QRangeModel);
411  setPositionRange(min, d->posatmax);
412 }
413 
414 qreal QRangeModel::positionAtMinimum() const
415 {
416  Q_D(const QRangeModel);
417  return d->posatmin;
418 }
419 
427 void QRangeModel::setPositionAtMaximum(qreal max)
428 {
429  Q_D(QRangeModel);
430  setPositionRange(d->posatmin, max);
431 }
432 
433 qreal QRangeModel::positionAtMaximum() const
434 {
435  Q_D(const QRangeModel);
436  return d->posatmax;
437 }
438 
445 qreal QRangeModel::valueForPosition(qreal position) const
446 {
447  Q_D(const QRangeModel);
448 
449  const qreal unconstrainedValue = d->equivalentValue(position);
450  return d->publicValue(unconstrainedValue);
451 }
452 
463 qreal QRangeModel::value() const
464 {
465  Q_D(const QRangeModel);
466 
467  // Return internal value but observe boundaries and
468  // stepSize restrictions
469  return d->publicValue(d->value);
470 }
471 
472 void QRangeModel::setValue(qreal newValue)
473 {
474  Q_D(QRangeModel);
475 
476  if (qFuzzyCompare(newValue, d->value))
477  return;
478 
479  const qreal oldValue = value();
480  const qreal oldPosition = position();
481 
482  // Update relative value and position
483  d->value = newValue;
484  d->pos = d->equivalentPosition(d->value);
485  d->emitValueAndPositionIfChanged(oldValue, oldPosition);
486 }
487 
497 void QRangeModel::setInverted(bool inverted)
498 {
499  Q_D(QRangeModel);
500  if (inverted == d->inverted)
501  return;
502 
503  d->inverted = inverted;
504  emit invertedChanged(d->inverted);
505 
506  // After updating the internal value, the position property can change.
507  setPosition(d->equivalentPosition(d->value));
508 }
509 
510 bool QRangeModel::inverted() const
511 {
512  Q_D(const QRangeModel);
513  return d->inverted;
514 }
515 
520 void QRangeModel::toMinimum()
521 {
522  Q_D(const QRangeModel);
523  setValue(d->minimum);
524 }
525 
530 void QRangeModel::toMaximum()
531 {
532  Q_D(const QRangeModel);
533  setValue(d->maximum);
534 }
535 
536 } // Plasma namespace
537 
538 #include "qrangemodel.moc"
Plasma::QRangeModelPrivate::value
qreal value
Definition: qrangemodel_p.h:56
Plasma::QRangeModel::setMaximum
void setMaximum(qreal max)
Definition: qrangemodel.cpp:308
Plasma::QRangeModelPrivate
Definition: qrangemodel_p.h:46
Plasma::QRangeModelPrivate::pos
qreal pos
Definition: qrangemodel_p.h:56
Plasma::QRangeModelPrivate::emitValueAndPositionIfChanged
void emitValueAndPositionIfChanged(const qreal oldValue, const qreal oldPosition)
Definition: qrangemodel.cpp:167
Plasma::QRangeModel::positionAtMaximum
qreal positionAtMaximum() const
Plasma::QRangeModel::stepSizeChanged
void stepSizeChanged(qreal stepSize)
Plasma::QRangeModel::maximumChanged
void maximumChanged(qreal max)
Plasma::QRangeModelPrivate::stepSize
qreal stepSize
Definition: qrangemodel_p.h:56
Plasma::QRangeModelPrivate::inverted
uint inverted
Definition: qrangemodel_p.h:58
Plasma::QRangeModel::setPositionAtMaximum
void setPositionAtMaximum(qreal posAtMax)
Definition: qrangemodel.cpp:427
Plasma::QRangeModel::minimum
qreal minimum() const
Definition: qrangemodel.cpp:295
Plasma::QRangeModelPrivate::init
void init()
Definition: qrangemodel.cpp:79
Plasma::QRangeModel::valueForPosition
Q_INVOKABLE qreal valueForPosition(qreal position) const
Definition: qrangemodel.cpp:445
Plasma::QRangeModel::setPositionAtMinimum
void setPositionAtMinimum(qreal posAtMin)
Definition: qrangemodel.cpp:408
Plasma::QRangeModelPrivate::effectivePosAtMin
qreal effectivePosAtMin() const
Definition: qrangemodel_p.h:62
Plasma::QRangeModel::stepSize
qreal stepSize() const
Plasma::QRangeModelPrivate::QRangeModelPrivate
QRangeModelPrivate(QRangeModel *qq)
Definition: qrangemodel.cpp:70
Plasma::QRangeModel::~QRangeModel
virtual ~QRangeModel()
Definition: qrangemodel.cpp:208
Plasma::QRangeModel::positionAtMinimum
qreal positionAtMinimum() const
Plasma::QRangeModel::position
qreal position() const
Plasma::QRangeModel::setPosition
void setPosition(qreal position)
Definition: qrangemodel.cpp:385
QObject
Plasma::QRangeModelPrivate::publicValue
qreal publicValue(qreal value) const
Definition: qrangemodel.cpp:139
Plasma::QRangeModel::toMinimum
void toMinimum()
Definition: qrangemodel.cpp:520
Plasma::QRangeModelPrivate::minimum
qreal minimum
Definition: qrangemodel_p.h:56
Plasma::QRangeModel::d_ptr
QRangeModelPrivate * d_ptr
Definition: qrangemodel.h:116
Plasma::QRangeModel::value
qreal value() const
Plasma::QRangeModel::maximum
qreal maximum() const
Definition: qrangemodel.cpp:316
qrangemodel.h
Plasma::QRangeModel::toMaximum
void toMaximum()
Definition: qrangemodel.cpp:530
Plasma::QRangeModel::positionForValue
Q_INVOKABLE qreal positionForValue(qreal value) const
Definition: qrangemodel.cpp:358
Plasma::QRangeModel
Definition: qrangemodel.h:51
Plasma::QRangeModelPrivate::~QRangeModelPrivate
virtual ~QRangeModelPrivate()
Definition: qrangemodel.cpp:75
Plasma::QRangeModel::positionAtMinimumChanged
void positionAtMinimumChanged(qreal min)
Plasma::QRangeModel::minimumChanged
void minimumChanged(qreal min)
Plasma::QRangeModel::QRangeModel
QRangeModel(QObject *parent=0)
Definition: qrangemodel.cpp:185
Plasma::QRangeModel::setPositionRange
void setPositionRange(qreal min, qreal max)
Definition: qrangemodel.cpp:220
Plasma::QRangeModel::setStepSize
void setStepSize(qreal stepSize)
Definition: qrangemodel.cpp:330
Plasma::QRangeModelPrivate::posatmax
qreal posatmax
Definition: qrangemodel_p.h:55
Plasma::QRangeModelPrivate::maximum
qreal maximum
Definition: qrangemodel_p.h:56
Plasma::QRangeModelPrivate::publicPosition
qreal publicPosition(qreal position) const
Definition: qrangemodel.cpp:98
qrangemodel_p.h
Plasma::QRangeModel::invertedChanged
void invertedChanged(bool inverted)
Plasma::QRangeModel::setValue
void setValue(qreal value)
Definition: qrangemodel.cpp:472
Plasma::QRangeModel::positionAtMaximumChanged
void positionAtMaximumChanged(qreal max)
Plasma::QRangeModel::setInverted
void setInverted(bool inverted)
Definition: qrangemodel.cpp:497
Plasma::QRangeModel::setMinimum
void setMinimum(qreal min)
Definition: qrangemodel.cpp:289
Plasma::QRangeModel::inverted
bool inverted() const
Plasma::QRangeModelPrivate::effectivePosAtMax
qreal effectivePosAtMax() const
Definition: qrangemodel_p.h:66
Plasma::QRangeModel::setRange
void setRange(qreal min, qreal max)
Definition: qrangemodel.cpp:255
Plasma::QRangeModelPrivate::posatmin
qreal posatmin
Definition: qrangemodel_p.h:55
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:08:40 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

PlasmaComponents

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

kde-runtime API Reference

Skip menu "kde-runtime API Reference"
  • KCMShell
  • KNotify
  • Plasma Runtime
  •     PlasmaCore
  •     DragAndDrop
  •     PlasmaComponents
  •     PlasmaExtraComponents
  •     QtExtraComponents

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal