path: root/src/sessiontreemodel.cpp

#include "sessiontreemodel.h"

#include <QFileInfo>
#include <QIcon>
#include <QResource>
#include <QString>
#include <QtDebug>

#include "sessiontreeitem.h"
#include "vsession.h"
#include "sessionsiconholder.h"

SessionTreeModel::SessionTreeModel(QObject *parent)
    : QAbstractItemModel(parent) {
    root_ = new SessionTreeItem("dummy");
    iconHolder = new SessionsIconHolder(*this);
}

SessionTreeModel::~SessionTreeModel() {
    delete root_;
}

int SessionTreeModel::columnCount(const QModelIndex& /*parent*/) const {
    return 1;
}

int SessionTreeModel::rowCount(const QModelIndex &parent) const {
    SessionTreeItem* parentItem;
    if (parent.column() > 0) {
        return 0;
    }

    if (!parent.isValid()) {
        parentItem = root_;
    } else {
        parentItem = static_cast<SessionTreeItem*>(parent.internalPointer());
    }

    return parentItem->childCount();
}

QVariant SessionTreeModel::data(const QModelIndex &index, int role) const {
    if (!index.isValid()) {
        return QVariant();
    }

    SessionTreeItem* item =
            static_cast<SessionTreeItem*>(index.internalPointer());

    const Session* s = item->session();
    if (s) {
        if (role == Qt::DisplayRole)
            return s->shortDescription();
        if (role == Qt::ToolTipRole)
            return s->description();
        if (role == Qt::DecorationRole) {
            if (index.column() == 0) { // TODO: is this line needed?
                QString icon(s->icon());

                if (icon.isEmpty()) {
                    // Nothing...
                } else if (icon.startsWith("http://")) {
                    // try to load icon from url
                    QIcon url_icon = iconHolder->getIcon(QUrl(icon));
                    if (!url_icon.isNull()) {
                        return url_icon;
                    }
                } else if (QFileInfo(icon).isAbsolute()) {
                    // try to load icon from file
                    return QIcon(icon);
                } else {
                    // try to load icon from QResource
                    QIcon res_icon = iconHolder->getIcon(icon);
                    if (!res_icon.isNull()) {
                        return res_icon;
                    }
                }
                // fallback to os icon
                if (s->type() == Session::VSESSION) {
                    const VSession* vs = (VSession*) s;
                    QString os(vs->getAttribute("os", "param").toLower());
                    if (!os.isEmpty()) {
                        QIcon osi = iconHolder->getIcon(os);
                        if (!osi.isNull())
                            return osi;
                        if (os == "dos")
                            return iconHolder->getIcon("dos");
                        if (os.startsWith("windows7"))
                            return iconHolder->getIcon("win7");
                        if (os.startsWith("win31"))
                            return iconHolder->getIcon("win311");
                        if (os.startsWith("windows8"))
                            return iconHolder->getIcon("win8");
                        if (os.startsWith("win2000"))
                            return iconHolder->getIcon("win2000");
                        if (os.startsWith("winxp"))
                            return iconHolder->getIcon("winxp");
                        if (os.startsWith("debian"))
                            return iconHolder->getIcon("debian");
                        if (os.startsWith("ubuntu"))
                            return iconHolder->getIcon("ubuntu");
                        if (os.startsWith("win"))
                            return iconHolder->getIcon("windows");
                        if (os.contains("linux"))
                            return iconHolder->getIcon("linux");
                    }
                    if (vs->imgtype() == VMWARE)
                        return iconHolder->getIcon("vmware");
                    if (vs->imgtype() == VBOX)
                        return iconHolder->getIcon("virtualbox");
                }
            }
        }
    } else if (role == Qt::DisplayRole) {
        // this is a section item (X Sessions / Virtual Sessions)
        return item->text();
    }

    return QVariant();
}

Qt::ItemFlags SessionTreeModel::flags(const QModelIndex &index) const {
    if (!index.isValid()) {
        return 0;
    }

    SessionTreeItem* item =
            static_cast<SessionTreeItem*>(index.internalPointer());

    if (item->session()) {
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
    } else {
        return Qt::ItemIsEnabled;
    }
}

QVariant SessionTreeModel::headerData(int /*section*/,
                                      Qt::Orientation /*orientation*/,
                                      int /*role*/) const {
    return QVariant();
}

QModelIndex SessionTreeModel::index(int row, int column,
                                    const QModelIndex &parent) const {
    if (!hasIndex(row, column, parent)) {
        return QModelIndex();
    }

    SessionTreeItem *parentItem;

    if (!parent.isValid()) {
        parentItem = root_;
    } else {
        parentItem = static_cast<SessionTreeItem*>(parent.internalPointer());
    }

    SessionTreeItem *childItem = parentItem->child(row);
    if (childItem) {
        return createIndex(row, column, childItem);
    } else {
        return QModelIndex();
    }
}

QModelIndex SessionTreeModel::parent(const QModelIndex &index) const {
    if (!index.isValid()) {
        return QModelIndex();
    }

    SessionTreeItem *childItem =
            static_cast<SessionTreeItem*>(index.internalPointer());
    SessionTreeItem *parentItem = childItem->parent();

    if (parentItem == root_) {
        return QModelIndex();
    }

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

void SessionTreeModel::addItems(const QList<Session*>& sessions) {
    foreach (Session* s, sessions) {
        root_->appendChild(new SessionTreeItem(s, root_));
    }
}

void SessionTreeModel::addLabelItem(const QString& label) {
    root_->appendChild(new SessionTreeItem(label, root_));
}

void SessionTreeModel::removeItem(const QString& name) {
	for (int i = 0; i < root_->childCount(); ++i) {
		SessionTreeItem* item = root_->child(i);
		if (item->text() == name) {
			root_->removeChild(item);
		}
	}
}

QList<Session*> SessionTreeModel::lookForItem(const QString& label) {
	QList<Session*> result;

	if (label.startsWith("\"")) {
		QString searchTerm = label;
		searchTerm.remove(0, 1);
		if (label.endsWith("\"")) {
			searchTerm.chop(1);
		}
		QList<QString> items;
		items.append(searchTerm);
		for (int i = 0; i < root_->childCount(); ++i) {
			SessionTreeItem* item = root_->child(i);
			if (item->session()->containsKeywords(items)) {
				result.append(const_cast<Session*>(item->session()));
			}
		}
	} else {
		QList<QString> items = label.split(" ", QString::SkipEmptyParts);
		for (int i = 0; i < root_->childCount(); ++i) {
			SessionTreeItem* item = root_->child(i);
			if (item->session()->containsKeywords(items)) {
				result.append(const_cast<Session*>(item->session()));
			}
		}
	}

	return result;

}

void SessionTreeModel::updateView() {
	emit layoutChanged();
}