playlistmodel.h

/***************************************************************************
 *   Copyright (C) 2006-2019 by Ilya Kotov                                 *
 *   forkotov02@ya.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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
 ***************************************************************************/
#ifndef PLAYLISTMODEL_H
#define PLAYLISTMODEL_H
 
#include <QObject>
#include <QString>
#include <QStringList>
#include <QMap>
#include <QQueue>
#include <QPointer>
#include <QVector>
#include <QUrl>
#include "playlistitem.h"
#include "playlisttrack.h"
#include "playlistgroup.h"
#include "qmmpui_export.h"
 
class FileLoader;
class PlayState;
class PlayListFormat;
class PlayListModel;
class PlayListContainer;
class QmmpUiSettings;
class PlayListTask;
 
struct SimpleSelection
{
    SimpleSelection()
    {
        m_bottom = -1;
        m_top = 1;
    }
    inline bool isValid()const
    {
        return (m_bottom != -1) && (m_top != -1);
    }
    inline void dump()const
    {
        qDebug("top: %d\tbotom: %d", m_top, m_bottom);
    }
    inline int count()const
    {
        return m_bottom - m_top + 1;
    }
    int m_bottom;               
    int m_top;                  
    QList<int> m_selected_indexes;  
};
class QMMPUI_EXPORT PlayListModel : public QObject
{
    Q_OBJECT
public:
    PlayListModel(const QString &name, QObject *parent = 0);
    ~PlayListModel();
    QString name() const;
    void setName(const QString &name);
    int count() const;
    int trackCount() const;
    bool isEmpty() const;
    int columnCount() const;
    PlayListTrack* currentTrack() const;
    PlayListTrack* nextTrack() const;
    int indexOf(PlayListItem* item) const;
    PlayListItem* item(int index) const;
    PlayListTrack* track(int index) const;
    PlayListGroup* group(int index) const;
    int currentIndex() const;
    bool setCurrent (int index);
    bool setCurrent(PlayListTrack *item);
    bool isTrack(int index) const;
    bool isGroup(int index) const;
    bool isSelected(int index) const;
    void setSelected(int index, bool selected = true);
    void setSelected(QList<PlayListTrack *> tracks, bool selected = true);
    void setSelected(QList<PlayListItem *> items, bool selected = true);
    void setSelected(int first, int last, bool selected = true);
    void setSelected(QList<int> indexes, bool selected = true);
    bool next();
    bool previous();
    QList<PlayListItem *> mid(int pos, int count = -1) const;
    void moveItems(int from, int to);
    bool isQueued(PlayListTrack* item) const;
    bool isEmptyQueue()const;
    int queuedIndex(PlayListTrack* track) const;
    int queueSize() const;
    bool isStopAfter(PlayListItem* item) const;
    const SimpleSelection& getSelection(int row);
    QList<int> selectedIndexes() const;
    QList<PlayListTrack *> selectedTracks() const;
    QList<PlayListItem*> items() const;
    int firstSelectedUpper(int row);
    int firstSelectedLower(int row);
    qint64 totalDuration() const;
    void loadPlaylist(const QString& f_name);
    void loadPlaylist(const QString &fmt, const QByteArray &data);
    void savePlaylist(const QString& f_name);
    bool isLoaderRunning() const;
    bool contains(const QString &url);
    enum SortMode
    {
        TITLE = 0,              
        ALBUM,                  
        DISCNUMBER,             
        ARTIST,                 
        ALBUMARTIST,            
        FILENAME,               
        PATH_AND_FILENAME,      
        DATE,                   
        TRACK,                  
        FILE_CREATION_DATE,     
        FILE_MODIFICATION_DATE, 
        GROUP                   
    };
    int indexOfTrack(int index) const;
    PlayListTrack *findTrack(int track_index) const;
    QList<PlayListItem *> findTracks(const QString &str) const;
    enum UpdateFlags
    {
        STRUCTURE = 0x01,  
        SELECTION = 0x02,  
        QUEUE = 0x04,      
        CURRENT = 0x08,    
        STOP_AFTER = 0x10, 
        METADATA = 0x20    
    };
 
signals:
    void listChanged(int flags);
    void trackAdded(PlayListTrack *track);
    void nameChanged(const QString& name);
    void loaderFinished();
    void scrollToRequest(int index);
    void sortingByColumnFinished(int column, bool reverted);
 
public slots:
    void add(PlayListTrack *track);
    void add(QList <PlayListTrack *> tracks);
    void add(const QString &path);
    void add(const QStringList &paths);
    void insert(int index, PlayListTrack *track);
    void insert(PlayListItem *before, PlayListTrack *track);
    void insert(int index, QList <PlayListTrack *> tracks);
    void insert(PlayListItem *before, QList <PlayListTrack *> tracks);
    void insert(int index, const QString &path);
    void insert(int index, const QStringList &paths);
    void insert(int index, const QList<QUrl> &urls);
    void clear();
    void clearSelection();
    void removeSelected();
    void removeUnselected();
    void removeTrack(int i);
    void removeTrack(PlayListItem *track);
    void removeTracks(const QList<PlayListItem *> &items);
    void removeTracks(const QList<PlayListTrack *> &tracks);
    void invertSelection();
    void selectAll();
    void showDetails(QWidget *parent = 0);
    void showDetailsForCurrent(QWidget *parent = 0);
    void doCurrentVisibleRequest();
    void scrollTo(int index);
    void randomizeList();
    void reverseList();
    void sortSelection(int mode);
    void sort(int mode);
    void sortByColumn(int column);
    void addToQueue();
    void setQueued(PlayListTrack* item);
    void removeInvalidTracks();
    void removeDuplicates();
    void refresh();
    void clearQueue();
    void stopAfterSelected();
    void rebuildGroups();
    void updateMetaData();
 
private:
    int topmostInSelection(int);
    int bottommostInSelection(int);
    void removeSelection(bool inverted = false);
 
    int removeTrackInternal(int i);
 
private slots:
    void preparePlayState();
    void prepareForShufflePlaying(bool yes);
    void prepareGroups(bool enabled);
 
    void onTaskFinished();
 
private:
    PlayListTrack* m_current_track;
    PlayListTrack* m_stop_track;
    int m_current;
    SimpleSelection m_selection;  
    QQueue <PlayListTrack*> m_queued_songs; 
    PlayState* m_play_state; 
    qint64 m_total_duration;
    FileLoader *m_loader;
    QString m_name;
    PlayListContainer *m_container;
    QmmpUiSettings *m_ui_settings;
    PlayListTask *m_task;
};
 
#endif