Merge lp:~mixxxdevelopers/mixxx/features_spinny into lp:~mixxxdevelopers/mixxx/trunk

[Albert Santoni]

Spinning vinyl widget, and factors out GL context creation into its own class. Also makes the waveform grab used the _closed_ hand icon. :)

[RJ Skerry-Ryan (rryan)]

* In SharedGLContext, are a constructor / destructor necessary? I don't think anything creates an instance, just uses the static methods.

* Check for PathBackground / PathForeground / PathGhost actually existing?

* WPixmapStore::getPixmap can return NULL if the pixmap doesn't exist. All uses of the member-variable pixmaps should be checked for non-NULL first

* QElapsedTimer, while much better than QTime, means we are ditching any platform <Qt 4.7 (e.g. Ubuntu 10.04 and earlier). I think it's a bit early to do that -- maybe stick to QTime for now?

[RJ Skerry-Ryan (rryan)]

* Qt::MiddleButton isn't compatible with <Qt 4.7 either, use Qt::MidButton instead

[lp:~mixxxdevelopers/mixxx/features_spinny]

2775. By Albert Santoni on 2011-05-09

* Addressing RJ's code review:
    - Remove unnecessary SharedGLContext destructor (kept private constructor though).
    - Handle WSpinny math when track_samples or other params are NaN.
    - Protect all pixmap drawing in WSpinny against NULL pointers and pixmaps.
    - Fixes for Qt < 4.7 compatibility

[Albert Santoni (gamegod)]

k, fixed everything you pointed out in r2775 plus the ASSERTs Jus found when no tracks were loaded.

Thanks,
Albert

[lp:~mixxxdevelopers/mixxx/features_spinny]

2776. By Albert Santoni on 2011-05-09

Squash WSpinny compiler warnings and my leftover qDebugs (oops)

2777. By Albert Santoni on 2011-05-09

* Merged from trunk

[Owen Williams (ywwg)]

This widget will need to understand 33 vs 45 rpm record speeds and move the spinner at a higher speed if the record is set to 45RPM. Use [ChannelX],"vinylcontrol_speed_type", which is either "33.3 RPM" or "45 RPM".

Also, is the spinny thing guaranteed to show the same angle for the same sample index number? That's the important part :).

also, "roughly 0.5" is not acceptable. This value needs to be exact (5/9).

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/features_spinny]

2778. By Albert Santoni on 2011-05-11

Use exact 33.3 RPM rotational speed in WSpinny

[Albert Santoni (gamegod)]

Hey Owen,

I just jammed that fraction in there to make the rotation more precise.

The good news is that the spinny thing is guaranteed to show the same
angle for the same sample index.

The bad news is that I can't monitor for changes of that ConfigKey
because it's a ConfigKey and not a ControlObject. (ie. WSpinny can't
tell when the vinyl control speed preferences get changed.) In the
past, we've solved this problem by duplicating the ConfigKey's value
across to a ControlObject. For example, the [Master],"samplerate"
ControlObject just mirrors a ConfigKey that's hooked into the prefs. I
guess I'll have to fix this that way?

Thanks,
Albert

On Mon, May 9, 2011 at 7:18 AM, Owen Williams <email address hidden> wrote:
> Review: Needs Fixing
> This widget will need to understand 33 vs 45 rpm record speeds and move the spinner at a higher speed if the record is set to 45RPM.  Use [ChannelX],"vinylcontrol_speed_type", which is either "33.3 RPM" or "45 RPM".
>
> Also, is the spinny thing guaranteed to show the same angle for the same sample index number?  That's the important part :).
>
> also, "roughly 0.5" is not acceptable.  This value needs to be exact (5/9).
> --
> https://code.launchpad.net/~mixxxdevelopers/mixxx/features_spinny/+merge/60327
> Your team Mixxx Development Team is subscribed to branch lp:mixxx.
>

--
Albert Santoni
Developer, Mixxx
http://www.mixxx.org

[lp:~mixxxdevelopers/mixxx/features_spinny]

2779. By Albert Santoni on 2011-05-11

* WSpinny respects the vinyl control RPM setting now so it always matches your turntables' speed.
* Minor cleanup in DlgPrefVinyl.

[Albert Santoni (gamegod)]

Ok that all up in r2779. Should be good to go now and matches your vinyl control speed.

Albert

[Albert Santoni (gamegod)]

"Ok, *fixed* that all up in r2779.

> Ok that all up in r2779. Should be good to go now and matches your vinyl
> control speed.
>
> Albert

[RJ Skerry-Ryan (rryan)]

LGTM! thanks albert

review: Approve

[Owen Williams (ywwg)]

> The bad news is that I can't monitor for changes of that ConfigKey
> because it's a ConfigKey and not a ControlObject. (ie. WSpinny can't
> tell when the vinyl control speed preferences get changed.) In the
> past, we've solved this problem by duplicating the ConfigKey's value
> across to a ControlObject. For example, the [Master],"samplerate"
> ControlObject just mirrors a ConfigKey that's hooked into the prefs. I
> guess I'll have to fix this that way?

We can either do that, or I can add a function in vinylcontrolproxy like getSpeed() that returns 1.0 for 33rpm, and 1.35 for 45rpm

[Owen Williams (ywwg)]

Is there a skin / example xml that shows this widget in action? It looks like it wants a couple pixmaps

[RJ Skerry-Ryan (rryan)]

Jus is cooking up some examples -- my guess is they will show up in his 1.10
branch soon.

On Wed, May 11, 2011 at 2:09 PM, Owen Williams <email address hidden> wrote:

> Is there a skin / example xml that shows this widget in action? It looks
> like it wants a couple pixmaps
> --
>
> https://code.launchpad.net/~mixxxdevelopers/mixxx/features_spinny/+merge/60327
> You are reviewing the proposed merge of
> lp:~mixxxdevelopers/mixxx/features_spinny into lp:mixxx.
>

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-04-28 21:54:22 +0000
+++ mixxx/build/depends.py	2011-05-11 04:41:18 +0000
@@ -414,6 +414,7 @@
 
                    "soundsource.cpp",
 
+                   "sharedglcontext.cpp",
                    "widget/wwidget.cpp",
                    "widget/wlabel.cpp",
                    "widget/wtracktext.cpp",
@@ -428,6 +429,7 @@
                    "widget/wslider.cpp",
                    "widget/wstatuslight.cpp",
                    "widget/woverview.cpp",
+                   "widget/wspinny.cpp",
                    "widget/wskincolor.cpp",
                    "widget/wabstractcontrol.cpp",
                    "widget/wsearchlineedit.cpp",

=== modified file 'mixxx/src/dlgprefvinyl.cpp'
--- mixxx/src/dlgprefvinyl.cpp	2011-04-17 04:16:00 +0000
+++ mixxx/src/dlgprefvinyl.cpp	2011-05-11 04:41:18 +0000
@@ -30,7 +30,9 @@
 
 DlgPrefVinyl::DlgPrefVinyl(QWidget * parent, VinylControlManager *pVCMan,
                            ConfigObject<ConfigValue> * _config) : QWidget(parent), Ui::DlgPrefVinylDlg(),
-    m_COTMode(ControlObject::getControl(ConfigKey("[VinylControl]", "mode")))
+    m_COMode(ControlObject::getControl(ConfigKey("[VinylControl]", "mode"))),
+    m_COSpeed1(ControlObject::getControl(ConfigKey("[Channel1]", "vinylcontrol_speed_type"))),
+    m_COSpeed2(ControlObject::getControl(ConfigKey("[Channel2]", "vinylcontrol_speed_type")))
 {
     m_pVCManager = pVCMan;
     config = _config;
@@ -177,7 +179,7 @@
 
     ControlObject::getControl(ConfigKey("[Channel1]", "vinylcontrol_mode"))->set(iMode);
     ControlObject::getControl(ConfigKey("[Channel2]", "vinylcontrol_mode"))->set(iMode);
-    m_COTMode.slotSet(iMode);
+    m_COMode.slotSet(iMode);
     config->set(ConfigKey("[VinylControl]","mode"), ConfigValue(iMode));
     config->set(ConfigKey("[VinylControl]","needle_skip_prevention" ), ConfigValue( (int)(NeedleSkipEnable->isChecked( )) ) );
 
@@ -196,6 +198,19 @@
     config->set(ConfigKey("[Channel2]","vinylcontrol_vinyl_type"), ConfigValue(ComboBoxVinylType2->currentText()));
     config->set(ConfigKey("[Channel1]","vinylcontrol_speed_type"), ConfigValue(ComboBoxVinylSpeed1->currentText()));
     config->set(ConfigKey("[Channel2]","vinylcontrol_speed_type"), ConfigValue(ComboBoxVinylSpeed2->currentText()));
+    
+    //Save the vinylcontrol_speed_type in ControlObjects as well so it can be retrieved quickly
+    //on the fly. (eg. WSpinny needs to know how fast to spin)
+    if (ComboBoxVinylSpeed1->currentText() == MIXXX_VINYL_SPEED_33) {
+        m_COSpeed1.slotSet(MIXXX_VINYL_SPEED_33_NUM);
+    } else if (ComboBoxVinylSpeed1->currentText() == MIXXX_VINYL_SPEED_45) {
+        m_COSpeed1.slotSet(MIXXX_VINYL_SPEED_45_NUM);
+    }
+    if (ComboBoxVinylSpeed2->currentText() == MIXXX_VINYL_SPEED_33) {
+        m_COSpeed2.slotSet(MIXXX_VINYL_SPEED_33_NUM);
+    } else if (ComboBoxVinylSpeed2->currentText() == MIXXX_VINYL_SPEED_45) {
+        m_COSpeed2.slotSet(MIXXX_VINYL_SPEED_45_NUM);
+    }
 }
 
 void DlgPrefVinyl::VinylGainSlotApply()

=== modified file 'mixxx/src/dlgprefvinyl.h'
--- mixxx/src/dlgprefvinyl.h	2011-04-17 04:16:00 +0000
+++ mixxx/src/dlgprefvinyl.h	2011-05-11 04:41:18 +0000
@@ -21,7 +21,7 @@
 #include "ui_dlgprefvinyldlg.h"
 #include "configobject.h"
 #include "vinylcontrol/vinylcontrolsignalwidget.h"
-#include "controlobjectthread.h"
+#include "controlobjectthreadmain.h"
 
 class QWidget;
 class PlayerProxy;
@@ -61,14 +61,9 @@
     VinylControlManager* m_pVCManager;
     /** Pointer to config object */
     ConfigObject<ConfigValue> *config;
-    /** Indicates the strength of the timecode signal on each input */
-    ControlObjectThreadMain* m_timecodeQuality1;
-    ControlObjectThreadMain* m_timecodeQuality2;
-    ControlObjectThreadMain* m_vinylControlInput1L;
-    ControlObjectThreadMain* m_vinylControlInput1R;
-    ControlObjectThreadMain* m_vinylControlInput2L;
-    ControlObjectThreadMain* m_vinylControlInput2R;
-    ControlObjectThread m_COTMode;
+    ControlObjectThreadMain m_COMode;
+    ControlObjectThreadMain m_COSpeed1;
+    ControlObjectThreadMain m_COSpeed2;
 };
 
 #endif

=== modified file 'mixxx/src/engine/positionscratchcontroller.cpp'
--- mixxx/src/engine/positionscratchcontroller.cpp	2011-04-26 23:57:28 +0000
+++ mixxx/src/engine/positionscratchcontroller.cpp	2011-05-11 04:41:18 +0000
@@ -113,6 +113,7 @@
     m_bScratching = false;
     m_iScratchTime = 0;
     m_bEnableInertia = false;
+    m_dRate = 0.;
 
     //m_pVelocityController->setPID(0.2, 1.0, 5.0);
     //m_pVelocityController->setPID(0.1, 0.0, 5.0);

=== modified file 'mixxx/src/engine/vinylcontrolcontrol.cpp'
--- mixxx/src/engine/vinylcontrolcontrol.cpp	2011-04-19 14:03:57 +0000
+++ mixxx/src/engine/vinylcontrolcontrol.cpp	2011-05-11 04:41:18 +0000
@@ -6,6 +6,19 @@
 VinylControlControl::VinylControlControl(const char* pGroup, ConfigObject<ConfigValue>* pConfig)
         : EngineControl(pGroup, pConfig) {
     m_pControlVinylStatus = new ControlObject(ConfigKey(pGroup, "vinylcontrol_status"));
+    m_pControlVinylSpeedType = new ControlObject(ConfigKey(pGroup, "vinylcontrol_speed_type"));
+
+    //Convert the ConfigKey's value into a double for the CO (for fast reads).
+    QString strVinylSpeedType = pConfig->getValueString(ConfigKey(pGroup,
+                                                      "vinylcontrol_speed_type"));
+    if (strVinylSpeedType == MIXXX_VINYL_SPEED_33) {
+        m_pControlVinylSpeedType->set(MIXXX_VINYL_SPEED_33_NUM);
+    } else if (strVinylSpeedType == MIXXX_VINYL_SPEED_45) {
+        m_pControlVinylSpeedType->set(MIXXX_VINYL_SPEED_45_NUM);
+    } else {
+        m_pControlVinylSpeedType->set(MIXXX_VINYL_SPEED_33_NUM);
+    }
+
     m_pControlVinylSeek = new ControlObject(ConfigKey(pGroup, "vinylcontrol_seek"));
     connect(m_pControlVinylSeek, SIGNAL(valueChanged(double)),
             this, SLOT(slotControlVinylSeek(double)),

=== modified file 'mixxx/src/engine/vinylcontrolcontrol.h'
--- mixxx/src/engine/vinylcontrolcontrol.h	2011-04-17 02:42:45 +0000
+++ mixxx/src/engine/vinylcontrolcontrol.h	2011-05-11 04:41:18 +0000
@@ -21,6 +21,7 @@
 
   private:
     ControlObject* m_pControlVinylSeek;
+    ControlObject* m_pControlVinylSpeedType;
     ControlObject* m_pControlVinylStatus;
     ControlPushButton* m_pControlVinylMode;
     ControlPushButton* m_pControlVinylEnabled;

=== modified file 'mixxx/src/mathstuff.h'
--- mixxx/src/mathstuff.h	2010-11-27 03:10:36 +0000
+++ mixxx/src/mathstuff.h	2011-05-11 04:41:18 +0000
@@ -23,7 +23,6 @@
 #include <math.h>
 #include <algorithm>
 
-static CSAMPLE two_pi = (2.f*acos(-1.f));
 
 CSAMPLE besseli(CSAMPLE);
 int sign(CSAMPLE);
@@ -44,6 +43,7 @@
 float sigmoid_zero(double t, double max_t);
 
 static CSAMPLE pi     = acos(-1.0f);
+static CSAMPLE two_pi = (2.f*acos(-1.f));
 
 #ifdef _MSC_VER
 #include <float.h>  // for _isnan() on VC++

=== added file 'mixxx/src/sharedglcontext.cpp'
--- mixxx/src/sharedglcontext.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/sharedglcontext.cpp	2011-05-11 04:41:18 +0000
@@ -0,0 +1,23 @@
+#include <QGLContext>
+#include <QGLFormat>
+#include "sharedglcontext.h"
+
+/** Singleton wrapper around QGLContext */
+
+QGLContext* SharedGLContext::s_pSharedGLContext = (QGLContext*)NULL;
+
+QGLContext* SharedGLContext::getContext()
+{
+    QGLContext *ctxt;
+    
+    if (s_pSharedGLContext == (QGLContext*)NULL) {
+        s_pSharedGLContext = new QGLContext(QGLFormat(QGL::SampleBuffers));
+        s_pSharedGLContext->create();
+        s_pSharedGLContext->makeCurrent();
+    }
+    
+    ctxt = new QGLContext(QGLFormat(QGL::SampleBuffers));
+    ctxt->create(s_pSharedGLContext);
+
+    return ctxt;
+}

=== added file 'mixxx/src/sharedglcontext.h'
--- mixxx/src/sharedglcontext.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/sharedglcontext.h	2011-05-11 04:41:18 +0000
@@ -0,0 +1,15 @@
+#ifndef SHAREDGLCONTEXT_H_
+#define SHAREDGLCONTEXT_H_
+
+class QGLContext;
+
+class SharedGLContext 
+{
+    public:
+        static QGLContext* getContext();
+    private:
+        SharedGLContext() { };
+        static QGLContext* s_pSharedGLContext;
+};
+
+#endif //SHAREDGLCONTEXT_H_

=== modified file 'mixxx/src/skin/legacyskinparser.cpp'
--- mixxx/src/skin/legacyskinparser.cpp	2011-04-24 06:00:11 +0000
+++ mixxx/src/skin/legacyskinparser.cpp	2011-05-11 04:41:18 +0000
@@ -39,6 +39,7 @@
 #include "widget/wnumberpos.h"
 #include "widget/wnumberrate.h"
 #include "widget/woverview.h"
+#include "widget/wspinny.h"
 
 #include "widget/wvisualsimple.h"
 #include "widget/wglwaveformviewer.h"
@@ -264,6 +265,8 @@
         return parseWidgetGroup(node);
     } else if (nodeName == "Style") {
         return parseStyle(node);
+    } else if (nodeName == "Spinny") {
+        return parseSpinny(node);
     } else {
         qDebug() << "Invalid node name in skin:" << nodeName;
     }
@@ -605,6 +608,22 @@
     return p;
 }
 
+QWidget* LegacySkinParser::parseSpinny(QDomElement node) {
+    QString channelStr = lookupNodeGroup(node);
+    const char* pSafeChannelStr = safeChannelString(channelStr);
+    WSpinny* p = new WSpinny(m_pParent);
+    setupWidget(node, p);
+
+    connect(p, SIGNAL(trackDropped(QString, QString)),
+            m_pPlayerManager, SLOT(slotLoadToPlayer(QString, QString)));
+
+    p->setup(node, pSafeChannelStr);
+    setupConnections(node, p);
+    p->installEventFilter(m_pKeyboard);
+    return p;
+}
+
+
 QWidget* LegacySkinParser::parseTableView(QDomElement node) {
     QStackedWidget* pTabWidget = new QStackedWidget(m_pParent);
 

=== modified file 'mixxx/src/skin/legacyskinparser.h'
--- mixxx/src/skin/legacyskinparser.h	2011-03-26 02:04:46 +0000
+++ mixxx/src/skin/legacyskinparser.h	2011-05-11 04:41:18 +0000
@@ -59,6 +59,7 @@
     QWidget* parseKnob(QDomElement node);
     QWidget* parseTableView(QDomElement node);
     QWidget* parseStyle(QDomElement node);
+    QWidget* parseSpinny(QDomElement node);
 
     void setupPosition(QDomNode node, QWidget* pWidget);
     void setupSize(QDomNode node, QWidget* pWidget);

=== modified file 'mixxx/src/vinylcontrol/vinylcontrol.h'
--- mixxx/src/vinylcontrol/vinylcontrol.h	2011-04-17 04:16:00 +0000
+++ mixxx/src/vinylcontrol/vinylcontrol.h	2011-05-11 04:41:18 +0000
@@ -21,6 +21,9 @@
 #define MIXXX_VINYL_SPEED_33 "33.3 RPM"
 #define MIXXX_VINYL_SPEED_45 "45 RPM"
 
+#define MIXXX_VINYL_SPEED_33_NUM 33.3f 
+#define MIXXX_VINYL_SPEED_45_NUM 45.0f 
+
 #define MIXXX_VCMODE_ABSOLUTE 0
 #define MIXXX_VCMODE_RELATIVE 1
 #define MIXXX_VCMODE_CONSTANT  2

=== modified file 'mixxx/src/waveformviewerfactory.cpp'
--- mixxx/src/waveformviewerfactory.cpp	2011-01-14 09:50:57 +0000
+++ mixxx/src/waveformviewerfactory.cpp	2011-05-11 04:41:18 +0000
@@ -5,6 +5,7 @@
 
 #include "configobject.h"
 #include "waveformviewerfactory.h"
+#include "sharedglcontext.h"
 
 #include "waveform/waveformrenderer.h"
 #include "widget/wvisualsimple.h"
@@ -17,21 +18,11 @@
 QList<WWaveformViewer*> WaveformViewerFactory::m_visualViewers = QList<WWaveformViewer*>();
 QList<WGLWaveformViewer*> WaveformViewerFactory::m_visualGLViewers = QList<WGLWaveformViewer*>();
 QTimer WaveformViewerFactory::s_waveformUpdateTimer;;
-QGLContext* WaveformViewerFactory::s_pSharedOGLCtxt = (QGLContext *)NULL;
 
 
 WaveformViewerType WaveformViewerFactory::createWaveformViewer(const char *group, QWidget *parent, ConfigObject<ConfigValue> *pConfig, QWidget **target, WaveformRenderer* pWaveformRenderer) {
     
-    QGLContext *ctxt;
-    
-    if ( s_pSharedOGLCtxt == (QGLContext*)NULL ) {
-        s_pSharedOGLCtxt = new QGLContext(QGLFormat(QGL::SampleBuffers));
-        s_pSharedOGLCtxt->create();
-        s_pSharedOGLCtxt->makeCurrent();
-    }
-    
-    ctxt = new QGLContext(QGLFormat(QGL::SampleBuffers));
-    ctxt->create(s_pSharedOGLCtxt);
+    QGLContext* ctxt = SharedGLContext::getContext();
 
     qDebug() << "createWaveformViewer()";
 

=== modified file 'mixxx/src/waveformviewerfactory.h'
--- mixxx/src/waveformviewerfactory.h	2011-01-14 09:32:49 +0000
+++ mixxx/src/waveformviewerfactory.h	2011-05-11 04:41:18 +0000
@@ -34,7 +34,6 @@
     static QList<WWaveformViewer*> m_visualViewers;
     static QList<WGLWaveformViewer*> m_visualGLViewers;
     static QTimer s_waveformUpdateTimer;
-    static QGLContext *s_pSharedOGLCtxt;
 
 public:
     static WaveformViewerType createWaveformViewer(const char* group, QWidget *pParent, ConfigObject<ConfigValue> *pConfig, QWidget **target, WaveformRenderer *pWaveformRenderer);

=== modified file 'mixxx/src/widget/wglwaveformviewer.cpp'
--- mixxx/src/widget/wglwaveformviewer.cpp	2011-04-26 02:43:58 +0000
+++ mixxx/src/widget/wglwaveformviewer.cpp	2011-05-11 04:41:18 +0000
@@ -13,6 +13,7 @@
 #include "wglwaveformviewer.h"
 #include "waveform/waveformrenderer.h"
 #include "controlobjectthreadmain.h"
+#include "sharedglcontext.h"
 
 WGLWaveformViewer::WGLWaveformViewer(
         const char *group,
@@ -24,7 +25,6 @@
     ) :
     QGLWidget(ctxt, pParent, pShareWidget)
 {
-
     m_pWaveformRenderer = pWaveformRenderer;
     Q_ASSERT(m_pWaveformRenderer);
 
@@ -46,6 +46,9 @@
     installEventFilter(this);
 
     m_painting = false;
+
+    setSizePolicy(QSizePolicy::MinimumExpanding,
+                  QSizePolicy::MinimumExpanding);
 }
 
 bool WGLWaveformViewer::directRendering()
@@ -63,6 +66,14 @@
     m_pWaveformRenderer->resize(w, h);
 }
 
+void WGLWaveformViewer::resizeEvent(QResizeEvent* e)
+{
+    const QSize newSize = e->size();
+    m_pWaveformRenderer->resize(newSize.width(),
+                                newSize.height());
+}
+
+
 void WGLWaveformViewer::paintEvent(QPaintEvent *event) {
     QPainter painter;
     painter.begin(this);
@@ -110,7 +121,7 @@
             //qDebug() << "m_dInitialPlaypos" << m_dInitialPlaypos;
 
             // Set the cursor to a hand while the mouse is down.
-            setCursor(Qt::OpenHandCursor);
+            setCursor(Qt::ClosedHandCursor);
         }
     } else if(e->type() == QEvent::MouseMove) {
         // Only send signals for mouse moving if the left button is pressed

=== modified file 'mixxx/src/widget/wglwaveformviewer.h'
--- mixxx/src/widget/wglwaveformviewer.h	2011-04-26 02:30:22 +0000
+++ mixxx/src/widget/wglwaveformviewer.h	2011-05-11 04:41:18 +0000
@@ -47,6 +47,7 @@
 
   protected:
     void paintEvent(QPaintEvent* event);
+    void resizeEvent(QResizeEvent* e);
 
   private:
     /** Used in mouse event handler */

=== added file 'mixxx/src/widget/wspinny.cpp'
--- mixxx/src/widget/wspinny.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/widget/wspinny.cpp	2011-05-11 04:41:18 +0000
@@ -0,0 +1,434 @@
+#include <math.h>
+#include "mathstuff.h"
+#include "wpixmapstore.h"
+#include "controlobject.h"
+#include "controlobjectthreadmain.h"
+#include "sharedglcontext.h"
+#include "wspinny.h"
+
+WSpinny::WSpinny(QWidget* parent) : QGLWidget(SharedGLContext::getContext(), parent),
+    m_pBG(NULL), 
+    m_pFG(NULL),
+    m_pGhost(NULL),
+    m_pPlay(NULL),
+    m_pPlayPos(NULL),
+    m_pVisualPlayPos(NULL),
+    m_pDuration(NULL),
+    m_pTrackSamples(NULL),
+    m_pBPM(NULL),
+    m_pScratch(NULL),
+    m_pScratchToggle(NULL),
+    m_pScratchPos(NULL),
+    m_pVinylControlSpeedType(NULL),
+    m_fAngle(0.0f),
+    m_fGhostAngle(0.0f),
+    m_dPausedPosition(0.0f),
+    m_bGhostPlayback(false),
+    m_iStartMouseX(-1),
+    m_iStartMouseY(-1),
+    m_iFullRotations(0),
+    m_dPrevTheta(0.)
+{
+    //Drag and drop
+    setAcceptDrops(true);
+}
+
+WSpinny::~WSpinny()
+{
+    //Don't delete these because the pixmap store takes care of them.
+    //delete m_pBG;
+    //delete m_pFG;
+    //delete m_pGhost;
+    WPixmapStore::deletePixmap(m_pBG);
+    WPixmapStore::deletePixmap(m_pFG);
+    WPixmapStore::deletePixmap(m_pGhost);
+    delete m_pPlay;
+    delete m_pPlayPos;
+    delete m_pVisualPlayPos;
+    delete m_pDuration;
+    delete m_pTrackSamples;
+    delete m_pTrackSampleRate;
+    delete m_pBPM;
+    delete m_pScratch;
+    delete m_pScratchToggle;
+    delete m_pScratchPos;
+    delete m_pVinylControlSpeedType;
+}
+
+void WSpinny::setup(QDomNode node, QString group)
+{
+    m_group = group;
+
+    // Set pixmaps
+    m_pBG = WPixmapStore::getPixmap(WWidget::getPath(WWidget::selectNodeQString(node, 
+                                                    "PathBackground")));
+    m_pFG = WPixmapStore::getPixmap(WWidget::getPath(WWidget::selectNodeQString(node, 
+                                                    "PathForeground")));
+    m_pGhost = WPixmapStore::getPixmap(WWidget::getPath(WWidget::selectNodeQString(node, 
+                                                    "PathGhost")));
+    if (m_pBG && !m_pBG->isNull()) {
+        setFixedSize(m_pBG->size());
+    }
+
+    m_pPlay = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "play")));
+    m_pPlayPos = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "playposition")));
+    m_pVisualPlayPos = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "visual_playposition")));
+    m_pDuration = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "duration")));
+    m_pTrackSamples = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "track_samples")));
+    m_pTrackSampleRate = new ControlObjectThreadMain(
+                                    ControlObject::getControl(
+                                    ConfigKey(group, "track_samplerate")));
+    m_pBPM = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "bpm")));
+
+    m_pScratch = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "scratch2")));
+    m_pScratchToggle = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "scratch_position_enable")));
+    m_pScratchPos = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "scratch_position")));
+    m_pVinylControlSpeedType = new ControlObjectThreadMain(ControlObject::getControl(
+                        ConfigKey(group, "vinylcontrol_speed_type")));
+    if (m_pVinylControlSpeedType)
+    {
+        //Initialize the rotational speed.
+        this->updateVinylControlSpeed(m_pVinylControlSpeedType->get());
+    }
+    Q_ASSERT(m_pPlayPos);
+    Q_ASSERT(m_pDuration);
+
+    //Repaint when visual_playposition changes.
+    connect(m_pVisualPlayPos, SIGNAL(valueChanged(double)),
+            this, SLOT(updateAngle(double)));
+
+    //Match the vinyl control's set RPM so that the spinny widget rotates at the same 
+    //speed as your physical decks, if you're using vinyl control.
+    connect(m_pVinylControlSpeedType, SIGNAL(valueChanged(double)),
+            this, SLOT(updateVinylControlSpeed(double)));
+}
+
+void WSpinny::paintEvent(QPaintEvent *e)
+{
+    Q_UNUSED(e); //ditch unused param warning
+
+    QPainter p(this);
+    
+    if (m_pBG) {
+        p.drawPixmap(0, 0, *m_pBG);
+    }
+
+    //To rotate the foreground pixmap around the center of the image,
+    //we use the classic trick of translating the coordinate system such that
+    //the origin is at the center of the image. We then rotate the coordinate system,
+    //and draw the pixmap at the corner.
+    p.translate(width() / 2, height() / 2);
+
+    if (m_bGhostPlayback)
+        p.save();
+
+    if (m_pFG && !m_pFG->isNull()) {
+        //Now rotate the pixmap and draw it on the screen.
+        p.rotate(m_fAngle);
+        p.drawPixmap(-(width() / 2), -(height() / 2), *m_pFG);
+    }
+    
+    if (m_bGhostPlayback && m_pGhost && !m_pGhost->isNull())
+    {
+        p.restore();
+        p.save();
+        p.rotate(m_fGhostAngle);
+        p.drawPixmap(-(width() / 2), -(height() / 2), *m_pGhost);
+
+        //Rotate back to the playback position (not the ghost positon), 
+        //and draw the beat marks from there.
+        p.restore();
+
+        /*
+        //Draw a line where the next 4 beats are 
+        double bpm = m_pBPM->get();
+        double duration = m_pDuration->get();
+        if (bpm <= 0. || duration <= 0.) {
+            return; //Prevent div by zero
+        }
+        double beatLengthInSec = 60. / bpm;
+        double beatLengthNormalized = beatLengthInSec / duration; //Noramlized to duration
+        double beatAngle = calculateAngle(beatLengthNormalized);
+        //qDebug() << "beatAngle:" << beatAngle;
+        //qDebug() << "beatLenInSec:" << beatLengthInSec << "norm:" << beatLengthNormalized;
+        p.rotate(m_fAngle);
+        for (int i = 0; i < 4; i++) {
+            QLineF beatLine(-(width()*0.6 / 2), -(height()*0.6 / 2),
+                            -(width()*0.8 / 2), -(height()*0.8 / 2));
+            //p.drawPoint(-(width()*0.5 / 2), -(height()*0.5 / 2));
+            p.drawLine(beatLine);
+            p.rotate(beatAngle);
+        } */
+    }
+}
+
+/* Convert between a normalized playback position (0.0 - 1.0) and an angle
+   in our polar coordinate system.
+   Returns an angle clamped between -180 and 180 degrees. */
+double WSpinny::calculateAngle(double playpos)
+{
+    if (isnan(playpos))
+        return 0.0f;
+
+    //Convert playpos to seconds.
+    //double t = playpos * m_pDuration->get();
+    double t = playpos * (m_pTrackSamples->get()/2 /  // Stereo audio!
+                          m_pTrackSampleRate->get());
+
+    if (isnan(t)) //Bad samplerate or number of track samples.
+        return 0.0f;
+
+    //33 RPM is approx. 0.5 rotations per second.
+    double angle = 360*m_dRotationsPerSecond*t;
+    //Clamp within -180 and 180 degrees
+    //qDebug() << "pc:" << angle;
+    //angle = ((angle + 180) % 360.) - 180;
+    //modulo for doubles :)
+    if (angle > 0)
+    {
+        int x = (angle+180)/360;
+        angle = angle - (360*x);
+    } else 
+    {
+        int x = (angle-180)/360;
+        angle = angle - (360*x);
+    }
+
+    Q_ASSERT(angle <= 180 && angle >= -180);
+    return angle; 
+}
+
+/** Given a normalized playpos, calculate the integer number of rotations
+    that it would take to wind the vinyl to that position. */
+int WSpinny::calculateFullRotations(double playpos)
+{
+    if (isnan(playpos))
+        return 0.0f;
+    //Convert playpos to seconds.
+    //double t = playpos * m_pDuration->get();
+    double t = playpos * (m_pTrackSamples->get()/2 /  // Stereo audio!
+                          m_pTrackSampleRate->get());
+
+    //33 RPM is approx. 0.5 rotations per second.
+    //qDebug() << t;
+    double angle = 360*m_dRotationsPerSecond*t;
+
+    return (((int)angle+180) / 360);
+}
+
+//Inverse of calculateAngle()
+double WSpinny::calculatePositionFromAngle(double angle)
+{
+    if (isnan(angle))
+        return 0.0f;
+
+    //33 RPM is approx. 0.5 rotations per second.
+    double t = angle/(360*m_dRotationsPerSecond); //time in seconds
+
+    //Convert t from seconds into a normalized playposition value.
+    //double playpos = t / m_pDuration->get();
+    double playpos = t / (m_pTrackSamples->get()/2 /  // Stereo audio!
+                          m_pTrackSampleRate->get());
+    return playpos; 
+}
+
+/** Update the playback angle saved in the widget and repaint.
+    @param playpos A normalized (0.0-1.0) playback position. (Not an angle!)
+*/
+void WSpinny::updateAngle(double playpos)
+{
+    m_fAngle = calculateAngle(playpos);
+    update();
+}
+
+//Update the angle using the ghost playback position. 
+void WSpinny::updateAngleForGhost()
+{
+    qint64 elapsed = m_time.elapsed();
+    double duration = m_pDuration->get();
+    double newPlayPos = m_dPausedPosition + 
+                         (((double)elapsed)/1000.)/duration;
+    m_fGhostAngle = calculateAngle(newPlayPos);
+    update();
+}
+
+void WSpinny::updateVinylControlSpeed(double rpm)
+{
+    m_dRotationsPerSecond = rpm/60.;
+}
+
+void WSpinny::mouseMoveEvent(QMouseEvent * e)
+{
+    int y = e->y();
+    int x = e->x();
+
+    //Keeping these around in case we want to switch to control relative
+    //to the original mouse position.
+    //int dX = x-m_iStartMouseX;
+    //int dY = y-m_iStartMouseY;
+
+    //Coordinates from center of widget
+    int c_x = x - width()/2;
+    int c_y = y - height()/2;
+    double theta = (180.0f/M_PI)*atan2(c_x, -c_y);
+
+    //qDebug() << "c_x:" << c_x << "c_y:" << c_y << 
+    //            "dX:" << dX << "dY:" << dY;
+
+    //When we finish one full rotation (clockwise or anticlockwise), 
+    //we'll need to manually add/sub 360 degrees because atan2()'s range is
+    //only within -180 to 180 degrees. We need a wider range so your position
+    //in the song can be tracked.
+    if (m_dPrevTheta > 100 && theta < 0) {
+        m_iFullRotations++;
+    }
+    else if (m_dPrevTheta < -100 && theta > 0) {
+        m_iFullRotations--;
+    }
+
+    m_dPrevTheta = theta;
+    theta += m_iFullRotations*360;
+   
+    //qDebug() << "c t:" << theta << "pt:" << m_dPrevTheta << 
+    //            "icr" << m_iFullRotations;
+
+    if (e->buttons() & Qt::LeftButton)
+    {
+        //Convert deltaTheta into a percentage of song length.
+        double absPos = calculatePositionFromAngle(theta);
+
+        double absPosInSamples = absPos * m_pTrackSamples->get();
+        m_pScratchPos->slotSet(absPosInSamples);
+    }
+    else if (e->buttons() & Qt::MidButton)
+    {
+    }
+    else if (e->buttons() & Qt::NoButton)
+    {
+        setCursor(QCursor(Qt::OpenHandCursor));
+    }
+}
+
+void WSpinny::mousePressEvent(QMouseEvent * e)
+{
+    int y = e->y();
+    int x = e->x();
+
+    m_iStartMouseX = x;
+    m_iStartMouseY = y;
+
+    if (e->button() == Qt::LeftButton)
+    {
+        QApplication::setOverrideCursor(QCursor(Qt::ClosedHandCursor));
+
+        double initialPosInSamples = m_pPlayPos->get() * m_pTrackSamples->get();
+        m_pScratchPos->slotSet(initialPosInSamples);
+        m_pScratchToggle->slotSet(1.0f);
+
+        m_iFullRotations = calculateFullRotations(m_pPlayPos->get());
+
+        m_dPrevTheta = calculateAngle(m_pPlayPos->get());
+
+        //Trigger a mouse move to immediately line up the vinyl with the cursor
+        mouseMoveEvent(e);
+    }
+    else if (e->button() == Qt::MidButton)
+    {
+    }
+    else if (e->button() == Qt::RightButton)
+    {
+        //Stop playback and start the timer for ghost playback
+        m_time.start();
+        m_dPausedPosition = m_pPlayPos->get();
+        updateAngleForGhost(); //Need to recalc the ghost angle right away
+        m_bGhostPlayback = true;
+        m_ghostPaintTimer.start(30);
+        connect(&m_ghostPaintTimer, SIGNAL(timeout()), 
+                this, SLOT(updateAngleForGhost()));
+
+        //TODO: Ramp down (brake) over a period of 1 beat 
+        //      instead? Would be sweet.
+        m_pPlay->slotSet(0.0f);
+    }
+}
+
+void WSpinny::mouseReleaseEvent(QMouseEvent * e)
+{
+    if (e->button() == Qt::LeftButton)
+    {
+        QApplication::restoreOverrideCursor();
+        m_pScratchToggle->slotSet(0.0f);
+        m_iFullRotations = 0;
+    }
+    else if (e->button() == Qt::RightButton)
+    {
+        //Start playback by jumping forwards in the song as if playback 
+        //was never paused. (useful for bleeping or adding silence breaks)
+        qint64 elapsed = m_time.elapsed();
+        //qDebug() << "elapsed:" << elapsed;
+        m_ghostPaintTimer.stop();
+        m_bGhostPlayback = false;
+
+        //Convert elapsed to seconds, then normalize it to the duration so we can
+        //move the playback position ahead by the elapsed amount.
+        double duration = m_pDuration->get();
+        double newPlayPos = m_dPausedPosition + (((double)elapsed)/1000.)/duration;
+        //qDebug() << m_dPausedPosition << newPlayPos; 
+        m_pPlay->slotSet(1.0f);
+        m_pPlayPos->slotSet(newPlayPos);
+        //m_bRightButtonPressed = true;
+    }
+}
+
+void WSpinny::wheelEvent(QWheelEvent *e)
+{
+    Q_UNUSED(e); //ditch unused param warning
+
+    /*
+    double wheelDirection = ((QWheelEvent *)e)->delta() / 120.;
+    double newValue = getValue() + (wheelDirection);
+    this->updateValue(newValue);
+
+    e->accept();
+    */
+}
+
+/** DRAG AND DROP **/
+void WSpinny::dragEnterEvent(QDragEnterEvent * event)
+{
+    // Accept the enter event if the thing is a filepath and nothing's playing
+    // in this deck.
+    if (event->mimeData()->hasUrls()) {
+        if (m_pPlay && m_pPlay->get()) {
+            event->ignore();
+        } else {
+            event->acceptProposedAction();
+        }
+    }
+}
+
+void WSpinny::dropEvent(QDropEvent * event)
+{
+    if (event->mimeData()->hasUrls()) {
+        QList<QUrl> urls(event->mimeData()->urls());
+        QUrl url = urls.first();
+        QString name = url.toLocalFile();
+        //If the file is on a network share, try just converting the URL to a string...
+        if (name == "")
+            name = url.toString();
+
+        event->accept();
+        emit(trackDropped(name, m_group));
+    } else {
+        event->ignore();
+    }
+}

=== added file 'mixxx/src/widget/wspinny.h'
--- mixxx/src/widget/wspinny.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/widget/wspinny.h	2011-05-11 04:41:18 +0000
@@ -0,0 +1,67 @@
+
+#ifndef _WSPINNY_H
+#define _WSPINNY_H
+
+#include <QGLWidget>
+#include "wwidget.h"
+
+class ControlObjectThreadMain;
+
+class WSpinny : public QGLWidget
+{
+    Q_OBJECT
+    public:
+        WSpinny(QWidget* parent);
+        ~WSpinny();
+        void setup(QDomNode node, QString group);
+        void dragEnterEvent(QDragEnterEvent *event);
+        void dropEvent(QDropEvent *event);
+    public slots:
+        void updateAngle(double);
+        void updateAngleForGhost();
+        void updateVinylControlSpeed(double rpm);
+    signals:
+        void trackDropped(QString filename, QString group);
+    protected:
+        //QWidget:
+        void paintEvent(QPaintEvent*);
+        void mouseMoveEvent(QMouseEvent * e);
+        void mousePressEvent(QMouseEvent * e);
+        void mouseReleaseEvent(QMouseEvent * e);
+        void wheelEvent(QWheelEvent *e);
+
+        double calculateAngle(double playpos);
+        int calculateFullRotations(double playpos);
+        double calculatePositionFromAngle(double angle);
+    private:
+        QPixmap* m_pBG;
+        QPixmap* m_pFG;
+        QPixmap* m_pGhost;
+        ControlObjectThreadMain* m_pPlay;
+        ControlObjectThreadMain* m_pPlayPos;
+        ControlObjectThreadMain* m_pVisualPlayPos;
+        ControlObjectThreadMain* m_pDuration;
+        ControlObjectThreadMain* m_pTrackSamples;
+        ControlObjectThreadMain* m_pTrackSampleRate;
+        ControlObjectThreadMain* m_pBPM;
+        ControlObjectThreadMain* m_pScratch;
+        ControlObjectThreadMain* m_pScratchToggle;
+        ControlObjectThreadMain* m_pScratchPos;
+        ControlObjectThreadMain* m_pVinylControlSpeedType;
+        QString m_group;
+        float m_fAngle; //Degrees
+        float m_fGhostAngle; 
+        QTime m_time;
+        double m_dPausedPosition;
+        bool m_bGhostPlayback;
+        QTimer m_ghostPaintTimer;
+        int m_iStartMouseX;
+        int m_iStartMouseY;
+        int m_iFullRotations;
+        double m_dPrevTheta;
+        double m_dTheta;
+        /** Speed of the vinyl rotation. */
+        double m_dRotationsPerSecond;
+};
+
+#endif //_WSPINNY_H