---

playlist.h

Go to the documentation of this file.

#ifndef NOATUNPLAYLIST_H
#define NOATUNPLAYLIST_H

#include <qobject.h>
#include <kurl.h>
#include <qdict.h>
#include <qstringlist.h>
#include <cassert>

class PlaylistItem;

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

        virtual QString property(const QString &key, const QString &def=0) const=0;

        virtual void setProperty(const QString &key, const QString &property)=0;

        virtual void clearProperty(const QString &key)=0;

        virtual QStringList properties() const=0;

        virtual bool isProperty(const QString &key) const=0;

        virtual QString title() const;

        virtual KURL url() const { return KURL(property("url")); }
        virtual void setUrl(const KURL &url) { setProperty("url", url.url()); }

        virtual QCString mimetype() const;

        virtual QCString playObject() const;
        
        virtual QString file() const { return url().path(); }

        virtual int length() const;

        virtual void setLength(int ms);

        QString lengthString() const;
        
        virtual bool operator == (const PlaylistItemData &d) const;

        virtual bool operator != (const PlaylistItemData &d) const;
        
        virtual void remove() = 0;
        

        bool streamable() const  { return isProperty("stream_"); }
        
public:
        void added();

        void removed();

        void modified();


public: // reference counting
        void addRef() { mRefs++; }
        void removeRef() { mRefs--; if (!mRefs) delete this; }

private:
        mutable int mRefs;
};


class PlaylistItem
{
public:
        PlaylistItem(const PlaylistItem &source);
        PlaylistItem(PlaylistItemData *source);
        PlaylistItem() : mData(0) {}
        ~PlaylistItem();

        PlaylistItem &operator =(const PlaylistItem &source);
        PlaylistItem &operator =(PlaylistItemData *source);

        PlaylistItemData *data() { return mData; }
        const PlaylistItemData *data() const { return mData; }
        
        const PlaylistItem &operator =(const PlaylistItem &source) const;
        const PlaylistItem &operator =(const PlaylistItemData *source) const;

        operator bool() const { return (bool)mData; }
        bool isNull() const { return !(bool)mData; }

        bool operator ==(const PlaylistItem &i) const
        {
                if (data()==i.data()) return true;
                if (!data() || !i.data()) return false;
                return *i.data()==*data();
        }
        bool operator ==(const PlaylistItemData *i) const
        {
                if (data()==i) return true;
                if (!data() || !i) return false;
                return *i==*data();
        }

        bool operator !=(const PlaylistItem &i) const
                { return ! (*this==i); }
        bool operator !=(const PlaylistItemData *i) const
                { return ! (*this->data()==*i); }
        
        QString property(const QString &key, const QString &def=0) const
        {
                assert(mData);
                return mData->property(key, def);
        }
        
        void setProperty(const QString &key, const QString &property)
        {
                assert(mData);
                const_cast<PlaylistItemData*>(mData)->setProperty(key, property);
        }
        
        void clearProperty(const QString &key)
        {
                assert(mData);
                const_cast<PlaylistItemData*>(mData)->clearProperty(key);
        }
        
        QStringList properties() const
        {
                assert(mData);
                return mData->properties();
        }

        bool isProperty(const QString &key) const
        {
                assert(mData);
                return mData->isProperty(key);
        }

        KURL url() const { assert(mData); return mData->url(); }
        void setUrl(const KURL &url)
        {
                assert(mData);
                const_cast<PlaylistItemData*>(mData)->setUrl(url);
        }

        QCString mimetype() const { assert(mData); return mData->mimetype(); }
        QCString playObject() const { assert(mData); return mData->playObject(); }
        QString file() const { assert(mData); return mData->file(); }

        QString title() const
        {
                assert(mData);
                return mData->title();
        }

        int length() const
        {
                assert(mData);
                return mData->length();
        }

        void setLength(int ms) const
        {
                assert(mData);
                mData->setLength(ms);
        }

        QString lengthString() const { assert(mData); return mData->lengthString(); }
        
        void remove() { assert(mData); mData->remove(); }

        bool streamable() const  { assert(mData); return mData->streamable(); }

private:
        // reference counting
        void removeRef() const;
        void addRef() const; // requires mData already has item

private:
        mutable PlaylistItemData *mData;
        void *_bc1, *_bc2;
};

class Playlist : public QObject
{
Q_OBJECT
        friend class PlaylistItemData;
public:
        Playlist(QObject *parent, const char *name);
        virtual ~Playlist();
        
        virtual void reset()=0;
        
        virtual void clear()=0;

        virtual void addFile(const KURL&, bool play=false)=0;

        virtual PlaylistItem next()=0;

        virtual PlaylistItem nextSection();

        virtual PlaylistItem previous()=0;

        virtual PlaylistItem previousSection();

        virtual PlaylistItem current()=0;
        virtual void setCurrent(const PlaylistItem &)=0;

        virtual PlaylistItem getFirst() const =0;

        virtual PlaylistItem getAfter(const PlaylistItem &item) const =0;
         
        virtual bool listVisible() const =0;
        
        int handleArguments();

        virtual QValueList<PlaylistItem> select(
                        const QStringList &keys, const QStringList &values,
                        int limit=-1, bool exact=false, bool caseSensitive=false
                );
        
        virtual QValueList<PlaylistItem> select(
                        const QString &key, const QString &value,
                        int limit=-1, bool exact=false, bool caseSensitive=false
                );
        inline QValueList<PlaylistItem> select(
                        const char *key, const char *value,
                        int limit=-1, bool exact=false, bool caseSensitive=false
                )
        {
                return select(
                                QString(key), QString(value),
                                limit, exact, caseSensitive
                        );
        }

public slots:
        virtual void showList()=0;
        virtual void hideList()=0;
        virtual void toggleList();

signals:
        void playCurrent();

        void listHidden();
        
        void listShown();
};

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

        virtual void added(PlaylistItem &) {}

        virtual void removed(PlaylistItem &) {}

        virtual void modified(PlaylistItem &) {}
};


#endif

---