comparison widgets/Thumbwheel.cpp @ 946:36cddc3de023 alignment_view

Merge from default branch

         emit valueChanged(getValue());
     }
 }
 
 void
-Thumbwheel::setMappedValue(float mappedValue)
+Thumbwheel::setMappedValue(double mappedValue)
 {
     if (m_rangeMapper) {
         int newValue = m_rangeMapper->getPositionForValue(mappedValue);
         bool changed = (m_mappedValue != mappedValue);
         m_mappedValue = mappedValue;

 Thumbwheel::getValue() const
 {
     return m_value;
 }
 
-float
+double
 Thumbwheel::getMappedValue() const
 {
     if (m_rangeMapper) {
 //        SVDEBUG << "Thumbwheel::getMappedValue(): value = " << getValue() << ", mappedValue = " << m_mappedValue << endl;
         return m_mappedValue;

 }
 
 void
 Thumbwheel::scroll(bool up)
 {
-    int step = lrintf(m_speed);
+    int step = int(lrintf(m_speed));
     if (step == 0) step = 1;
 
     if (up) {
 	setValue(m_value + step);
     } else {

 
     bool ok = false;
 
     if (m_rangeMapper) {
         
-        float min = m_rangeMapper->getValueForPosition(m_min);
-        float max = m_rangeMapper->getValueForPosition(m_max);
+        double min = m_rangeMapper->getValueForPosition(m_min);
+        double max = m_rangeMapper->getValueForPosition(m_max);
                 
         if (min > max) { 
-            float tmp = min;
+            double tmp = min;
             min = max;
             max = tmp;
         }
 
         QString unit = m_rangeMapper->getUnit();

                 text = tr("Enter a new value from %1 to %2:")
                     .arg(min).arg(max);
             }
         }
         
-        float newValue = QInputDialog::getDouble
+        double newValue = QInputDialog::getDouble
             (this,
              tr("Enter new value"),
              text,
              m_mappedValue,
              min,

         dist = e->x() - m_clickPos.x();
     } else {
         dist = e->y() - m_clickPos.y();
     }
 
-    float rotation = m_clickRotation + (m_speed * dist) / 100;
+    float rotation = m_clickRotation + (m_speed * float(dist)) / 100;
     if (rotation < 0.f) rotation = 0.f;
     if (rotation > 1.f) rotation = 1.f;
-    int value = lrintf(m_min + (m_max - m_min) * m_rotation);
+    int value = int(lrintf(float(m_min) + float(m_max - m_min) * m_rotation));
     if (value != m_value) {
         setValue(value);
         if (m_tracking) emit valueChanged(getValue());
         m_rotation = rotation;
     } else if (fabsf(rotation - m_rotation) > 0.001) {

 }
 
 void
 Thumbwheel::wheelEvent(QWheelEvent *e)
 {
-    int step = lrintf(m_speed);
+    int step = int(lrintf(m_speed));
     if (step == 0) step = 1;
 
     if (e->delta() > 0) {
 	setValue(m_value + step);
     } else {

     paint.setClipRect(rect());
     paint.fillRect(subclip, palette().background().color());
 
     paint.setRenderHint(QPainter::Antialiasing, true);
 
-    float w  = width();
-    float w0 = 0.5;
-    float w1 = w - 0.5;
-
-    float h  = height();
-    float h0 = 0.5;
-    float h1 = h - 0.5;
+    double w  = width();
+    double w0 = 0.5;
+    double w1 = w - 0.5;
+
+    double h  = height();
+    double h0 = 0.5;
+    double h1 = h - 0.5;
 
     for (int i = bw-1; i >= 0; --i) {
 
         int grey = (i + 1) * (256 / (bw + 1));
         QColor fc = QColor(grey, grey, grey);

         paint.drawPath(path);
     }
 
     paint.setClipRect(subclip);
 
-    float radians = m_rotation * 1.5f * M_PI;
+    double radians = m_rotation * 1.5f * M_PI;
 
 //    cerr << "value = " << m_value << ", min = " << m_min << ", max = " << m_max << ", rotation = " << rotation << endl;
 
     w = (m_orientation == Qt::Horizontal ? width() : height()) - bw*2;
 

     // radius of the wheel including invisible part
     int radius = int(w / 2 + 2);
 
     for (int i = 0; i < notches; ++i) {
 
-        float a0 = (2.f * M_PI * i) / notches + radians;
-        float a1 = a0 + M_PI / (notches * 2);
-        float a2 = (2.f * M_PI * (i + 1)) / notches + radians;
-
-        float depth = cosf((a0 + a2) / 2);
+        double a0 = (2.0 * M_PI * i) / notches + radians;
+        double a1 = a0 + M_PI / (notches * 2);
+        double a2 = (2.0 * M_PI * (i + 1)) / notches + radians;
+
+        double depth = cos((a0 + a2) / 2);
         if (depth < 0) continue;
 
-        float x0 = radius * sinf(a0) + w/2;
-        float x1 = radius * sinf(a1) + w/2;
-        float x2 = radius * sinf(a2) + w/2;
+        double x0 = radius * sin(a0) + w/2;
+        double x1 = radius * sin(a1) + w/2;
+        double x2 = radius * sin(a2) + w/2;
         if (x2 < 0 || x0 > w) continue;
 
         if (x0 < 0) x0 = 0;
         if (x2 > w) x2 = w;
 
         x0 += bw;
         x1 += bw;
         x2 += bw;
 
-        int grey = lrintf(120 * depth);
+        int grey = int(lrint(120 * depth));
 
         QColor fc = QColor(grey, grey, grey);
         QColor oc = palette().highlight().color();
 
         paint.setPen(fc);
 
         if (m_showScale) {
 
             paint.setBrush(oc);
 
-            float prop;
+            double prop;
             if (i >= notches / 4) {
-                prop = float(notches - (((i - float(notches) / 4.f) * 4.f) / 3.f))
+                prop = double(notches - (((i - double(notches) / 4.f) * 4.f) / 3.f))
                     / notches;
             } else {
                 prop = 0.f;
             }