path: root/archiveview.cpp

/*
  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.
*/

#include <QComboBox>
#include <QDialog>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QLabel>
#include <QLineEdit>
#include <QMessageBox>
#include <QPushButton>
#include <QSettings>
#include <QSplitter>
#include <QVBoxLayout>
#include <QHeaderView>

#include "archiveview.h"
#include "archivecontroller.h"
#include "smglobals.h"
#include "helper.h"

ArchiveView::ArchiveView(QWidget *parent) : QWidget(parent) {
    QSettings s;
    mArchiveModel = static_cast<ArchiveModel*>(SmGlobals::instance()->model("ArchiveModel"));
    connect(mArchiveModel, SIGNAL(needRefresh()), this, SLOT(refreshArchive()));
    connect(mArchiveModel, SIGNAL(databaseError(QString)), this, SLOT(showDatabaseError(QString)));

    mProxy = new ArchiveProxy;
    mProxy->setSourceModel(mArchiveModel);
    mTree = new ArchiveTree;
    mTree->setModel(mProxy);
    mTree->setColumnHidden(ArchiveModel::GenericId, true);
    mTree->setColumnHidden(ArchiveModel::SeriesPartId, true);
    mTree->setColumnHidden(ArchiveModel::SeriesPart, true);
    mTree->setColumnHidden(ArchiveModel::Type, true);
    mTree->setColumnHidden(ArchiveModel::Favorite, true);
    mTree->setColumnHidden(ArchiveModel::Subtitle, true);
    mTree->setColumnHidden(ArchiveModel::Count, true);
    mTree->resizeColumnToContents(ArchiveModel::Name);
    mTree->setSortingEnabled(true);
    mTree->setEditTriggers(QAbstractItemView::NoEditTriggers);
    connect(mTree, SIGNAL(expanded(QModelIndex)), this, SLOT(expandItem(QModelIndex)));
    connect(mTree, SIGNAL(collapsed(QModelIndex)), this, SLOT(collapseItem(QModelIndex)));

    QString sortOrderName = s.value("archivemodel/sortorder", "Series Name").toString();
    mSortOrder = new QComboBox;
    mSortOrder->addItems(mArchiveModel->availableOrders());
    mSortOrder->setCurrentText(sortOrderName);
    // this is _not_ redundant! when sortOrderName is the first
    // item in the list, nothing will happen otherwise!
    mArchiveModel->setOrder(sortOrderName);
    connect(mSortOrder, SIGNAL(currentIndexChanged(QString)), mArchiveModel, SLOT(setOrder(QString)));
    connect(mArchiveModel, SIGNAL(modelReset()), this, SLOT(expandedItems()));

    QLabel *l1 = new QLabel(tr("Filter"));
    mFilter = new QLineEdit;
    QString savedFilter = s.value("archivemodel/filter", QString()).toString();
    connect(mFilter, SIGNAL(returnPressed()), this, SLOT(setFilter()));
    QPushButton *filter = new QPushButton(tr("Filter"));
    connect(filter, SIGNAL(clicked()), this, SLOT(setFilter()));
    QPushButton *clear = new QPushButton(tr("Clear"));
    mFilter->setText(savedFilter);
    connect(clear, SIGNAL(clicked()), this, SLOT(clearFilter()));
    mProxy->setFilter(savedFilter, currentSortOrder());
    QHBoxLayout *filterLayout = new QHBoxLayout;
    filterLayout->addWidget(l1);
    filterLayout->addWidget(mFilter);
    filterLayout->addWidget(filter);
    filterLayout->addWidget(clear);
    QVBoxLayout *treeLayout = new QVBoxLayout;
    treeLayout->addWidget(mSortOrder);
    treeLayout->addLayout(filterLayout);
    treeLayout->addWidget(mTree);
    QWidget *treeWidget = new QWidget;
    treeWidget->setLayout(treeLayout);

    mFiles = new ArchiveFiles;
    mFiles->setItemDelegateForColumn(ArchiveFilesModel::FileType, new FileTypeDelegate(this));
    mFiles->setItemDelegateForColumn(ArchiveFilesModel::DvdNo, new DvdNoDelegate(this));
    mFiles->setItemDelegateForColumn(ArchiveFilesModel::Size, new SizeDelegate(this));
    mFiles->setItemDelegateForColumn(ArchiveFilesModel::SizeDur, new DurationDelegate(this));
    mFiles->setItemDelegateForColumn(ArchiveFilesModel::FileNumber, new EmptyDelegate(this));
    mFilesModel = new ArchiveFilesModel(QStringList() << QChar(0x26A7) << tr("Seriespartid") << tr("Filename") << tr("Md5Sum") << tr("Size") << tr("Dvd") << tr("Type") << tr("No") << tr("Q") << tr("Fileid") << tr("S/Dur") << tr("Full Path"), this);
    mFilesProxy = new ArchiveFilesProxy;
    mFilesProxy->setSourceModel(mFilesModel);
    mFiles->setModel(mFilesProxy);

    QSplitter *treeSplitter = new QSplitter(Qt::Horizontal);
    treeSplitter->addWidget(treeWidget);
    treeSplitter->addWidget(mFiles);
    treeSplitter->setStretchFactor(0, 1);
    treeSplitter->setStretchFactor(1, 4);
    QHBoxLayout *mainLayout = new QHBoxLayout;
    mainLayout->addWidget(treeSplitter);
    setLayout(mainLayout);
    initController();
}

int ArchiveView::currentSortOrder() const {
    return mArchiveModel->availableOrdersHash().value(mSortOrder->currentText());
}

void ArchiveView::readSettings(){
    QSettings s;
    QVariantList list;
    list = s.value("archivemodel/expandedgenres").toList();
    mExpandedItems[ArchiveModel::Genre] = list;
    list = s.value("archivemodel/expandedactors").toList();
    mExpandedItems[ArchiveModel::Actor] = list;
    list = s.value("archivemodel/expandedseries").toList();
    mExpandedItems[ArchiveModel::SeriesName] = list;
    expandedItems();
    mFiles->readHeaderConfig();
    mFiles->setSortingEnabled(true);
}

void ArchiveView::writeSettings() {
    QSettings s;
    s.setValue("archivemodel/sortorder", mSortOrder->currentText());
    s.setValue("archivemodel/filter", mFilter->text());
    s.setValue("archivemodel/expandedgenres", mExpandedItems.value(ArchiveModel::Genre));
    s.setValue("archivemodel/expandedactors", mExpandedItems.value(ArchiveModel::Actor));
    s.setValue("archivemodel/expandedseries", mExpandedItems.value(ArchiveModel::SeriesName));
    mFiles->writeHeaderConfig();
}

void ArchiveView::refreshArchive(){
    writeSettings();
    mArchiveModel->refresh();
    expandedItems();
}

void ArchiveView::expandedItems(){
    QVariantList list = mExpandedItems.value(currentSortOrder());
    foreach(QVariant p, list){
        QStringList path = p.toStringList();
        QModelIndexList expand = mArchiveModel->pathToIndex(path);
        foreach(QModelIndex idx, expand){
            mTree->setExpanded(mProxy->mapFromSource(idx), true);
        }
    }
}

void ArchiveView::setFilter(){
    QString filter = mFilter->text();
    mProxy->setFilter(filter, currentSortOrder());
    mTree->expandAll();
}

void ArchiveView::clearFilter(){
    mFilter->clear();
    mProxy->setFilter(QString(), currentSortOrder());
    mTree->collapseAll();
}

void ArchiveView::showDatabaseError(const QString &errorMsg){
    QMessageBox::critical(this, tr("Database Error"), errorMsg);
}

void ArchiveView::expandItem(const QModelIndex &idx){
    QModelIndex realIdx = mProxy->mapToSource(idx);
    if(realIdx.isValid()){
        QStringList path = mArchiveModel->indexToPath(realIdx);
        QVariantList list = mExpandedItems.value(currentSortOrder());
        if(!list.contains(path)){
            list << mArchiveModel->indexToPath(realIdx);
        }
        mExpandedItems[currentSortOrder()] = list;
    }
}

void ArchiveView::collapseItem(const QModelIndex &idx){
    QModelIndex realIdx = mProxy->mapToSource(idx);
    if(realIdx.isValid()){
        QVariantList list = mExpandedItems.value(currentSortOrder());
        list.removeAll(mArchiveModel->indexToPath(realIdx));
        mExpandedItems[currentSortOrder()] = list;
    }
}

void ArchiveView::initController(){
    mController = new ArchiveController(this);
    mController->setArchiveView(mTree, mProxy);
    mController->setArchiveFiles(mFiles, mFilesProxy);
    mController->setModels(mArchiveModel, mFilesModel);
    mController->init();
    SmGlobals::instance()->setArchiveController(mController);
}

ArchiveTree::ArchiveTree(QWidget *parent) : SmTreeView(parent) {}

void ArchiveTree::setModel(ArchiveProxy *model){
    mProxy = model;
    mModel = qobject_cast<ArchiveModel*>(mProxy->sourceModel());
    QTreeView::setModel(model);
}

void ArchiveTree::rename(){
    QModelIndex idx = currentIndex();
    int nodeType = idx.data(ArchiveModel::TypeRole).toInt();
    if(nodeType == ArchiveModel::SeriesPartNode){
        impossible();
        return;
    }
    QString currentName = idx.data(ArchiveModel::NameRole).toString();
    QString question = QString(tr("Rename %1 to:")).arg(currentName);
    QString newName = QInputDialog::getText(this, tr("Rename"), question, QLineEdit::Normal, currentName);
    if(!newName.isEmpty()){
        QModelIndex realIdx = mProxy->mapToSource(idx);
        mModel->setData(realIdx, newName, Qt::EditRole);
    }
}

void ArchiveTree::remove(){
    QModelIndex idx = currentIndex();
    QModelIndex realIdx = mProxy->mapToSource(idx);
    QString warningMsg = QString("Really remove %1?").arg(idx.data().toString());
    int retval = QMessageBox::warning(this, tr("Question"), warningMsg, QMessageBox::Yes | QMessageBox::No);
    if(retval == QMessageBox::Yes){
        if(!mModel->removeNode(realIdx)){
            impossible();
        }
    }
}

void ArchiveTree::impossible(const QString msg){
    QMessageBox::critical(this, tr("Error"), msg);
}

ArchiveFiles::ArchiveFiles(const QString &headerSettings, QWidget *parent) : SmTreeView(headerSettings, parent){
    setEditTriggers(QAbstractItemView::NoEditTriggers);
}

ArchiveProxy::ArchiveProxy(QObject *parent) : QSortFilterProxyModel(parent) {}

void ArchiveProxy::setFilter(const QString &filter, int sortOrder){
    mFilter = QRegExp(filter);
    mSortOrder = sortOrder;
    invalidateFilter();
}

bool ArchiveProxy::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const {
    if(mFilter.isEmpty()){
        return true;
    }
    QModelIndex nameIdx = sourceModel()->index(sourceRow, ArchiveModel::Name, sourceParent);
    ArchiveModel *model = qobject_cast<ArchiveModel*>(sourceModel());
    return model->matchRecursive(nameIdx, mFilter);
}

ArchiveFilesProxy::ArchiveFilesProxy(QObject *parent) : QSortFilterProxyModel(parent) {}

/* Delegate for file type */

QString FileTypeDelegate::displayText(const QVariant &value, const QLocale &locale) const{
    Q_UNUSED(locale);
    int type = value.toInt();
    switch(type){
        case ArchiveFilesModel::Movie:
            return tr("Movie");
        case ArchiveFilesModel::FrontCover:
            return tr("Front Cover");
        case ArchiveFilesModel::BackCover:
            return tr("Back Cover");
        case ArchiveFilesModel::GeneralCover:
            return tr("General Cover");
        default:
            ;
    }
    return tr("n/a");
}

/* Delegate for Dvd no. */

QString DvdNoDelegate::displayText(const QVariant &value, const QLocale &locale) const{
    Q_UNUSED(locale);
    int no = value.toInt();
    if(no < 0){
        return tr("(local)");
    }
    QString retval = QString(tr("#%1")).arg(QString::number(no));
    return retval;
}

/* Delegate for size */

QString SizeDelegate::displayText(const QVariant &value, const QLocale &locale) const{
    // locale.toString() doesn't work, maybe b/c it's const
    Q_UNUSED(locale);
    QLocale l;
    return l.toString(value.toLongLong());
}

/* Delegate for duration */

QString DurationDelegate::displayText(const QVariant &value, const QLocale &locale) const{
    Q_UNUSED(locale);
    if(value.toString().contains("x")){
        return value.toString();
    }
    qint64 secs = value.toInt();
    if(secs == 0){
        return tr("n/a");
    }
    Helper::Duration dur(secs);
    return dur.toString();
}

/* Empty delegate */

QString EmptyDelegate::displayText(const QVariant &value, const QLocale &locale) const{
    int i = value.toInt();
    if(i < 1){
        return QString();
    }
    return QStyledItemDelegate::displayText(value, locale);
}