src/analyzers/analyzerbase.h

   1 // Maintainer: Max Howell <max.howell@methylblue.com>, (C) 2004
   2 // Copyright:  See COPYING file that comes with this distribution
   3
   4 #ifndef ANALYZERBASE_H
   5 #define ANALYZERBASE_H
   6
   7
   8 #include "config-amarok.h"  //HAVE_QGLWIDGET
   9
  10 #ifdef __FreeBSD__
  11 #include <sys/types.h>
  12 #endif
  13
  14 #include "fht.h"     //stack allocated and convenience
  15 #include <QPixmap> //stack allocated and convenience
  16 #include <QTimer>  //stack allocated
  17 #include <qwidget.h> //baseclass
  18 //Added by qt3to4:
  19 #include <QResizeEvent>
  20 #include <QEvent>
  21 #include <QPaintEvent>
  22 #include <vector>    //included for convenience
  23
  24 #ifdef HAVE_QGLWIDGET
  25 #include <qgl.h>     //baseclass
  26 #ifdef Q_WS_MACX
  27 #include <OpenGL/gl.h>   //included for convenience
  28 #include <OpenGL/glu.h>  //included for convenience
  29 #else
  30 #include <GL/gl.h>   //included for convenience
  31 #include <GL/glu.h>  //included for convenience
  32 #endif
  33 #else
  34 //this is a workaround for compile problems due to moc
  35 #define QGLWidget QWidget
  36 #endif
  37
  38 #include <qimage.h> //for bitBlt
  39
  40 class QEvent;
  41 class QPaintEvent;
  42 class QResizeEvent;
  43
  44
  45 namespace Analyzer {
  46
  47 typedef std::vector<float> Scope;
  48
  49 template<class W> class Base : public W
  50 {
  51 public:
  52     uint timeout() const { return m_timeout; }
  53
  54 protected:
  55     Base( QWidget*, uint, uint = 7 );
  56     ~Base() { delete m_fht; }
  57
  58     void drawFrame();
  59     int  resizeExponent( int );
  60     int  resizeForBands( int );
  61     virtual void transform( Scope& );
  62     virtual void analyze( const Scope& ) = 0;
  63     virtual void paused();
  64     virtual void demo();
  65
  66     void changeTimeout( uint newTimeout )
  67     {
  68         m_timer.start( newTimeout );
  69         m_timeout = newTimeout;
  70     }
  71
  72 private:
  73     bool event( QEvent* );
  74
  75 protected:
  76     QTimer m_timer;
  77     uint   m_timeout;
  78     FHT    *m_fht;
  79 };
  80
  81
  82 class Base2D : public Base<QWidget>
  83 {
  84 Q_OBJECT
  85 public:
  86     const QPixmap *background() const { return &m_background; }
  87
  88 private slots:
  89     void draw() { drawFrame(); }
  90
  91 protected slots:
  92     void set50fps() { changeTimeout( 50 ); }
  93     void set33fps() { changeTimeout( 33 ); }
  94     void set25fps() { changeTimeout( 25 ); }
  95     void set20fps() { changeTimeout( 20 ); }
  96     void set10fps() { changeTimeout( 10 ); }
  97
  98 protected:
  99     Base2D( QWidget*, uint timeout, uint scopeSize = 7 );
 100
 101     virtual void init() {}
 102
 103     QPixmap *background() { return &m_background; }
 104
 105     void resizeEvent( QResizeEvent* );
 106
 107     void polish();
 108
 109 private:
 110     QPixmap m_background;
 111 };
 112
 113
 114
 115 //This mess is because moc generates an entry for this class despite the #if block
 116 //1. the Q_OBJECT macro must be exposed
 117 //2. we have to define the class
 118 //3. we have to declare a ctor (to satisfy the inheritance)
 119 //4. the slot must also by visible (!)
 120 //TODO find out how to stop moc generating a metaobject for this class
 121 class Base3D : public Base<QGLWidget>
 122 {
 123 Q_OBJECT
 124 #ifdef HAVE_QGLWIDGET
 125 protected:
 126     Base3D( QWidget*, uint, uint = 7 );
 127 private slots:
 128     void draw() { drawFrame(); }
 129 #else
 130 protected:
 131     Base3D( QWidget *w, uint i1, uint i2 ) : Base<QGLWidget>( w, i1, i2 ) {}
 132 private slots:
 133     void draw() {}
 134 #endif
 135 };
 136
 137
 138 class Factory
 139 {
 140     //Currently this is a rather small class, its only purpose
 141     //to ensure that making changes to analyzers will not require
 142     //rebuilding the world!
 143
 144     //eventually it would be better to make analyzers pluggable
 145     //but I can't be arsed, nor can I see much reason to do so
 146     //yet!
 147 public:
 148     static QWidget* createAnalyzer( QWidget* );
 149     static QWidget* createPlaylistAnalyzer( QWidget *);
 150 };
 151
 152
 153 void interpolate( const Scope&, Scope& );
 154 void initSin( Scope&, const uint = 6000 );
 155
 156 } //END namespace Analyzer
 157
 158 using Analyzer::Scope;
 159
 160 #endif