QVariant DirModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid()) {
return QVariant();
}
switch (role) {
case UrlRole: {
KFileItem item = itemForIndex(index);
return item.url().toString();
}
case MimeTypeRole: {
KFileItem item = itemForIndex(index);
return item.mimetype();
}
case Thumbnail: {
KFileItem item = itemForIndex(index);
QImage preview = QImage(m_screenshotSize, QImage::Format_ARGB32_Premultiplied);
if (m_imageCache->findImage(item.url().toString(), &preview)) {
return preview;
}
m_previewTimer->start(100);
const_cast<DirModel *>(this)->m_filesToPreview[item.url()] = QPersistentModelIndex(index);
}
default:
return KDirModel::data(index, role);
}
}
void ProjectModel::startNewMetadataJob()
{
if (!m_completeScan) //hack for debugging
return;
m_activeJob = NULL;
m_activeNode = NULL;
if (m_dirsWaitingForMetadata.isEmpty())
return;
ProjectNode* node = *m_dirsWaitingForMetadata.begin();
//prepare new work
m_activeNode = node;
QList<KFileItem> files;
QModelIndex item = indexForNode(node);
for (int row=0; row < node->rows.count(); row ++)
files.append(itemForIndex(index(row, 0, item)));
m_activeJob = new UpdateStatsJob(files, this);
connect(
m_activeJob,SIGNAL(done(ThreadWeaver::Job*)),
this,SLOT(finishMetadataUpdate(ThreadWeaver::Job*)));
m_weaver->enqueue(m_activeJob);
}
QModelIndex TreeModel::cut(const QModelIndex &index)
{
if (!index.isValid())
return index;
delete cutItem;
cutItem = itemForIndex(index);
Q_ASSERT(cutItem);
TaskItem *parent = cutItem->parent();
Q_ASSERT(parent);
int row = parent->rowOfChild(cutItem);
Q_ASSERT(row == index.row());
beginRemoveRows(index.parent(), row, row);
TaskItem *child = parent->takeChild(row);
endRemoveRows();
Q_ASSERT(child == cutItem);
child = 0; // Silence compiler unused variable warning
if (row > 0) {
--row;
return createIndex(row, 0, parent->childAt(row));
}
if (parent != rootItem) {
TaskItem *grandParent = parent->parent();
Q_ASSERT(grandParent);
return createIndex(grandParent->rowOfChild(parent), 0, parent);
}
return QModelIndex();
}
void TreeModel::setTimedItem(const QModelIndex &index)
{
clearTimedItem();
timedItem = itemForIndex(index);
Q_ASSERT(timedItem);
announceItemChanged(timedItem);
}
const TestResult *TestResultModel::testResult(const QModelIndex &idx)
{
if (idx.isValid())
return static_cast<TestResultItem *>(itemForIndex(idx))->testResult();
return 0;
}
QVariant TreeModel::data(const QModelIndex &index, int role) const
{
if (!rootItem || !index.isValid() || index.column() < 0 ||
index.column() >= ColumnCount)
return QVariant();
if (TaskItem *item = itemForIndex(index)) {
if (role == Qt::DisplayRole || role == Qt::EditRole) {
switch (index.column()) {
case Name: return item->name();
case Today: return item->todaysTime();
case Total: return item->totalTime();
default: Q_ASSERT(false);
}
}
if (role == Qt::CheckStateRole && index.column() == Name)
return static_cast<int>(item->isDone() ? Qt::Checked
: Qt::Unchecked);
if (role == Qt::TextAlignmentRole) {
if (index.column() == Name)
return static_cast<int>(Qt::AlignVCenter|
Qt::AlignLeft);
return static_cast<int>(Qt::AlignVCenter|Qt::AlignRight);
}
if (role == Qt::DecorationRole && index.column() == Today &&
timedItem && item == timedItem && !m_icon.isNull())
return m_icon;
}
return QVariant();
}
int TreeModel::rowCount(const QModelIndex &parent) const
{
if (parent.isValid() && parent.column() != 0)
return 0;
TaskItem *parentItem = itemForIndex(parent);
return parentItem ? parentItem->childCount() : 0;
}
QModelIndex TreeModel::moveUp(const QModelIndex &index)
{
if (!index.isValid() || index.row() <= 0)
return index;
TaskItem *item = itemForIndex(index);
Q_ASSERT(item);
TaskItem *parent = item->parent();
Q_ASSERT(parent);
return moveItem(parent, index.row(), index.row() - 1);
}
void ThumbnailPage::importList(const QModelIndexList& list)
{
d->mUrlList.clear();
Q_FOREACH(const QModelIndex & index, list) {
KFileItem item = itemForIndex(index);
if (!ArchiveUtils::fileItemIsDirOrArchive(item)) {
d->mUrlList << item.url();
}
// FIXME: Handle dirs (do we want to import recursively?)
}
QModelIndex ProjectModel::index(int row, int column, const QModelIndex& parent) const
{
ProjectNode* parentNode = nodeForIndex(parent);
//kWarning()<<(sizeof(ProjectNode))<<nodeCounter;
if (row>=parentNode->rows.size())
{
kWarning()<<"SHIT HAPPENED WITH INDEXES"<<row<<parentNode->rows.size()<<itemForIndex(parent).url();
return QModelIndex();
}
return createIndex(row, column, parentNode->rows.at(row));
}
QModelIndex TreeModel::index(int row, int column,
const QModelIndex &parent) const
{
if (!rootItem || row < 0 || column < 0 || column >= ColumnCount
|| (parent.isValid() && parent.column() != 0))
return QModelIndex();
TaskItem *parentItem = itemForIndex(parent);
Q_ASSERT(parentItem);
if (TaskItem *item = parentItem->childAt(row))
return createIndex(row, column, item);
return QModelIndex();
}
QModelIndex TreeModel::moveDown(const QModelIndex &index)
{
if (!index.isValid())
return index;
TaskItem *item = itemForIndex(index);
Q_ASSERT(item);
TaskItem *parent = item->parent();
int newRow = index.row() + 1;
if (!parent || parent->childCount() <= newRow)
return index;
return moveItem(parent, index.row(), newRow);
}
bool TreeModel::removeRows(int row, int count,
const QModelIndex &parent)
{
if (!rootItem)
return false;
TaskItem *item = parent.isValid() ? itemForIndex(parent)
: rootItem;
beginRemoveRows(parent, row, row + count - 1);
for (int i = 0; i < count; ++i)
delete item->takeChild(row);
endRemoveRows();
return true;
}
QVariantMap DirModel::get(int i) const
{
QModelIndex modelIndex = index(i, 0);
KFileItem item = itemForIndex(modelIndex);
QString url = item.url().toString();
QString mimeType = item.mimetype();
QVariantMap ret;
ret.insert(QStringLiteral("url"), QVariant(url));
ret.insert(QStringLiteral("mimeType"), QVariant(mimeType));
return ret;
}
DTrashItemInfoList DTrashItemModel::itemsForIndexes(const QList<QModelIndex>& indexes)
{
DTrashItemInfoList items;
foreach (const QModelIndex& index, indexes)
{
if (!index.isValid())
continue;
items << itemForIndex(index);
}
return items;
}
bool TreeModel::insertRows(int row, int count,
const QModelIndex &parent)
{
if (!rootItem)
rootItem = new TaskItem;
TaskItem *parentItem = parent.isValid() ? itemForIndex(parent)
: rootItem;
beginInsertRows(parent, row, row + count - 1);
for (int i = 0; i < count; ++i) {
TaskItem *item = new TaskItem(tr("New Task"), false);
parentItem->insertChild(row, item);
}
endInsertRows();
return true;
}
QModelIndex TreeModel::paste(const QModelIndex &index)
{
if (!index.isValid() || !cutItem)
return index;
TaskItem *sibling = itemForIndex(index);
Q_ASSERT(sibling);
TaskItem *parent = sibling->parent();
Q_ASSERT(parent);
int row = parent->rowOfChild(sibling) + 1;
beginInsertRows(index.parent(), row, row);
parent->insertChild(row, cutItem);
TaskItem *child = cutItem;
cutItem = 0;
endInsertRows();
return createIndex(row, 0, child);
}
bool QFPseudoTreeModel::isLastInFolder(const QModelIndex &index) const
{
if (!index.isValid()) return true;
QFPseudoTreeModelItem *childItem = itemForIndex(index);
if (!childItem) return true;
for (int i=0; i<m_folders.size(); i++) {
if (m_items.contains(m_folders[i])) {
for (int j=0; j<m_items[m_folders[i]].size(); j++) {
if (m_items[m_folders[i]].value(j, NULL)==childItem) {
return j==m_items[m_folders[i]].size()-1;
}
}
}
}
return true;
}
void ProjectModel::slotFileSaved(const KUrl& url)
{
QModelIndex index = indexForUrl(url);
if (!index.isValid())
return;
QList<KFileItem> files;
files.append(itemForIndex(index));
UpdateStatsJob* j = new UpdateStatsJob(files);
connect(j,SIGNAL(done(ThreadWeaver::Job*)),
this,SLOT(finishSingleMetadataUpdate(ThreadWeaver::Job*)));
m_weaver->enqueue(j);
}
QMimeData *TreeModel::mimeData(const QModelIndexList &indexes) const
{
Q_ASSERT(indexes.count());
if (indexes.count() != 1)
return 0;
if (TaskItem *item = itemForIndex(indexes.at(0))) {
QMimeData *mimeData = new QMimeData;
QByteArray xmlData;
QXmlStreamWriter writer(&xmlData);
writeTaskAndChildren(&writer, item);
mimeData->setData(MimeType, qCompress(xmlData,
MaxCompression));
return mimeData;
}
return 0;
}
QModelIndex TreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
if (TaskItem *childItem = itemForIndex(index)) {
if (TaskItem *parentItem = childItem->parent()) {
if (parentItem == rootItem)
return QModelIndex();
if (TaskItem *grandParentItem = parentItem->parent()) {
int row = grandParentItem->rowOfChild(parentItem);
return createIndex(row, 0, parentItem);
}
}
}
return QModelIndex();
}
bool TreeModel::setData(const QModelIndex &index,
const QVariant &value, int role)
{
if (!index.isValid() || index.column() != Name)
return false;
if (TaskItem *item = itemForIndex(index)) {
if (role == Qt::EditRole)
item->setName(value.toString());
else if (role == Qt::CheckStateRole)
item->setDone(value.toBool());
else
return false;
emit dataChanged(index, index);
return true;
}
return false;
}
QVariant DirModel::data( const QModelIndex & index, int role ) const
{
if (role != Qt::DisplayRole) {
return KDirModel::data(index, role);
}
KFileItem item = itemForIndex(index);
if(item.isDesktopFile()) {
KDesktopFile f(item.url().path());
QString name = f.readName();
if(!name.isEmpty()){
return name;
}
}
return item.text();
}
QMimeData* FeedsModel::mimeData(const QModelIndexList& indexes) const {
auto* mime_data = new QMimeData();
QByteArray encoded_data;
QDataStream stream(&encoded_data, QIODevice::WriteOnly);
foreach (const QModelIndex& index, indexes) {
if (index.column() != 0) {
continue;
}
RootItem* item_for_index = itemForIndex(index);
if (item_for_index->kind() != RootItemKind::Root) {
stream << quintptr(item_for_index);
}
}
mime_data->setData(QSL(MIME_TYPE_ITEM_POINTER), encoded_data);
return mime_data;
}
QModelIndex TreeModel::demote(const QModelIndex &index)
{
if (!index.isValid())
return index;
TaskItem *item = itemForIndex(index);
Q_ASSERT(item);
TaskItem *parent = item->parent();
Q_ASSERT(parent);
int row = parent->rowOfChild(item);
if (row == 0)
return index; // No preceding sibling to move this under
TaskItem *child = parent->takeChild(row);
Q_ASSERT(child == item);
TaskItem *sibling = parent->childAt(row - 1);
Q_ASSERT(sibling);
sibling->addChild(child);
QModelIndex newIndex = createIndex(sibling->childCount() - 1, 0,
child);
emit dataChanged(newIndex, newIndex);
return newIndex;
}
QModelIndex TreeModel::promote(const QModelIndex &index)
{
if (!index.isValid())
return index;
TaskItem *item = itemForIndex(index);
Q_ASSERT(item);
TaskItem *parent = item->parent();
Q_ASSERT(parent);
if (parent == rootItem)
return index; // Already a top-level item
int row = parent->rowOfChild(item);
TaskItem *child = parent->takeChild(row);
Q_ASSERT(child == item);
TaskItem *grandParent = parent->parent();
Q_ASSERT(grandParent);
row = grandParent->rowOfChild(parent) + 1;
grandParent->insertChild(row, child);
QModelIndex newIndex = createIndex(row, 0, child);
emit dataChanged(newIndex, newIndex);
return newIndex;
}
bool TreeModel::dropMimeData(const QMimeData *mimeData,
Qt::DropAction action, int row, int column,
const QModelIndex &parent)
{
if (action == Qt::IgnoreAction)
return true;
if (action != Qt::MoveAction || column > 0 ||
!mimeData || !mimeData->hasFormat(MimeType))
return false;
if (TaskItem *item = itemForIndex(parent)) {
emit stopTiming();
QByteArray xmlData = qUncompress(mimeData->data(MimeType));
QXmlStreamReader reader(xmlData);
if (row == -1)
row = parent.isValid() ? parent.row()
: rootItem->childCount();
beginInsertRows(parent, row, row);
readTasks(&reader, item);
endInsertRows();
return true;
}
return false;
}
QUrl SortedDirModel::urlForIndex(const QModelIndex& index) const
{
KFileItem item = itemForIndex(index);
return item.isNull() ? QUrl() : item.url();
}
bool TreeModel::isTimedItem(const QModelIndex &index)
{
return timedItem && itemForIndex(index) == timedItem;
}
/**
* we use QRect to pass data through QVariant tunnel
*
* order is tran, untr, fuzzy
* left() top() width()
*
*/
QVariant ProjectModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
return QVariant();
const ProjectModelColumns& column=(ProjectModelColumns)index.column();
ProjectNode* node = nodeForIndex(index);
QModelIndex internalIndex = poOrPotIndexForOuter(index);
if (!internalIndex.isValid())
return QVariant();
KFileItem item=itemForIndex(index);
bool isDir = item.isDir();
int translated = node->translatedAsPerRole();
int fuzzy = node->fuzzyAsPerRole();
int untranslated = node->untranslated;
bool hasStats = translated != -1;
switch(role)
{
case Qt::DisplayRole:
switch (column)
{
case FileName: return item.text();
case Graph: return hasStats?QRect(translated, untranslated, fuzzy, 0):QVariant();
case TotalCount: return hasStats?(translated + untranslated + fuzzy):QVariant();
case TranslatedCount:return hasStats?translated:QVariant();
case FuzzyCount: return hasStats?fuzzy:QVariant();
case UntranslatedCount:return hasStats?untranslated:QVariant();
case SourceDate: return node->sourceDate;
case TranslationDate:return node->translationDate;
case LastTranslator:return node->lastTranslator;
default: return QVariant();
}
case Qt::ToolTipRole:
switch (column)
{
case FileName: return item.text();
default: return QVariant();
}
case KDirModel::FileItemRole:
return QVariant::fromValue(item);
case Qt::DecorationRole:
switch (column)
{
case FileName:
if (isDir)
return m_dirIcon;
if (hasStats && fuzzy == 0 && untranslated == 0)
return m_poComplIcon;
else if (node->poRowNumber != -1)
return m_poIcon;
else if (node->potRowNumber != -1)
return m_potIcon;
default:
return QVariant();
}
case FuzzyUntrCountRole:
return item.isFile()?(fuzzy + untranslated):0;
case FuzzyCountRole:
return item.isFile()?fuzzy:0;
case UntransCountRole:
return item.isFile()?untranslated:0;
case TemplateOnlyRole:
return item.isFile()?(node->poRowNumber == -1):0;
case TransOnlyRole:
return item.isFile()?(node->potRowNumber == -1):0;
case TotalRole:
return hasStats?(fuzzy + untranslated + translated):0;
default:
return QVariant();
}
}
