separate h/v overshoot policy (plus some cleanups)

9 files changed, 160 insertions, 91 deletions

diff --git a/kineticscroller.pro b/kineticscroller.pro
index 8b879b7..061318a 100644
--- a/kineticscroller.pro
+++ b/kineticscroller.pro
@@ -3,10 +3,28 @@
 ######################################################################
 
 TEMPLATE = app
-TARGET = 
+TARGET =
 DEPENDPATH += .
 INCLUDEPATH += .
 
 # Input
-HEADERS += qkineticscroller.h qkineticscroller_p.h qscrollareakineticscroller.h metricswidget.h plotwidget.h
-SOURCES += main.cpp qkineticscroller.cpp qscrollareakineticscroller.cpp metricswidget.cpp plotwidget.cpp
+HEADERS += \
+    qkineticscroller.h \
+    qkineticscroller_p.h \
+    qscrollareakineticscroller.h
+
+SOURCES += \
+    qkineticscroller.cpp \
+    qscrollareakineticscroller.cpp
+
+# debug/development stuff
+
+HEADERS += \
+    settingswidget.h \
+    plotwidget.h
+
+SOURCES += \
+    settingswidget.cpp \
+    plotwidget.cpp \
+    main.cpp
+
diff --git a/main.cpp b/main.cpp
index 7ea0354..698ec64 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,14 +1,13 @@
 #include <QtGui>
 #include "qscrollareakineticscroller.h"
 
-#include "metricswidget.h"
+#include "settingswidget.h"
 #include "plotwidget.h"
 
 int main(int argc, char **argv)
 {
     QApplication a(argc, argv);
 
-    QWidget *w = new QWidget();
     QListWidget *lw = new QListWidget();
 
     for (int i = 0; i < 1000; ++i)
@@ -17,20 +16,18 @@ int main(int argc, char **argv)
     QScrollAreaKineticScroller *s = new QScrollAreaKineticScroller();
     s->setWidget(lw);
 
-    QWidget *metrics = new MetricsWidget(s);
+    QWidget *settings = new SettingsWidget(s);
     QWidget *plot = new PlotWidget(s);
 
-    QHBoxLayout *lay = new QHBoxLayout(w);
-    lay->addWidget(lw);
+    QSplitter *split = new QSplitter();
+    split->addWidget(lw);
     QTabWidget *tab = new QTabWidget();
-    tab->addTab(metrics, metrics->windowTitle());
+    tab->addTab(settings, settings->windowTitle());
     tab->addTab(plot, plot->windowTitle());
-    lay->addWidget(tab);
-    
-    w->show();
-    w->raise();
+    split->addWidget(tab);
 
-    s->scrollTo(QPointF(80,3000));
+    split->show();
+    split->raise();
 
     return a.exec();
 }
diff --git a/plotwidget.cpp b/plotwidget.cpp
index 90231ec..41a2f72 100644
--- a/plotwidget.cpp
+++ b/plotwidget.cpp
@@ -8,7 +8,7 @@ PlotWidget::PlotWidget(QKineticScroller *scroller)
 {
     setWindowTitle(QLatin1String("Plot"));
     m_scroller->registerDebugHook(debugHook, this);
-    
+
     m_clear = new QPushButton(QLatin1String("Clear"), this);
     connect(m_clear, SIGNAL(clicked()), this, SLOT(reset()));
     m_legend = new QLabel(QLatin1String("Legend"), this);
@@ -43,12 +43,12 @@ void PlotWidget::addPlotItem(const PlotItem &pi)
 
     while (m_plotitems.size() > 500)
         m_plotitems.removeFirst();
-    
+
     foreach (const PlotItem &pi, m_plotitems) {
         doMaxMin(pi.releaseVelocity, minMaxVelocity);
         doMaxMin(pi.contentPosition, minMaxPosition);
         doMaxMin(pi.overshootPosition, minMaxPosition);
-    } 
+    }
     update();
 }
 
@@ -84,19 +84,19 @@ void PlotWidget::paintEvent(QPaintEvent *)
         return;
 
     int x = 2;
-    int offset = m_plotitems.size() - width() / 2;    
+    int offset = m_plotitems.size() - width() / 2;
     QList<PlotItem>::const_iterator it = m_plotitems.constBegin();
     if (offset > 0)
         it += (offset - 1);
-    
+
 //     PlotItem &last = const_cast<PlotItem &>(*it++);
 //     PlotItem dummy;
      const PlotItem *last = &(*it++);
 //     last = *it++;
-        
+
 //    qWarning() << "lastOp[0].y = " << last.overshootPosition.y() << m_plotitems.at(1).overshootPosition.y();
-        
-    while (it != m_plotitems.constEnd()) {    
+
+    while (it != m_plotitems.constEnd()) {
         p.setPen(rvColor.light());
         p.drawLine(qreal(x - 2), SCALE(last->releaseVelocity.x(), minMaxVelocity),
                    qreal(x), SCALE(it->releaseVelocity.x(), minMaxVelocity));
diff --git a/plotwidget.h b/plotwidget.h
index 8031549..c555b13 100644
--- a/plotwidget.h
+++ b/plotwidget.h
@@ -14,20 +14,20 @@ public:
 
 public slots:
     void reset();
-    
+
 protected:
     void resizeEvent(QResizeEvent *);
     void paintEvent(QPaintEvent *);
-    
+
 private:
     static void debugHook(void *user, const QPointF &releaseVelocity, const QPointF &contentPosition, const QPointF &overshootPosition);
-    
+
     struct PlotItem {
         QPointF releaseVelocity;
         QPointF contentPosition;
         QPointF overshootPosition;
     };
-    
+
     void addPlotItem(const PlotItem &pi);
 
     QKineticScroller *m_scroller;
diff --git a/qkineticscroller.cpp b/qkineticscroller.cpp
index f2888a4..0544518 100644
--- a/qkineticscroller.cpp
+++ b/qkineticscroller.cpp
@@ -182,7 +182,8 @@ QKineticScroller::~QKineticScroller()
 QKineticScrollerPrivate::QKineticScrollerPrivate()
     : enabled(true)
     , state(QKineticScroller::StateInactive)
-    , overshootPolicy(QKineticScroller::OvershootWhenScrollable)
+    , hOvershootPolicy(QKineticScroller::OvershootWhenScrollable)
+    , vOvershootPolicy(QKineticScroller::OvershootWhenScrollable)
     , pressTimestamp(0)
     , lastTimestamp(0)
     , scrollToX(false)
@@ -205,10 +206,9 @@ void QKineticScrollerPrivate::init()
 
 void QKineticScroller::registerDebugHook(void (*callback)(void *user, const QPointF &releaseVelocity, const QPointF &position, const QPointF &overshootPosition), void *user)
 {
-    Q_D(QKineticScroller);   
+    Q_D(QKineticScroller);
     d->debugHook = callback;
     d->debugHookUser = user;
-    qWarning("AAAAAAAAAAAAAAAAA");
 }
 
 void QKineticScroller::resetScrollMetrics()
@@ -393,16 +393,28 @@ void QKineticScroller::reset()
     d->setState(StateInactive);
 }
 
-QKineticScroller::OvershootPolicy QKineticScroller::overshootPolicy() const
+QKineticScroller::OvershootPolicy QKineticScroller::horizontalOvershootPolicy() const
+{
+    Q_D(const QKineticScroller);
+    return d->hOvershootPolicy;
+}
+
+void QKineticScroller::setHorizontalOvershootPolicy(QKineticScroller::OvershootPolicy policy)
+{
+    Q_D(QKineticScroller);
+    d->hOvershootPolicy = policy;
+}
+
+QKineticScroller::OvershootPolicy QKineticScroller::verticalOvershootPolicy() const
 {
     Q_D(const QKineticScroller);
-    return d->overshootPolicy;
+    return d->vOvershootPolicy;
 }
 
-void QKineticScroller::setOvershootPolicy(QKineticScroller::OvershootPolicy policy)
+void QKineticScroller::setVerticalOvershootPolicy(QKineticScroller::OvershootPolicy policy)
 {
     Q_D(QKineticScroller);
-    d->overshootPolicy = policy;
+    d->vOvershootPolicy = policy;
 }
 
 QVariant QKineticScroller::scrollMetric(ScrollMetric metric) const
@@ -598,8 +610,8 @@ void QKineticScrollerPrivate::handleDrag(const QPointF &position, qint64 timesta
 
     // restrict velocity, if content is not scrollable
     QPointF maxPos = q->maximumContentPosition();
-    bool canScrollX = maxPos.x() || (overshootPolicy == QKineticScroller::OvershootAlwaysOn);
-    bool canScrollY = maxPos.y() || (overshootPolicy == QKineticScroller::OvershootAlwaysOn);
+    bool canScrollX = maxPos.x() || (hOvershootPolicy == QKineticScroller::OvershootAlwaysOn);
+    bool canScrollY = maxPos.y() || (vOvershootPolicy == QKineticScroller::OvershootAlwaysOn);
 
     if (!canScrollX) {
         deltaPixel.setX(0);
@@ -631,7 +643,9 @@ bool QKineticScrollerPrivate::pressWhileInactive(QKineticScroller::Input, const
 {
     Q_Q(QKineticScroller);
 
-    if ((q->maximumContentPosition() > qreal(0)) || (overshootPolicy == QKineticScroller::OvershootAlwaysOn)) {
+    if ((q->maximumContentPosition() > qreal(0)) ||
+        (hOvershootPolicy == QKineticScroller::OvershootAlwaysOn) ||
+        (vOvershootPolicy == QKineticScroller::OvershootAlwaysOn)) {
         if (q->canStartScrollingAt(position)) {
             lastPosition = pressPosition = position;
             lastTimestamp = pressTimestamp = timestamp;
@@ -666,8 +680,10 @@ bool QKineticScrollerPrivate::moveWhilePressed(QKineticScroller::Input, const QP
         bool canScrollX = (maxPos.x() > 0);
         bool canScrollY = (maxPos.y() > 0);
 
-        if (overshootPolicy == QKineticScroller::OvershootAlwaysOn)
-            canScrollX = canScrollY = true;
+        if (hOvershootPolicy == QKineticScroller::OvershootAlwaysOn)
+            canScrollX = true;
+        if (vOvershootPolicy == QKineticScroller::OvershootAlwaysOn)
+            canScrollY = true;
 
         if (deltaXtoY < 0) {
             if (!canScrollY && (!canScrollX || (-deltaXtoY >= dragStartDirectionErrorMargin)))
@@ -1006,11 +1022,14 @@ void QKineticScrollerPrivate::setContentPositionHelper(const QPointF &deltaPos)
     newClampedPos.setY(qBound(qreal(0), newPos.y(), maxPos.y()));
 
     // --- handle overshooting and stop if the coordinate is going back inside the normal area
-    bool alwaysOvershoot = (overshootPolicy == QKineticScroller::OvershootAlwaysOn);
-    bool noOvershoot = (overshootPolicy == QKineticScroller::OvershootAlwaysOff) ||
-        ((state == QKineticScroller::StateDragging) && !overshootDragResistanceFactor);
-    bool canOvershootX = !noOvershoot && (alwaysOvershoot || maxPos.x());
-    bool canOvershootY = !noOvershoot && (alwaysOvershoot || maxPos.y());
+    bool alwaysOvershootX = (hOvershootPolicy == QKineticScroller::OvershootAlwaysOn);
+    bool alwaysOvershootY = (vOvershootPolicy == QKineticScroller::OvershootAlwaysOn);
+    bool noOvershootX = (hOvershootPolicy == QKineticScroller::OvershootAlwaysOff) ||
+                        ((state == QKineticScroller::StateDragging) && !overshootDragResistanceFactor);
+    bool noOvershootY = (vOvershootPolicy == QKineticScroller::OvershootAlwaysOff) ||
+                        ((state == QKineticScroller::StateDragging) && !overshootDragResistanceFactor);
+    bool canOvershootX = !noOvershootX && (alwaysOvershootX || maxPos.x());
+    bool canOvershootY = !noOvershootY && (alwaysOvershootY || maxPos.y());
 
     qreal oldOvershootX = (canOvershootX) ? oldPos.x() - oldClampedPos.x() : 0;
     qreal oldOvershootY = (canOvershootY) ? oldPos.y() - oldClampedPos.y() : 0;
@@ -1023,9 +1042,9 @@ void QKineticScrollerPrivate::setContentPositionHelper(const QPointF &deltaPos)
     qreal newOvershootY = (canOvershootY) ? newPos.y() - newClampedPos.y() : 0;
 
     // --- sanity check for scrollTo in case we can't even scroll that direction
-    if (!(maxPos.x() || alwaysOvershoot))
+    if (!(maxPos.x() || alwaysOvershootX))
         scrollToX = false;
-    if (!(maxPos.y() || alwaysOvershoot))
+    if (!(maxPos.y() || alwaysOvershootY))
         scrollToY = false;
 
     QPointF oldScrollToDist = scrollToPosition - oldPos;
diff --git a/qkineticscroller.h b/qkineticscroller.h
index 239102f..e0378d4 100644
--- a/qkineticscroller.h
+++ b/qkineticscroller.h
@@ -81,8 +81,10 @@ public:
         OvershootAlwaysOn,
     };
 
-    OvershootPolicy overshootPolicy() const;
-    void setOvershootPolicy(OvershootPolicy policy);
+    OvershootPolicy horizontalOvershootPolicy() const;
+    void setHorizontalOvershootPolicy(OvershootPolicy policy);
+    OvershootPolicy verticalOvershootPolicy() const;
+    void setVerticalOvershootPolicy(OvershootPolicy policy);
 
     enum ScrollMetric
     {
diff --git a/qkineticscroller_p.h b/qkineticscroller_p.h
index 2dcbbbd..599bb68 100644
--- a/qkineticscroller_p.h
+++ b/qkineticscroller_p.h
@@ -118,7 +118,8 @@ public:
 
     bool enabled;
     QKineticScroller::State state;
-    QKineticScroller::OvershootPolicy overshootPolicy;
+    QKineticScroller::OvershootPolicy hOvershootPolicy;
+    QKineticScroller::OvershootPolicy vOvershootPolicy;
     QPointF oldVelocity;
 
     QPointF pressPosition;
diff --git a/metricswidget.cpp b/settingswidget.cpp
index e79d62c..e31a6fb 100644
--- a/metricswidget.cpp
+++ b/settingswidget.cpp
@@ -1,6 +1,6 @@
 #include <QtGui>
 
-#include "metricswidget.h"
+#include "settingswidget.h"
 #include "qkineticscroller.h"
 
 struct MetricItem
@@ -13,11 +13,11 @@ struct MetricItem
     QVariant step;
 };
 
-class ItemUpdater : public QObject
+class MetricItemUpdater : public QObject
 {
     Q_OBJECT
 public:
-    ItemUpdater(MetricItem *item, QKineticScroller *scroller)
+    MetricItemUpdater(MetricItem *item, QKineticScroller *scroller)
         : m_item(item), m_scroller(scroller)
     {
         if (m_item->min.type() == QVariant::PointF) {
@@ -173,13 +173,13 @@ MetricItem items[QKineticScroller::ScrollMetricCount] = {
 
 #undef METRIC
 
-QGridLayout *MetricsWidget::createControlGrid()
+QGridLayout *SettingsWidget::createMetricsItemGrid()
 {
     QGridLayout *grid = new QGridLayout();
     int row = 0;
 
     for (int i = 0; i < QKineticScroller::ScrollMetricCount; i++) {
-        ItemUpdater *u = new ItemUpdater(items + i, m_scroller);
+        MetricItemUpdater *u = new MetricItemUpdater(items + i, m_scroller);
         u->setParent(this);
 
         grid->addWidget(u->nameLabel(), row, 0);
@@ -199,10 +199,15 @@ public:
     using QKineticScroller::maximumContentPosition;
 };
 
-MetricsWidget::MetricsWidget(QKineticScroller *scroller)
+class HackSpinBox : public QSpinBox {
+public:
+    using QAbstractSpinBox::lineEdit;
+};
+
+SettingsWidget::SettingsWidget(QKineticScroller *scroller)
     : QWidget(), m_scroller(scroller)
 {
-    setWindowTitle(QLatin1String("Kinetic Scroller Metrics"));
+    setWindowTitle(QLatin1String("Settings"));
     QVBoxLayout *layout = new QVBoxLayout(this);
     QGroupBox *grp;
     QGridLayout *grid;
@@ -220,68 +225,95 @@ MetricsWidget::MetricsWidget(QKineticScroller *scroller)
     dpi->setValue(m_scroller->dpi());
     connect(dpi, SIGNAL(valueChanged(int)), this, SLOT(dpiChanged(int)));
     grid->addWidget(dpi, 1, 1);
-    
-    grid->addWidget(new QLabel("Overshoot Policy"), 2, 0);
-    m_ospolicy = new QComboBox();
-    m_ospolicy->addItem("When Scrollable", QKineticScroller::OvershootWhenScrollable);
-    m_ospolicy->addItem("Always On",   QKineticScroller::OvershootAlwaysOn);
-    m_ospolicy->addItem("Always Off",  QKineticScroller::OvershootAlwaysOff);
-    m_ospolicy->setCurrentIndex(m_ospolicy->findData(m_scroller->overshootPolicy()));
-    connect(m_ospolicy, SIGNAL(currentIndexChanged(int)), this, SLOT(overshootPolicyChanged(int)));
-    grid->addWidget(m_ospolicy, 2, 1);
+
+    grid->addWidget(new QLabel("Horizontal Overshoot Policy"), 2, 0);
+    m_hospolicy = new QComboBox();
+    m_hospolicy->addItem("When Scrollable", QKineticScroller::OvershootWhenScrollable);
+    m_hospolicy->addItem("Always On",       QKineticScroller::OvershootAlwaysOn);
+    m_hospolicy->addItem("Always Off",      QKineticScroller::OvershootAlwaysOff);
+    m_hospolicy->setCurrentIndex(m_hospolicy->findData(m_scroller->horizontalOvershootPolicy()));
+    connect(m_hospolicy, SIGNAL(currentIndexChanged(int)), this, SLOT(overshootPolicyChanged(int)));
+    grid->addWidget(m_hospolicy, 2, 1);
+
+    grid->addWidget(new QLabel("Vertical Overshoot Policy"), 3, 0);
+    m_vospolicy = new QComboBox();
+    m_vospolicy->addItem("When Scrollable", QKineticScroller::OvershootWhenScrollable);
+    m_vospolicy->addItem("Always On",       QKineticScroller::OvershootAlwaysOn);
+    m_vospolicy->addItem("Always Off",      QKineticScroller::OvershootAlwaysOff);
+    m_vospolicy->setCurrentIndex(m_vospolicy->findData(m_scroller->verticalOvershootPolicy()));
+    connect(m_vospolicy, SIGNAL(currentIndexChanged(int)), this, SLOT(overshootPolicyChanged(int)));
+    grid->addWidget(m_vospolicy, 3, 1);
     grp->setLayout(grid);
     layout->addWidget(grp);
-    
+
     grp = new QGroupBox(QLatin1String("Scroll Metrics"));
-    grid = createControlGrid();
+    grid = createMetricsItemGrid();
     grp->setLayout(grid);
     layout->addWidget(grp);
-    
+
     grp = new QGroupBox(QLatin1String("Scroll To"));
     grid = new QGridLayout();
-    
+
     QSizeF vp = static_cast<HackScroller *>(m_scroller)->viewportSize();
-    QPointF maxc = static_cast<HackScroller *>(m_scroller)->maximumContentPosition(); 
-    
+    QPointF maxc = static_cast<HackScroller *>(m_scroller)->maximumContentPosition();
+
     m_scrollx = new QSpinBox();
     m_scrollx->setRange(int(-vp.width()), int(maxc.x() + vp.width()));
-    m_scrollx->setSuffix(QLatin1String(" pix"));
     m_scrolly = new QSpinBox();
     m_scrolly->setRange(int(-vp.height()), int(maxc.y() + vp.height()));
-    m_scrolly->setSuffix(QLatin1String(" pix"));
     m_scrolltime = new QSpinBox();
     m_scrolltime->setRange(0, 10000);
     m_scrolltime->setValue(1000);
     m_scrolltime->setSuffix(QLatin1String(" ms"));
     QPushButton *go = new QPushButton(QLatin1String("Go"));
     connect(go, SIGNAL(clicked()), this, SLOT(scrollTo()));
-    grid->addWidget(m_scrollx, 0, 0);
-    grid->addWidget(m_scrolly, 0, 1);
-    grid->addWidget(m_scrolltime, 0, 2);
-    grid->addWidget(go, 0, 3);
-    
+    connect(m_scrollx, SIGNAL(editingFinished()), this, SLOT(scrollTo()));
+    connect(m_scrolly, SIGNAL(editingFinished()), this, SLOT(scrollTo()));
+    connect(m_scrolltime, SIGNAL(editingFinished()), this, SLOT(scrollTo()));
+    grid->addWidget(new QLabel(QLatin1String("X:")), 0, 0);
+    grid->addWidget(m_scrollx, 0, 1);
+    grid->addWidget(new QLabel(QLatin1String("Y:")), 0, 2);
+    grid->addWidget(m_scrolly, 0, 3);
+    grid->addWidget(new QLabel(QLatin1String("in")), 0, 4);
+    grid->addWidget(m_scrolltime, 0, 5);
+    grid->addWidget(go, 0, 6);
+    grid->setColumnStretch(1, 1);
+    grid->setColumnStretch(3, 1);
+    grid->setColumnStretch(5, 1);
+    grid->setColumnStretch(6, 1);
     grp->setLayout(grid);
     layout->addWidget(grp);
+    layout->addStretch(100);
 }
 
-void MetricsWidget::enabledChanged(bool on)
+void SettingsWidget::enabledChanged(bool on)
 {
     m_scroller->setEnabled(on);
 }
 
-void MetricsWidget::dpiChanged(int dpi)
+void SettingsWidget::dpiChanged(int dpi)
 {
     m_scroller->setDpi(dpi);
 }
 
-void MetricsWidget::overshootPolicyChanged(int index)
+void SettingsWidget::overshootPolicyChanged(int index)
 {
-    m_scroller->setOvershootPolicy(static_cast<QKineticScroller::OvershootPolicy>(m_ospolicy->itemData(index).toInt()));
+    if (sender() == m_hospolicy)
+        m_scroller->setHorizontalOvershootPolicy(static_cast<QKineticScroller::OvershootPolicy>(m_hospolicy->itemData(index).toInt()));
+    else if (sender() == m_vospolicy)
+        m_scroller->setVerticalOvershootPolicy(static_cast<QKineticScroller::OvershootPolicy>(m_hospolicy->itemData(index).toInt()));
 }
 
-void MetricsWidget::scrollTo()
+void SettingsWidget::scrollTo()
 {
+    if ((sender() == m_scrollx) && !m_scrollx->hasFocus())
+        return;
+    if ((sender() == m_scrolly) && !m_scrolly->hasFocus())
+        return;
+    if ((sender() == m_scrolltime) && !m_scrolltime->hasFocus())
+        return;
+
     m_scroller->scrollTo(QPointF(m_scrollx->value(), m_scrolly->value()), m_scrolltime->value());
 }
 
-#include "metricswidget.moc"
+#include "settingswidget.moc"
diff --git a/metricswidget.h b/settingswidget.h
index 955dc12..a426bdd 100644
--- a/metricswidget.h
+++ b/settingswidget.h
@@ -1,29 +1,29 @@
-#ifndef METRICSWIDGET_H
-#define METRICSWIDGET_H
+#ifndef SETTINGSWIDGET_H
+#define SETTINGSWIDGET_H
 
 #include <QtGui>
 
 class QKineticScroller;
 
-class MetricsWidget : public QWidget
+class SettingsWidget : public QWidget
 {
     Q_OBJECT
 
 public:
-    MetricsWidget(QKineticScroller *scroller);
-    
+    SettingsWidget(QKineticScroller *scroller);
+
 private slots:
     void enabledChanged(bool on);
     void dpiChanged(int dpi);
     void overshootPolicyChanged(int index);
     void scrollTo();
-    
+
 private:
-    QGridLayout *createControlGrid();
+    QGridLayout *createMetricsItemGrid();
 
     QKineticScroller *m_scroller;
     QSpinBox *m_scrollx, *m_scrolly, *m_scrolltime;
-    QComboBox *m_ospolicy;
+    QComboBox *m_hospolicy, *m_vospolicy;
 };
 
 #endif