playlistmodel.h

/***************************************************************************
 *   Copyright (C) 2006-2025 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 <QSet>
#include "playlistitem.h"
#include "playlisttrack.h"
#include "playlistgroup.h"
#include "coverloader_p.h"
#include "qmmpui_export.h"
 
class FileLoader;
class PlayState;
class PlayListFormat;
class PlayListModel;
class PlayListContainer;
class QmmpUiSettings;
class PlayListTask;

struct SimpleSelection
{
    inline int count()const
    {
        return bottom - top + 1;
    }
    int top = 1;                  
    int bottom = -1;              
};

class QMMPUI_EXPORT PlayListModel : public QObject
{
    Q_OBJECT
public:
    explicit PlayListModel(const QString &name, QObject *parent = nullptr);
    ~PlayListModel();
    QString name() const;
    void setName(const QString &name);
    int groupCount() const;
    int trackCount() const;
    bool isEmpty() const;
    int columnCount() const;
    PlayListTrack *currentTrack() const;
    PlayListTrack *nextTrack() const;
    int indexOf(PlayListItem *item) const;
    PlayListTrack *track(int index) const;
    PlayListGroup *group(int index) const;
    int currentIndex() const;
    bool setCurrent(int index);
    bool setCurrent(PlayListTrack *track);
    void setSelected(PlayListItem *item, bool selected = true);
    void setSelected(const QList<PlayListTrack *> &tracks, bool selected = true);
    void setSelected(const QList<PlayListItem *> &items, bool selected = true);
    void setSelectedLines(int firstLine, int lastLine, bool selected = true);
    bool next();
    bool previous();
    int lineCount() const;
    PlayListItem *itemAtLine(int lineIndex) const;
    PlayListTrack *trackAtLine(int lineIndex) const;
    QList<PlayListItem *> itemsAtLines(int pos, int count = -1) const;
    int findLine(PlayListItem *item) const;
    int findLine(int trackIndex) const;
    int subIndexOfLine(int lineIndex) const;
    int trackIndexAtLine(int lineIndex) const;
    bool alternateColor(int lineIndex) const;
    int linesPerGroup() const;
    void moveTracks(int from, int to);
    const QList<PlayListTrack *> &queuedTracks() const;
    bool isEmptyQueue()const;
    int queueSize() const;
    bool isStopAfter(const PlayListItem *track) const;
    SimpleSelection getSelection(int trackIndex);
    QList<int> selectedLines() const;
    void setSelectedLine(int line, bool selected = true);
    QList<int> selectedTrackIndexes() const;
    QList<PlayListTrack *> selectedTracks() const;
    QList<PlayListTrack *> tracks() const;
    int firstSelectedUpper(int trackIndex);
    int firstSelectedLower(int trackIndex);
    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                   
    };

    PlayListTrack *findTrack(int trackIndex) 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 tracksAdded(const QList<PlayListTrack *> &tracks);
    void nameChanged(const QString &name);
    void loaderFinished();
    void scrollToRequest(int trackIndex);
    void sortingByColumnFinished(int column, bool reverted);
    void currentTrackRemoved();
 
public slots:
    void addTrack(PlayListTrack *track);
    void addTracks(const QList<PlayListTrack *> &tracks);
    void addPath(const QString &path);
    void addPaths(const QStringList &paths);
    void insertTrack(int index, PlayListTrack *track);
    void insertTracks(int index, const QList<PlayListTrack *> &tracks);
    void insertJson(int index, const QByteArray &json);
    void insertPath(int index, const QString &path);
    void insertPaths(int index, const QStringList &paths);
    void insertUrls(int index, const QList<QUrl> &urls);
    void clear();
    void clearSelection();
    void removeSelected();
    void removeUnselected();
    void removeTrack(int i);
    void removeTrack(PlayListTrack *track);
    void removeTracks(const QList<PlayListItem *> &items);
    void removeTracks(const QList<PlayListTrack *> &tracks);
    void invertSelection();
    void selectAll();
    void showDetails(QWidget *parent = nullptr);
    void showDetailsForCurrent(QWidget *parent = nullptr);
    void doCurrentVisibleRequest();
    void scrollTo(int trackIndex);
    void randomizeList();
    void reverseList();
    void sortSelection(PlayListModel::SortMode mode);
    void sort(PlayListModel::SortMode mode);
    void sortByColumn(int column);
    void addToQueue();
    void setQueued(PlayListTrack *t);
    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();
 
    void updateMetaData(const QStringList &paths);
 
    void startCoverLoader();
    void setCover(const QString &path, const QImage &img);
    void insertTracksInternal(PlayListTrack *before, const QList<PlayListTrack *> &tracks);
 
private:
    PlayListTrack *m_current_track = nullptr;
    PlayListTrack *m_stop_track = nullptr;
    int m_current = -1;
    PlayState* m_play_state; 
    qint64 m_total_duration = 0;
    FileLoader *m_loader;
    CoverLoader *m_coverLoder;
    QString m_name;
    PlayListContainer *m_container;
    QmmpUiSettings *m_ui_settings;
    PlayListTask *m_task;
    QSet<QString> m_uniquePaths;
};
 
Q_DECLARE_METATYPE(PlayListModel::SortMode)
 
#endif