QGCArchiveModel.h

Go to the documentation of this file.

#pragma once
 
#include "QGCCompressionTypes.h"
 
#include <QtCore/QAbstractListModel>
#include <QtCore/QString>
#include <QtCore/QUrl>
#include <QtQml/QQmlEngine>
 
class QGCArchiveModel : public QAbstractListModel
{
    Q_OBJECT
    QML_ELEMENT
 
    Q_PROPERTY(QString archivePath READ archivePath WRITE setArchivePath NOTIFY archivePathChanged)
 
    
    Q_PROPERTY(QUrl archiveUrl READ archiveUrl WRITE setArchiveUrl NOTIFY archivePathChanged)
 
    
    Q_PROPERTY(int count READ count NOTIFY countChanged)
 
    
    Q_PROPERTY(int fileCount READ fileCount NOTIFY fileCountChanged)
 
    
    Q_PROPERTY(int directoryCount READ directoryCount NOTIFY directoryCountChanged)
 
    
    Q_PROPERTY(qint64 totalSize READ totalSize NOTIFY totalSizeChanged)
 
    
    Q_PROPERTY(bool loading READ loading NOTIFY loadingChanged)
 
    
    Q_PROPERTY(QString errorString READ errorString NOTIFY errorStringChanged)
 
    
    Q_PROPERTY(FilterMode filterMode READ filterMode WRITE setFilterMode NOTIFY filterModeChanged)
 
public:
    enum Role {
        NameRole = Qt::UserRole + 1,    
        SizeRole,                        
        ModifiedRole,                    
        IsDirectoryRole,                 
        PermissionsRole,                 
        FileNameRole,                    
        DirectoryRole,                   
        FormattedSizeRole,               
    };
    Q_ENUM(Role)
 
    
    enum FilterMode {
        AllEntries,     
        FilesOnly,      
        DirectoriesOnly 
    };
    Q_ENUM(FilterMode)
 
    explicit QGCArchiveModel(QObject *parent = nullptr);
    ~QGCArchiveModel() override;
 
    // Property accessors
    QString archivePath() const { return _archivePath; }
    void setArchivePath(const QString &path);
 
    QUrl archiveUrl() const { return QUrl::fromLocalFile(_archivePath); }
    void setArchiveUrl(const QUrl &url);
 
    int count() const { return static_cast<int>(_filteredEntries.size()); }
    int fileCount() const { return _fileCount; }
    int directoryCount() const { return _directoryCount; }
    qint64 totalSize() const { return _totalSize; }
    bool loading() const { return _loading; }
    QString errorString() const { return _errorString; }
 
    FilterMode filterMode() const { return _filterMode; }
    void setFilterMode(FilterMode mode);
 
    // QAbstractListModel interface
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    QHash<int, QByteArray> roleNames() const override;
 
    Q_INVOKABLE void refresh();
 
    Q_INVOKABLE void clear();
 
    Q_INVOKABLE QVariantMap get(int index) const;
 
    Q_INVOKABLE bool contains(const QString &fileName) const;
 
    Q_INVOKABLE static QString formatSize(qint64 bytes);
 
signals:
    void archivePathChanged();
    void countChanged();
    void fileCountChanged();
    void directoryCountChanged();
    void totalSizeChanged();
    void loadingChanged();
    void errorStringChanged();
    void filterModeChanged();
 
    void loadingComplete(bool success);
 
private:
    void _loadArchive();
    void _applyFilter();
    void _setLoading(bool loading);
    void _setErrorString(const QString &error);
 
    QString _archivePath;
    QList<QGCCompression::ArchiveEntry> _allEntries;      
    QList<QGCCompression::ArchiveEntry> _filteredEntries; 
    int _fileCount = 0;
    int _directoryCount = 0;
    qint64 _totalSize = 0;
    bool _loading = false;
    QString _errorString;
    FilterMode _filterMode = AllEntries;
};