/usr/src/RPM/BUILD/qmmp-0.4-svn/src/qmmpui/playlistmodel.h

/***************************************************************************
 *   Copyright (C) 2006-2010 by Ilya Kotov                                 *
 *   forkotov02@hotmail.ru                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef PLAYLISTMODEL_H
#define PLAYLISTMODEL_H

#include <QObject>
#include <QString>
#include <QStringList>
#include <QMap>
#include <QPointer>
#include <QVector>
#include "playlistitem.h"

class FileLoader;
class PlayListItem;
class PlayState;
class PlaylistFormat;
class PlayListModel;

struct SimpleSelection
{
    SimpleSelection()
    {
        ;
    }
    inline bool isValid()const
    {
        return (m_bottom != -1) && (m_anchor != -1) && (m_top != -1);
    }
    inline void dump()const
    {
        qWarning("top: %d\tbotom: %d\tanchor: %d",m_top,m_bottom,m_anchor);
    }
    inline int count()const
    {
        return m_bottom - m_top + 1;
    }
    int m_bottom;               
    int m_top;                  
    int m_anchor;               
    QList<int>m_selected_rows;  
};
class TagUpdater : public QObject
{
    Q_OBJECT
    QObject* m_observable;
    PlayListItem* m_item;

public:
    TagUpdater(QObject* o, PlayListItem* item);

protected slots:
    void updateTag();
};
class PlayListModel : public QObject
{
    Q_OBJECT
public:
    PlayListModel(const QString &name, QObject *parent = 0);
    ~PlayListModel();
    QString name() const;
    void setName(const QString &name);
    int count();
    PlayListItem* currentItem();
    PlayListItem* nextItem();
    int row(PlayListItem* item) const
    {
        return m_items.indexOf(item);
    }
    PlayListItem* item(int row) const;
    int currentRow();
    bool setCurrent (int row);
    bool isSelected(int row);
    void setSelected(int row, bool select);
    bool next();
    bool previous();
    QList <QString> getTitles(int first,int last);
    QList <QString> getTimes(int first,int last);
    void moveItems(int from, int to);
    bool isQueued(PlayListItem* item) const;
    void setCurrentToQueued();
    bool isEmptyQueue()const;
    int queuedIndex(PlayListItem* item) const
    {
        return m_queued_songs.indexOf(item);
    }
    const SimpleSelection& getSelection(int row);
    QList<int> getSelectedRows() const;
    QList<PlayListItem*> getSelectedItems() const;
    QList<PlayListItem*> items() const
    {
        return m_items;
    }
    int firstSelectedUpper(int row);
    int firstSelectedLower(int row);
    int totalLength()const
    {
        return m_total_length;
    }
    void loadPlaylist(const QString& f_name);
    void savePlaylist(const QString& f_name);
    bool isRepeatableList() const;
    bool isShuffle() const;
    bool contains(const QString &url);
    enum SortMode
    {
        TITLE,             
        ALBUM,             
        ARTIST,            
        FILENAME,          
        PATH_AND_FILENAME, 
        DATE,              
        TRACK              
    };

signals:
    void listChanged();
    void currentChanged();
    void firstAdded();
    void nameChanged(const QString& name);

public slots:
    void add(PlayListItem *item);
    void add(QList <PlayListItem *> items);
    void clear();
    void clearSelection();
    void removeSelected();
    void removeUnselected();
    void removeAt (int i);
    void removeItem (PlayListItem *item);
    void invertSelection();
    void selectAll();
    void showDetails();
    void doCurrentVisibleRequest();
    void addFile(const QString &path);
    void addFiles(const QStringList& l);
    void addDirectory(const QString& dir);
    bool setFileList(const QStringList &l);
    void addFileList(const QStringList &l);
    void randomizeList();
    void reverseList();
    void prepareForShufflePlaying(bool yes);
    void prepareForRepeatablePlaying(bool);
    void sortSelection(int mode);
    void sort(int mode);
    void addToQueue();
    void setQueued(PlayListItem* f);
    void removeInvalidItems();
    void removeDuplicates();

private:
    void doSort(int mode,QList<PlayListItem*>& list_to_sort);
    int topmostInSelection(int);
    int bottommostInSelection(int);
    FileLoader* createFileLoader();
    bool isFileLoaderRunning()const;
    void removeSelection(bool inverted = false);

private slots:
    void preparePlayState();

private:
    QList <PlayListItem*> m_items;
    QList <PlayListItem*> m_editing_items;
    PlayListItem* m_currentItem;
    int m_current;
    SimpleSelection m_selection;
    QList<PlayListItem*> m_queued_songs;
    bool is_repeatable_list;
    PlayState* m_play_state;
    int m_total_length;
    typedef QPointer<FileLoader> GuardedFileLoader;
    QVector<GuardedFileLoader> m_running_loaders;
    bool m_shuffle;
    QString m_name;
};


#endif

---