409 lines
12 KiB
C++
409 lines
12 KiB
C++
/*
|
|
* This file Copyright (C) 2009-2015 Mnemosyne LLC
|
|
*
|
|
* It may be used under the GNU GPL versions 2 or 3
|
|
* or any future license endorsed by Mnemosyne LLC.
|
|
*
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
|
|
#include <QHeaderView>
|
|
#include <QMenu>
|
|
#include <QQueue>
|
|
#include <QResizeEvent>
|
|
#include <QSortFilterProxyModel>
|
|
|
|
#include <libtransmission/transmission.h> // priorities
|
|
|
|
#include "FileTreeDelegate.h"
|
|
#include "FileTreeItem.h"
|
|
#include "FileTreeModel.h"
|
|
#include "FileTreeView.h"
|
|
#include "Formatter.h"
|
|
#include "Utils.h"
|
|
|
|
#define PRIORITY_KEY "priority"
|
|
|
|
FileTreeView::FileTreeView (QWidget * parent, bool isEditable):
|
|
QTreeView (parent),
|
|
myModel (new FileTreeModel (this, isEditable)),
|
|
myProxy (new QSortFilterProxyModel (this)),
|
|
myDelegate (new FileTreeDelegate (this))
|
|
{
|
|
myProxy->setSourceModel (myModel);
|
|
myProxy->setSortRole (FileTreeModel::SortRole);
|
|
myProxy->setSortCaseSensitivity (Qt::CaseInsensitive);
|
|
|
|
setModel (myProxy);
|
|
setItemDelegate (myDelegate);
|
|
sortByColumn (FileTreeModel::COL_NAME, Qt::AscendingOrder);
|
|
|
|
connect (this, SIGNAL(clicked(QModelIndex)),
|
|
this, SLOT(onClicked(QModelIndex)));
|
|
|
|
connect (myModel, SIGNAL(priorityChanged(QSet<int>, int)),
|
|
this, SIGNAL(priorityChanged(QSet<int>, int)));
|
|
|
|
connect (myModel, SIGNAL(wantedChanged(QSet<int>, bool)),
|
|
this, SIGNAL(wantedChanged(QSet<int>, bool)));
|
|
|
|
connect (myModel, SIGNAL(pathEdited(QString, QString)),
|
|
this, SIGNAL(pathEdited(QString, QString)));
|
|
|
|
connect (myModel, SIGNAL (openRequested (QString)),
|
|
this, SIGNAL (openRequested (QString)));
|
|
}
|
|
|
|
void
|
|
FileTreeView::onClicked (const QModelIndex& proxyIndex)
|
|
{
|
|
const QModelIndex modelIndex = myProxy->mapToSource (proxyIndex);
|
|
if (modelIndex.column () == FileTreeModel::COL_WANTED)
|
|
myModel->twiddleWanted (QModelIndexList () << modelIndex);
|
|
else if (modelIndex.column () == FileTreeModel::COL_PRIORITY)
|
|
myModel->twiddlePriority (QModelIndexList () << modelIndex);
|
|
}
|
|
|
|
void
|
|
FileTreeView::resizeEvent (QResizeEvent * event)
|
|
{
|
|
QTreeView::resizeEvent (event);
|
|
|
|
// this is kind of a hack to get the last four columns be the
|
|
// right size, and to have the filename column use whatever
|
|
// space is left over...
|
|
|
|
int left = event->size ().width () - 1;
|
|
for (int column = 0; column < FileTreeModel::NUM_COLUMNS; ++column)
|
|
{
|
|
if (column == FileTreeModel::COL_NAME)
|
|
continue;
|
|
|
|
int minWidth = 0;
|
|
|
|
QStringList itemTexts;
|
|
switch (column)
|
|
{
|
|
case FileTreeModel::COL_SIZE:
|
|
for (int s = Formatter::B; s <= Formatter::TB; ++s)
|
|
itemTexts << QLatin1String ("999.9 ") +
|
|
Formatter::unitStr (Formatter::MEM, static_cast<Formatter::Size> (s));
|
|
break;
|
|
|
|
case FileTreeModel::COL_PROGRESS:
|
|
itemTexts << QLatin1String (" 100% ");
|
|
break;
|
|
|
|
case FileTreeModel::COL_WANTED:
|
|
minWidth = 20;
|
|
break;
|
|
|
|
case FileTreeModel::COL_PRIORITY:
|
|
itemTexts << FileTreeItem::tr ("Low") << FileTreeItem::tr ("Normal") <<
|
|
FileTreeItem::tr ("High") << FileTreeItem::tr ("Mixed");
|
|
break;
|
|
}
|
|
|
|
int itemWidth = 0;
|
|
for (const QString& itemText: itemTexts)
|
|
itemWidth = std::max (itemWidth, Utils::measureViewItem (this, itemText));
|
|
|
|
const QString headerText = myModel->headerData (column, Qt::Horizontal).toString ();
|
|
int headerWidth = Utils::measureHeaderItem (this->header (), headerText);
|
|
|
|
const int width = std::max (minWidth, std::max (itemWidth, headerWidth));
|
|
setColumnWidth (column, width);
|
|
|
|
left -= width;
|
|
}
|
|
|
|
setColumnWidth (FileTreeModel::COL_NAME, std::max (left, 0));
|
|
}
|
|
|
|
void
|
|
FileTreeView::keyPressEvent (QKeyEvent * event)
|
|
{
|
|
if (state () != EditingState)
|
|
{
|
|
if (event->key () == Qt::Key_Space)
|
|
{
|
|
// handle using the keyboard to toggle the
|
|
// wanted/unwanted state or the file priority
|
|
|
|
const Qt::KeyboardModifiers modifiers = event->modifiers ();
|
|
|
|
if (modifiers == Qt::NoModifier)
|
|
{
|
|
myModel->twiddleWanted (selectedSourceRows ());
|
|
return;
|
|
}
|
|
|
|
if (modifiers == Qt::ShiftModifier)
|
|
{
|
|
myModel->twiddlePriority (selectedSourceRows ());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
QTreeView::keyPressEvent (event);
|
|
}
|
|
|
|
void
|
|
FileTreeView::mouseDoubleClickEvent (QMouseEvent * event)
|
|
{
|
|
const QModelIndex index = currentIndex ();
|
|
if (!index.isValid () || index.column () == FileTreeModel::COL_WANTED || index.column () == FileTreeModel::COL_PRIORITY)
|
|
return;
|
|
|
|
if (openSelectedItem ())
|
|
return;
|
|
|
|
QTreeView::mouseDoubleClickEvent (event);
|
|
}
|
|
|
|
void
|
|
FileTreeView::contextMenuEvent (QContextMenuEvent * event)
|
|
{
|
|
const QModelIndex rootIndex = myModel->index (0, 0);
|
|
if (!rootIndex.isValid ())
|
|
return;
|
|
|
|
if (myContextMenu == nullptr)
|
|
initContextMenu ();
|
|
myContextMenu->popup (event->globalPos ());
|
|
}
|
|
|
|
void
|
|
FileTreeView::update (const FileList& files, bool updateFields)
|
|
{
|
|
const bool modelWasEmpty = myProxy->rowCount () == 0;
|
|
|
|
for (const TorrentFile& file: files)
|
|
myModel->addFile (file.index, file.filename, file.wanted, file.priority, file.size, file.have, updateFields);
|
|
|
|
if (modelWasEmpty)
|
|
{
|
|
// expand up until the item with more than one expandable child
|
|
for (QModelIndex index = myProxy->index (0, 0); index.isValid ();)
|
|
{
|
|
const QModelIndex oldIndex = index;
|
|
|
|
expand (oldIndex);
|
|
|
|
index = QModelIndex ();
|
|
for (int i = 0, count = myProxy->rowCount (oldIndex); i < count; ++i)
|
|
{
|
|
const QModelIndex newIndex = myProxy->index (i, 0, oldIndex);
|
|
if (myProxy->rowCount (newIndex) == 0)
|
|
continue;
|
|
if (index.isValid ())
|
|
{
|
|
index = QModelIndex ();
|
|
break;
|
|
}
|
|
index = newIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
myProxy->sort (header ()->sortIndicatorSection (), header ()->sortIndicatorOrder ());
|
|
}
|
|
|
|
void
|
|
FileTreeView::clear ()
|
|
{
|
|
myModel->clear();
|
|
}
|
|
|
|
void
|
|
FileTreeView::setEditable (bool editable)
|
|
{
|
|
myModel->setEditable (editable);
|
|
}
|
|
|
|
bool
|
|
FileTreeView::edit (const QModelIndex& index, EditTrigger trigger, QEvent * event)
|
|
{
|
|
if (selectionModel ()->selectedRows ().size () != 1)
|
|
return false;
|
|
|
|
const QModelIndex nameIndex = index.sibling (index.row (), FileTreeModel::COL_NAME);
|
|
if (editTriggers ().testFlag (trigger))
|
|
selectionModel ()->setCurrentIndex (nameIndex, QItemSelectionModel::NoUpdate);
|
|
|
|
return QTreeView::edit (nameIndex, trigger, event);
|
|
}
|
|
|
|
void
|
|
FileTreeView::checkSelectedItems ()
|
|
{
|
|
myModel->setWanted (selectedSourceRows (), true);
|
|
}
|
|
|
|
void
|
|
FileTreeView::uncheckSelectedItems ()
|
|
{
|
|
myModel->setWanted (selectedSourceRows (), false);
|
|
}
|
|
|
|
void
|
|
FileTreeView::onlyCheckSelectedItems ()
|
|
{
|
|
const QModelIndex rootIndex = myModel->index (0, 0);
|
|
if (!rootIndex.isValid ())
|
|
return;
|
|
|
|
QModelIndexList wantedIndices = selectedSourceRows ();
|
|
myModel->setWanted (wantedIndices, true);
|
|
|
|
qSort (wantedIndices);
|
|
|
|
QSet<QModelIndex> wantedIndicesParents;
|
|
for (const QModelIndex& i: wantedIndices)
|
|
{
|
|
for (QModelIndex p = i.parent (); p.isValid (); p = p.parent ())
|
|
wantedIndicesParents.insert (p);
|
|
}
|
|
|
|
QQueue<QModelIndex> parentsQueue;
|
|
parentsQueue.enqueue (rootIndex);
|
|
QModelIndexList unwantedIndices;
|
|
while (!parentsQueue.isEmpty ())
|
|
{
|
|
const QModelIndex parentIndex = parentsQueue.dequeue ();
|
|
if (qBinaryFind (wantedIndices, parentIndex) != wantedIndices.end ())
|
|
continue;
|
|
|
|
for (int i = 0, count = myModel->rowCount (parentIndex); i < count; ++i)
|
|
{
|
|
const QModelIndex childIndex = parentIndex.child (i, 0);
|
|
const int childCheckState = childIndex.data (FileTreeModel::WantedRole).toInt ();
|
|
if (childCheckState == Qt::Unchecked || qBinaryFind (wantedIndices, childIndex) != wantedIndices.end ())
|
|
continue;
|
|
|
|
if (childCheckState == Qt::Checked && childIndex.data (FileTreeModel::FileIndexRole).toInt () >= 0)
|
|
{
|
|
unwantedIndices << childIndex;
|
|
}
|
|
else
|
|
{
|
|
if (!wantedIndicesParents.contains (childIndex))
|
|
unwantedIndices << childIndex;
|
|
else
|
|
parentsQueue.enqueue (childIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
myModel->setWanted (unwantedIndices, false);
|
|
}
|
|
|
|
void
|
|
FileTreeView::setSelectedItemsPriority ()
|
|
{
|
|
QAction * action = qobject_cast<QAction *> (sender ());
|
|
assert (action != nullptr);
|
|
myModel->setPriority (selectedSourceRows (), action->property (PRIORITY_KEY).toInt ());
|
|
}
|
|
|
|
bool
|
|
FileTreeView::openSelectedItem ()
|
|
{
|
|
return myModel->openFile (myProxy->mapToSource (currentIndex ()));
|
|
}
|
|
|
|
void
|
|
FileTreeView::renameSelectedItem ()
|
|
{
|
|
QTreeView::edit (currentIndex ());
|
|
}
|
|
|
|
void
|
|
FileTreeView::refreshContextMenuActionsSensitivity ()
|
|
{
|
|
assert (myContextMenu != nullptr);
|
|
|
|
const QModelIndexList selectedRows = selectionModel ()->selectedRows ();
|
|
const Qt::CheckState checkState = getCumulativeCheckState (selectedRows);
|
|
|
|
const bool haveSelection = !selectedRows.isEmpty ();
|
|
const bool haveSingleSelection = selectedRows.size() == 1;
|
|
const bool haveUnchecked = checkState == Qt::Unchecked || checkState == Qt::PartiallyChecked;
|
|
const bool haveChecked = checkState == Qt::Checked || checkState == Qt::PartiallyChecked;
|
|
|
|
myCheckSelectedAction->setEnabled (haveUnchecked);
|
|
myUncheckSelectedAction->setEnabled (haveChecked);
|
|
myOnlyCheckSelectedAction->setEnabled (haveSelection);
|
|
myPriorityMenu->setEnabled (haveSelection);
|
|
myOpenAction->setEnabled (haveSingleSelection &&
|
|
selectedRows.first ().data (FileTreeModel::FileIndexRole).toInt () >= 0 &&
|
|
selectedRows.first ().data (FileTreeModel::CompleteRole).toBool ());
|
|
myRenameAction->setEnabled (haveSingleSelection);
|
|
}
|
|
|
|
void
|
|
FileTreeView::initContextMenu ()
|
|
{
|
|
myContextMenu = new QMenu (this);
|
|
|
|
myCheckSelectedAction = myContextMenu->addAction (tr ("Check Selected"), this, SLOT (checkSelectedItems ()));
|
|
myUncheckSelectedAction = myContextMenu->addAction (tr ("Uncheck Selected"), this, SLOT (uncheckSelectedItems ()));
|
|
myOnlyCheckSelectedAction = myContextMenu->addAction (tr ("Only Check Selected"), this, SLOT (onlyCheckSelectedItems ()));
|
|
|
|
myContextMenu->addSeparator ();
|
|
|
|
myPriorityMenu = myContextMenu->addMenu (tr ("Priority"));
|
|
myHighPriorityAction = myPriorityMenu->addAction (FileTreeItem::tr ("High"), this, SLOT (setSelectedItemsPriority ()));
|
|
myNormalPriorityAction = myPriorityMenu->addAction (FileTreeItem::tr ("Normal"), this, SLOT (setSelectedItemsPriority ()));
|
|
myLowPriorityAction = myPriorityMenu->addAction (FileTreeItem::tr ("Low"), this, SLOT (setSelectedItemsPriority ()));
|
|
|
|
myHighPriorityAction->setProperty (PRIORITY_KEY, TR_PRI_HIGH);
|
|
myNormalPriorityAction->setProperty (PRIORITY_KEY, TR_PRI_NORMAL);
|
|
myLowPriorityAction->setProperty (PRIORITY_KEY, TR_PRI_LOW);
|
|
|
|
myContextMenu->addSeparator ();
|
|
|
|
myOpenAction = myContextMenu->addAction (tr ("Open"), this, SLOT (openSelectedItem ()));
|
|
myRenameAction = myContextMenu->addAction (tr ("Rename..."), this, SLOT (renameSelectedItem ()));
|
|
|
|
connect (myContextMenu, SIGNAL (aboutToShow ()), SLOT (refreshContextMenuActionsSensitivity ()));
|
|
}
|
|
|
|
QModelIndexList
|
|
FileTreeView::selectedSourceRows (int column) const
|
|
{
|
|
QModelIndexList indices;
|
|
for (const QModelIndex& i: selectionModel ()->selectedRows (column))
|
|
indices << myProxy->mapToSource (i);
|
|
return indices;
|
|
}
|
|
|
|
Qt::CheckState
|
|
FileTreeView::getCumulativeCheckState (const QModelIndexList& indices)
|
|
{
|
|
bool haveChecked = false, haveUnchecked = false;
|
|
|
|
for (const QModelIndex& i: indices)
|
|
{
|
|
switch (i.data (FileTreeModel::WantedRole).toInt ())
|
|
{
|
|
case Qt::Checked:
|
|
haveChecked = true;
|
|
break;
|
|
case Qt::Unchecked:
|
|
haveUnchecked = true;
|
|
break;
|
|
case Qt::PartiallyChecked:
|
|
return Qt::PartiallyChecked;
|
|
}
|
|
|
|
if (haveChecked && haveUnchecked)
|
|
return Qt::PartiallyChecked;
|
|
}
|
|
|
|
return haveChecked ? Qt::Checked : Qt::Unchecked;
|
|
}
|