m_parent(parent),

m_fetchedDirectoryList(false)

{

{

if(m_parent)

return m_parent->m_children.indexOf(const_cast<RemoteModelItem*>(this));

return 0;

{

QList<RemoteModelItem*> items;

// Loop through all directory items

QJsonArray array = value.toArray();

for(int i=0;i<array.size();i++)

{

// Create a new model item with the specified parent

RemoteModelItem* item = new RemoteModelItem(parent);

// Save all relevant values. If one of the values isn't set in the JSON document, an empty string

// will be stored

item->setValue(RemoteModelColumnName, array.at(i).toObject().value("name"));

item->setValue(RemoteModelColumnType, array.at(i).toObject().value("type"));

item->setValue(RemoteModelColumnUrl, array.at(i).toObject().value("url"));

item->setValue(RemoteModelColumnVersion, array.at(i).toObject().value("version"));

item->setValue(RemoteModelColumnSize, array.at(i).toObject().value("size"));

item->setValue(RemoteModelColumnLastModified, array.at(i).toObject().value("last_modified"));

items.push_back(item);

}

return items;

QAbstractItemModel(parent),

rootItem(new RemoteModelItem()),

remoteDatabase(remote)

{

// Initialise list of column names

headerList << tr("Name") << tr("Version") << tr("Last modified") << tr("Size");

// Set up signals

connect(&remoteDatabase, &RemoteDatabase::gotDirList, this, &RemoteModel::parseDirectoryListing);

{

// Save settings

currentRootDirectory = url;

currentClientCert = cert;

// Fetch root directory and put the reply data under the root item

remoteDatabase.fetch(currentRootDirectory, RemoteDatabase::RequestTypeDirectory, currentClientCert, QModelIndex());

{

// Load new JSON root document assuming it's an array

QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());

if(doc.isNull() || !doc.isArray())

return;

QJsonArray array = doc.array();

// Get model index to store the new data under

QModelIndex parent = userdata.toModelIndex();

RemoteModelItem* parentItem = const_cast<RemoteModelItem*>(modelIndexToItem(parent));

// An invalid model index indicates that this is a new root item. This means the old one needs to be entirely deleted first.

if(!parent.isValid())

{

// Clear root item

beginResetModel();

delete rootItem;

rootItem = new RemoteModelItem();

endResetModel();

// Set parent model index and parent item to the new values

parent = QModelIndex();

parentItem = rootItem;

}

// Insert data

beginInsertRows(parent, 0, array.size());

QList<RemoteModelItem*> items = RemoteModelItem::loadArray(QJsonValue(array), parentItem);

foreach(RemoteModelItem* item, items)

parentItem->appendChild(item);

endInsertRows();

{

if(!hasIndex(row, column, parent))

return QModelIndex();

const RemoteModelItem* parentItem = modelIndexToItem(parent);

RemoteModelItem* childItem = parentItem->child(row);

if(childItem)

return createIndex(row, column, childItem);

else

return QModelIndex();

{

if(!index.isValid())

return QModelIndex();

const RemoteModelItem* childItem = modelIndexToItem(index);

RemoteModelItem* parentItem = childItem->parent();

if(parentItem == rootItem)

return QModelIndex();

return createIndex(parentItem->row(), 0, parentItem);

{

// Don't return data for invalid indices

if(!index.isValid())

return QVariant();

// Type of item

const RemoteModelItem* item = modelIndexToItem(index);

QString type = item->value(RemoteModelColumnType).toString();

// Decoration role? Only for first column!

if(role == Qt::DecorationRole && index.column() == 0)

{

// Use different icons depending on item type

if(type == "folder")

return QImage(":/icons/folder");

else if(type == "database")

return QImage(":/icons/database");

} else if(role == Qt::DisplayRole) {

// Display role?

// Return different value depending on column

switch(index.column())

{

case 0:

{

return item->value(RemoteModelColumnName);

}

case 1:

{

if(type == "folder")

return QVariant();

return QString::number(item->value(RemoteModelColumnVersion).toInt());

}

case 2:

{

return item->value(RemoteModelColumnLastModified);

}

case 3:

{

// Folders don't have a size

if(type == "folder")

return QVariant();

// Convert size to human readable format

float size = item->value(RemoteModelColumnSize).toInt();

QStringList list;

list << "KiB" << "MiB" << "GiB" << "TiB";

QStringListIterator it(list);

QString unit(tr("bytes"));

while(size >= 1024.0f && it.hasNext())

{

unit = it.next();

size /= 1024.0;

}

return QString().setNum(size, 'f', 2) + " " + unit;

}

}

}

return QVariant();

{

// Call default implementation for vertical headers and for non-display roles

if(role != Qt::DisplayRole || orientation != Qt::Horizontal)

return QAbstractItemModel::headerData(section, orientation, role);

// Return header string depending on column

return headerList.at(section);

{

if(parent.column() > 0)

return 0;

const RemoteModelItem* parentItem = modelIndexToItem(parent);

return parentItem->childCount();

{

if(!parent.isValid())

return true;

// If the item actually has children or is of type "folder" (and may have no children yet), we say that it actually has children

const RemoteModelItem* item = modelIndexToItem(parent);

return item->childCount() || item->value(RemoteModelColumnType) == "folder";

{

if(!parent.isValid())

return false;

// If the item is of type "folder" and we haven't tried fetching a directory listing yet, we indicate that there might be more data to load

const RemoteModelItem* item = modelIndexToItem(parent);

return item->value(RemoteModelColumnType) == "folder" && !item->fetchedDirectoryList();

{

// Can we even fetch more data?

if(!canFetchMore(parent))

return;

// Get parent item

RemoteModelItem* item = static_cast<RemoteModelItem*>(parent.internalPointer());

// Fetch item URL

item->setFetchedDirectoryList(true);

remoteDatabase.fetch(item->value(RemoteModelColumnUrl).toString(), RemoteDatabase::RequestTypeDirectory, currentClientCert, parent);