---

plugin.h

Go to the documentation of this file.

#ifndef NPLUGIN_H
#define NPLUGIN_H

#include <noatun/pluginloader.h>
#include <qmemarray.h>
#include <vector>


namespace Noatun { class FFTScopeStereo; class FFTScope; class RawScope; 
                   class RawScopeStereo; class StereoEffectStack;
                   class Listener;
                 }
namespace Arts { class SoundServerV2; class Dispatcher; }

//backwards compatibility

#define NOATUNPLUGIND 
#define NOATUNPLUGINC(classname)  { }

class Playlist;
class Player;
class ExitNotifier;
class NoatunApp;

class Plugin
{
public:
        Plugin();
        virtual ~Plugin();

        virtual void init();

        virtual bool unload();

        virtual Playlist *playlist() { return 0; }
};

class UserInterface : public Plugin
{
public:
        UserInterface();
        virtual ~UserInterface();
};


class TimerThingy;


class Visualization
{
friend class TimerThingy;
friend class ThingThatTellsAVisualizationThatNoatunIsGone;
friend class ExitNotifier;
friend class NoatunApp;
public:
        Visualization(int interval=125, int pid=0);
        virtual ~Visualization();

        virtual void start();
        virtual void stop();

        int interval() const;
        
        virtual void setInterval(int msecs);

        virtual void timeout()=0;

        Noatun::StereoEffectStack visualizationStack();
        Arts::SoundServerV2 *server();

        static int noatunPid();

        bool connected();

        static void initDispatcher();
        
private:
        int mTimeout;
        TimerThingy *mTimerThingy;
        QCString mVisualizationStack;
        Arts::SoundServerV2 *mServer;
        static Arts::Dispatcher *mDispatcher;
        static bool internalVis;
};

class FFTScope : public Visualization
{
public:
        FFTScope(int interval, int pid=0);
        
        virtual int bands() const=0;

        static float magic(int bands);

        virtual void setBands(float n)=0;
};

class StereoFFTScope : public FFTScope
{
public:
        StereoFFTScope(int timeout=250, int pid=0);
        virtual ~StereoFFTScope();
        
        virtual void scopeEvent(float *left, float *right, int len)
                { (void)left; (void)right; (void)len; }

        void scopeData(std::vector<float> *&left, std::vector<float> *&right);
        virtual void timeout();

        virtual int bands() const;
        virtual void setBands(float f);
        
private:
        Noatun::FFTScopeStereo *mScope;
        long mId;
};

class MonoFFTScope : public FFTScope
{
public:
        MonoFFTScope(int timeout=250, int pid=0);
        virtual ~MonoFFTScope();
        
        virtual void scopeEvent(float *data, int len)
                { (void)data; (void)len; }

        void scopeData(std::vector<float> *&data);
        
        virtual void timeout();

        virtual int bands() const;
        virtual void setBands(float f);
        
private:
        Noatun::FFTScope *mScope;
        long mId;
};

class Scope : public Visualization
{
public:
        Scope(int interval, int pid=0);
        
        virtual int samples() const=0;

        virtual void setSamples(int )=0;
};

class MonoScope : public Scope
{
public:
        MonoScope(int timeout=250, int pid=0);
        virtual ~MonoScope();
        
        virtual void scopeEvent(float *data, int len)
                {(void)data; (void)len; }

        void scopeData(std::vector<float> *&data);
        
        virtual void timeout();


        virtual int samples() const;
        virtual void setSamples(int);

private:
        Noatun::RawScope *mScope;
        long mId;
};

class StereoScope : public Scope
{
public:
        StereoScope(int timeout=250, int pid=0);
        virtual ~StereoScope();
        
        virtual void scopeEvent(float *left, float *right, int len)
                { (void)left; (void)right; (void)len; }

        void scopeData(std::vector<float> *&left, std::vector<float> *&right);
        
        virtual void timeout();


        virtual int samples() const;
        virtual void setSamples(int);

        
private:
        Noatun::RawScopeStereo *mScope;
        long mId;
};

class SessionManagement : public Plugin
{
public:
        SessionManagement();
        virtual ~SessionManagement();

        virtual void restore();
};

class NoatunListenerNotif;

class NoatunListener : public QObject
{
Q_OBJECT
friend class NoatunListenerNotif;

public:
        NoatunListener(QObject *parent=0);
        virtual ~NoatunListener();

signals:
        void event();
        
protected:
        virtual void message();
        
        NoatunListenerNotif *mNotif;
};

class ExitNotifier : public NoatunListener
{
public:
        ExitNotifier(int pid, QObject *parent=0);
        virtual ~ExitNotifier();

private:
        QCString appid;
};

class BoolNotifier : public QObject
{
Q_OBJECT
public:
        BoolNotifier(bool *value, NoatunListener *listener, QObject *parent=0);

private slots:
        void event() {*mValue=false;}

private:
        bool *mValue;
};

#endif

---