X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fdragvalue.cpp;h=64a8f2eec69f53b43f8ed4c0ffc14f31fc13aa5e;hb=56aee6aedeeed3efd10ada8fe3c229eddc01ef05;hp=377dd952187f4d1818f127bfae5e044d85c9c47c;hpb=23803a2984c48c67414440ac078ae0e43b4ceec3;p=kdenlive

diff --git a/src/dragvalue.cpp b/src/dragvalue.cpp
index 377dd952..64a8f2ee 100644
--- a/src/dragvalue.cpp
+++ b/src/dragvalue.cpp
@@ -37,35 +37,39 @@
 #include <QPainter>
 #include <QStyle>
 
+#include <KDebug>
 #include <KIcon>
 #include <KLocalizedString>
 #include <KGlobalSettings>
 
-DragValue::DragValue(const QString &label, double defaultValue, int decimals, int id, const QString suffix, bool showSlider, QWidget* parent) :
-        QWidget(parent),
-        m_maximum(100),
-        m_minimum(0),
-        m_decimals(decimals),
-        m_default(defaultValue),
-        m_id(id),
-        m_intEdit(NULL),
-        m_doubleEdit(NULL)
+
+DragValue::DragValue(const QString &label, double defaultValue, int decimals, double min, double max, int id, const QString &suffix, bool showSlider, QWidget* parent) :
+    QWidget(parent),
+    m_maximum(max),
+    m_minimum(min),
+    m_decimals(decimals),
+    m_default(defaultValue),
+    m_id(id),
+    m_intEdit(NULL),
+    m_doubleEdit(NULL)
 {
     if (showSlider) setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     else setSizePolicy(QSizePolicy::Maximum, QSizePolicy::MinimumExpanding);
     setFocusPolicy(Qt::StrongFocus);
     setContextMenuPolicy(Qt::CustomContextMenu);
+    setFocusPolicy(Qt::StrongFocus);
     
     QHBoxLayout *l = new QHBoxLayout;
     l->setSpacing(0);
     l->setContentsMargins(0, 0, 0, 0);
-    m_label = new CustomLabel(label, showSlider, decimals, this);
-    m_label->setCursor(Qt::PointingHandCursor);
-    m_label->setRange(m_minimum, m_maximum);
+    m_label = new CustomLabel(label, showSlider, m_maximum - m_minimum, this);
     l->addWidget(m_label);
     if (decimals == 0) {
+        m_label->setMaximum(max - min);
+        m_label->setStep(1);
         m_intEdit = new QSpinBox(this);
         m_intEdit->setObjectName("dragBox");
+        m_intEdit->setFocusPolicy(Qt::StrongFocus);
         if (!suffix.isEmpty()) m_intEdit->setSuffix(suffix);
         m_intEdit->setKeyboardTracking(false);
         m_intEdit->setButtonSymbols(QAbstractSpinBox::NoButtons);
@@ -75,10 +79,10 @@ DragValue::DragValue(const QString &label, double defaultValue, int decimals, in
         l->addWidget(m_intEdit);
         connect(m_intEdit, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));
         connect(m_intEdit, SIGNAL(editingFinished()), this, SLOT(slotEditingFinished()));
-    }
-    else {
+    } else {
         m_doubleEdit = new QDoubleSpinBox(this);
         m_doubleEdit->setDecimals(decimals);
+        m_doubleEdit->setFocusPolicy(Qt::StrongFocus);
         m_doubleEdit->setObjectName("dragBox");
         if (!suffix.isEmpty()) m_doubleEdit->setSuffix(suffix);
         m_doubleEdit->setKeyboardTracking(false);
@@ -86,19 +90,25 @@ DragValue::DragValue(const QString &label, double defaultValue, int decimals, in
         m_doubleEdit->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
         m_doubleEdit->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
         m_doubleEdit->setRange(m_minimum, m_maximum);
+        double factor = 100;
+        if (m_maximum - m_minimum > 10000) factor = 1000;
+        m_label->setStep(1);
+        m_doubleEdit->setSingleStep((m_maximum - m_minimum) / factor);
         l->addWidget(m_doubleEdit);
         connect(m_doubleEdit, SIGNAL(valueChanged(double)), this, SLOT(slotSetValue(double)));
         connect(m_doubleEdit, SIGNAL(editingFinished()), this, SLOT(slotEditingFinished()));
     }
     
-    connect(m_label, SIGNAL(valueChanged(double,bool)), this, SLOT(setValue(double,bool)));
+    connect(m_label, SIGNAL(valueChanged(double,bool)), this, SLOT(setValueFromProgress(double,bool)));
     connect(m_label, SIGNAL(resetValue()), this, SLOT(slotReset()));
     setLayout(l);
-    if (m_intEdit) m_label->setMaximumHeight(m_intEdit->sizeHint().height());
-    else m_label->setMaximumHeight(m_doubleEdit->sizeHint().height());
+    if (m_intEdit)
+        m_label->setMaximumHeight(m_intEdit->sizeHint().height());
+    else
+        m_label->setMaximumHeight(m_doubleEdit->sizeHint().height());
 
     m_menu = new QMenu(this);
-  
+
     m_scale = new KSelectAction(i18n("Scaling"), this);
     m_scale->addAction(i18n("Normal scale"));
     m_scale->addAction(i18n("Pixel scale"));
@@ -122,7 +132,7 @@ DragValue::DragValue(const QString &label, double defaultValue, int decimals, in
         m_menu->addAction(timeline);
     }
 
-    connect(this, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(slotShowContextMenu(const QPoint&)));
+    connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slotShowContextMenu(QPoint)));
     connect(m_scale, SIGNAL(triggered(int)), this, SLOT(slotSetScaleMode(int)));
     connect(m_directUpdate, SIGNAL(triggered(bool)), this, SLOT(slotSetDirectUpdate(bool)));
 }
@@ -130,23 +140,27 @@ DragValue::DragValue(const QString &label, double defaultValue, int decimals, in
 
 DragValue::~DragValue()
 {
-    if (m_intEdit) delete m_intEdit;
-    if (m_doubleEdit) delete m_doubleEdit;
+    delete m_intEdit;
+    delete m_doubleEdit;
     delete m_menu;
-    delete m_scale;
-    delete m_directUpdate;
+    //delete m_scale;
+    //delete m_directUpdate;
 }
 
 int DragValue::spinSize()
 {
-    if (m_intEdit) return m_intEdit->sizeHint().width();
-    else return m_doubleEdit->sizeHint().width();
+    if (m_intEdit)
+        return m_intEdit->sizeHint().width();
+    else
+        return m_doubleEdit->sizeHint().width();
 }
 
 void DragValue::setSpinSize(int width)
 {
-    if (m_intEdit) m_intEdit->setMinimumWidth(width);
-    else m_doubleEdit->setMinimumWidth(width);
+    if (m_intEdit)
+        m_intEdit->setMinimumWidth(width);
+    else
+        m_doubleEdit->setMinimumWidth(width);
 }
 
 void DragValue::slotSetInTimeline()
@@ -177,27 +191,34 @@ qreal DragValue::value() const
 
 void DragValue::setMaximum(qreal max)
 {
-    m_maximum = max;
-    m_label->setRange(m_minimum, m_maximum);
-    if (m_intEdit) m_intEdit->setRange(m_minimum, m_maximum);
-    else m_doubleEdit->setRange(m_minimum, m_maximum);
+    if (m_maximum != max) {
+        m_maximum = max;
+        if (m_intEdit)
+            m_intEdit->setRange(m_minimum, m_maximum);
+        else
+            m_doubleEdit->setRange(m_minimum, m_maximum);
+    }
 }
 
 void DragValue::setMinimum(qreal min)
 {
-    m_minimum = min;
-    m_label->setRange(m_minimum, m_maximum);
-    if (m_intEdit) m_intEdit->setRange(m_minimum, m_maximum);
-    else m_doubleEdit->setRange(m_minimum, m_maximum);
+    if (m_minimum != min) {
+        m_minimum = min;
+        if (m_intEdit)
+            m_intEdit->setRange(m_minimum, m_maximum);
+        else
+            m_doubleEdit->setRange(m_minimum, m_maximum);
+    }
 }
 
 void DragValue::setRange(qreal min, qreal max)
 {
     m_maximum = max;
     m_minimum = min;
-    m_label->setRange(m_minimum, m_maximum);
-    if (m_intEdit) m_intEdit->setRange(m_minimum, m_maximum);
-    else m_doubleEdit->setRange(m_minimum, m_maximum);
+    if (m_intEdit)
+        m_intEdit->setRange(m_minimum, m_maximum);
+    else
+        m_doubleEdit->setRange(m_minimum, m_maximum);
 }
 
 void DragValue::setPrecision(int /*precision*/)
@@ -210,9 +231,12 @@ void DragValue::setPrecision(int /*precision*/)
         m_edit->setValidator(new QDoubleValidator(m_minimum, m_maximum, precision, this));*/
 }
 
-void DragValue::setStep(qreal /*step*/)
+void DragValue::setStep(qreal step)
 {
-    //m_step = step;
+    if (m_intEdit)
+        m_intEdit->setSingleStep(step);
+    else
+        m_doubleEdit->setSingleStep(step);
 }
 
 void DragValue::slotReset()
@@ -229,17 +253,26 @@ void DragValue::slotReset()
         m_doubleEdit->blockSignals(false);
         emit valueChanged(m_default, true);
     }
-    m_label->setProgressValue(m_default);
+    m_label->setProgressValue((m_default - m_minimum) / (m_maximum - m_minimum) * m_label->maximum());
 }
 
 void DragValue::slotSetValue(int value)
 {
-    setValue(value, KdenliveSettings::dragvalue_directupdate());
+    setValue(value, true);
 }
 
 void DragValue::slotSetValue(double value)
 {
-    setValue(value, KdenliveSettings::dragvalue_directupdate());
+    setValue(value, true);
+}
+
+void DragValue::setValueFromProgress(double value, bool final)
+{
+    value = m_minimum + value * (m_maximum - m_minimum) / m_label->maximum();
+    if (m_decimals == 0)
+        setValue(qRound(value), final);
+    else
+        setValue(value, final);
 }
 
 void DragValue::setValue(double value, bool final)
@@ -257,11 +290,23 @@ void DragValue::setValue(double value, bool final)
         m_doubleEdit->blockSignals(false);
         emit valueChanged(value, final);
     }
-    m_label->setProgressValue(value);
+
+    m_label->setProgressValue((value - m_minimum) / (m_maximum - m_minimum) * m_label->maximum());
+}
+
+void DragValue::focusOutEvent(QFocusEvent*)
+{
+    if (m_intEdit) m_intEdit->setFocusPolicy(Qt::StrongFocus);
+    else m_doubleEdit->setFocusPolicy(Qt::StrongFocus);
 }
 
 void DragValue::focusInEvent(QFocusEvent* e)
 {
+    if (m_intEdit)
+        m_intEdit->setFocusPolicy(Qt::WheelFocus);
+    else
+        m_doubleEdit->setFocusPolicy(Qt::WheelFocus);
+
     if (e->reason() == Qt::TabFocusReason || e->reason() == Qt::BacktabFocusReason) {
         if (m_intEdit) m_intEdit->setFocus(e->reason());
         else m_doubleEdit->setFocus(e->reason());
@@ -272,16 +317,20 @@ void DragValue::focusInEvent(QFocusEvent* e)
 
 void DragValue::slotEditingFinished()
 {
-    qreal value;
     if (m_intEdit) {
-        value = m_intEdit->value();
+        int value = m_intEdit->value();
+        m_intEdit->blockSignals(true);
         m_intEdit->clearFocus();
+        m_intEdit->blockSignals(false);
+        if (!KdenliveSettings::dragvalue_directupdate()) emit valueChanged((double) value, true);
     }
     else {
-        value = m_doubleEdit->value();
+        double value = m_doubleEdit->value();
+        m_doubleEdit->blockSignals(true);
         m_doubleEdit->clearFocus();
+        m_doubleEdit->blockSignals(false);
+        if (!KdenliveSettings::dragvalue_directupdate()) emit valueChanged(value, true);
     }
-    emit valueChanged(value, true);
 }
 
 void DragValue::slotShowContextMenu(const QPoint& pos)
@@ -324,22 +373,24 @@ void DragValue::setInTimelineProperty(bool intimeline)
     
 }
 
-CustomLabel::CustomLabel(const QString &label, bool showSlider, int precision, QWidget* parent) :
+CustomLabel::CustomLabel(const QString &label, bool showSlider, int range, QWidget* parent) :
     QProgressBar(parent),
     m_dragMode(false),
-    m_step(1.0),
     m_showSlider(showSlider),
-    m_precision(pow(10, precision)),
-    m_value(0)
+    m_step(10.0)
+  //m_precision(pow(10, precision)),
 {
     setFont(KGlobalSettings::toolBarFont());
-    setFormat(" " + label);
-    setFocusPolicy(Qt::ClickFocus);
+    setFormat(' ' + label);
+    setFocusPolicy(Qt::StrongFocus);
+    setCursor(Qt::PointingHandCursor);
     setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
-    if (!showSlider) {
+    if (showSlider) setRange(0, 1000);
+    else {
+        setRange(0, range);
         QSize sh;
         const QFontMetrics &fm = fontMetrics();
-        sh.setWidth(fm.width(" " + label + " "));
+        sh.setWidth(fm.width(' ' + label + ' '));
         setMaximumWidth(sh.width());
         setObjectName("dragOnly");
     }
@@ -379,12 +430,12 @@ void CustomLabel::mouseMoveEvent(QMouseEvent* e)
                 if (KdenliveSettings::dragvalue_mode() == 2)
                     diff = (diff > 0 ? 1 : -1) * pow(diff, 2);
 
-                int nv = m_value + diff / m_step;
-                if (nv != m_value) setNewValue(nv, KdenliveSettings::dragvalue_directupdate());
+                double nv = value() + diff * m_step;
+                if (nv != value()) setNewValue(nv, KdenliveSettings::dragvalue_directupdate());
             }
             else {
                 double nv = minimum() + ((double) maximum() - minimum()) / width() * e->pos().x();
-                if (nv != m_value) setNewValue(nv, KdenliveSettings::dragvalue_directupdate());
+                if (nv != value()) setNewValue(nv, KdenliveSettings::dragvalue_directupdate());
             }
             m_dragLastPosition = e->pos();
             e->accept();
@@ -405,12 +456,12 @@ void CustomLabel::mouseReleaseEvent(QMouseEvent* e)
         return;
     }
     if (m_dragMode) {
-        setNewValue(m_value, true);
+        setNewValue(value(), true);
         m_dragLastPosition = m_dragStartPosition;
         e->accept();
     }
     else if (m_showSlider) {
-        setNewValue((minimum() + ((double)maximum() - minimum()) / width() * e->pos().x()), true);
+        setNewValue((double) maximum() * e->pos().x() / width(), true);
         m_dragLastPosition = m_dragStartPosition;
         e->accept();
     }
@@ -421,12 +472,12 @@ void CustomLabel::wheelEvent(QWheelEvent* e)
 {
     if (e->delta() > 0) {
         if (e->modifiers() == Qt::ControlModifier) slotValueInc(10);
-        else if (e->modifiers() == Qt::AltModifier) slotValueInc(1.0 / m_precision);
+        else if (e->modifiers() == Qt::AltModifier) slotValueInc(0.1);
         else slotValueInc();
     }
     else {
         if (e->modifiers() == Qt::ControlModifier) slotValueDec(10);
-        else if (e->modifiers() == Qt::AltModifier) slotValueDec(1.0 / m_precision);
+        else if (e->modifiers() == Qt::AltModifier) slotValueDec(0.1);
         else slotValueDec();
     }
     e->accept();
@@ -434,26 +485,38 @@ void CustomLabel::wheelEvent(QWheelEvent* e)
 
 void CustomLabel::slotValueInc(double factor)
 {
-    setNewValue(m_value + m_step * factor, true);
+    setNewValue(value() + m_step * factor, true);
 }
 
 void CustomLabel::slotValueDec(double factor)
 {
-    setNewValue(m_value - m_step * factor, true);
+    setNewValue(value() - m_step * factor, true);
 }
 
 void CustomLabel::setProgressValue(double value)
 {
-    m_value = value;
-    setValue((int) value);
+    setValue(qRound(value));
 }
 
 void CustomLabel::setNewValue(double value, bool update)
 {
-    m_value = value;
-    setValue(value);
-    emit valueChanged(value, update);
+    setValue(qRound(value));
+    emit valueChanged(qRound(value), update);
 }
 
-#include "dragvalue.moc"
+void CustomLabel::setStep(double step)
+{
+    m_step = step;
+}
+
+void CustomLabel::focusInEvent(QFocusEvent*)
+{
+    setFocusPolicy(Qt::WheelFocus);
+}
 
+void CustomLabel::focusOutEvent(QFocusEvent*)
+{
+    setFocusPolicy(Qt::StrongFocus);
+}
+
+#include "dragvalue.moc"