Turn metadata display into a QTreeView

This wasn't as easy as it sounds. I had to completely redesign the
SeriesMetadataModel. Now it's a hybrid between a ListModel and a
TreeModel. The actual data is held in a QList<QVariant>, the tree is
only for display.

4 files changed, 161 insertions, 182 deletions

diff --git a/newmoviewizard.cpp b/newmoviewizard.cpp
index e479a33..f482d57 100644
--- a/newmoviewizard.cpp
+++ b/newmoviewizard.cpp
@@ -166,20 +166,18 @@ void NewMovieWizard::doMetadata(const QModelIndex &idx){
 	int seriesPartId = idx.data(SeriesTreeModel::SeriesPartIdRole).toInt();
 	SeriesMetadataModel *metadataModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));
 	metadataModel->populate(seriesPartId);
-	QModelIndex curIdx = metadataModel->find(seriesPartId, SeriesMetadataModel::SeriesPartId);
-	if(idx.isValid()){
-		QModelIndex parent = curIdx.parent();
-		int row = curIdx.row();
-		metadataModel->setData(parent, field("year"), row, SeriesMetadataModel::ReleaseYear);
-		metadataModel->setData(parent, mMetadataPage->sourceMedium(), row, SeriesMetadataModel::SourceMedium);
-		metadataModel->setData(parent, field("subject"), row, SeriesMetadataModel::Subject);
-		metadataModel->setData(parent, mMetadataPage->releaseGroup(), row, SeriesMetadataModel::ReleaseGroup);
-		metadataModel->setData(parent, field("encoder"), row, SeriesMetadataModel::EncoderOpts);
-		metadataModel->setData(parent, mMetadataPage->comment(), row, SeriesMetadataModel::Comment);
-		metadataModel->setData(parent, field("passes"), row, SeriesMetadataModel::Passes);
-		metadataModel->setData(parent, QDate::currentDate(), row, SeriesMetadataModel::Added);
-		metadataModel->update();
-	}
+	QList<QVariant> metaData;
+	for(int i = 0; i < metadataModel->numFields(); ++i){
+		metaData << QVariant();
+	}
+	metaData[SeriesMetadataModel::ReleaseYear] = field("year");
+	metaData[SeriesMetadataModel::Subject] = field("subject");
+	metaData[SeriesMetadataModel::EncoderOpts] = field("encoder");
+	metaData[SeriesMetadataModel::Passes] = field("passes");
+	metaData[SeriesMetadataModel::SourceMedium] = mMetadataPage->sourceMedium();
+	metaData[SeriesMetadataModel::ReleaseGroup] = mMetadataPage->releaseGroup();
+	metaData[SeriesMetadataModel::Added] = QDate::currentDate();
+	metadataModel->setAllData(seriesPartId, metaData);
 }
 
 MovieInfoPage::MovieInfoPage(QWidget *parent) : QWizardPage(parent){
diff --git a/seriesmetadatamodel.cpp b/seriesmetadatamodel.cpp
index 81845e3..bd67e93 100644
--- a/seriesmetadatamodel.cpp
+++ b/seriesmetadatamodel.cpp
@@ -16,104 +16,81 @@
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QGroupBox>
-#include <QPalette>
 #include <QSettings>
 #include <QColor>
-#include <QScrollArea>
+#include <QTreeView>
 
 #include "seriesmetadatamodel.h"
 #include "smtreeitem.h"
 #include "smglobals.h"
 #include "helper.h"
 
-SeriesMetadataModel::SeriesMetadataModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mColumns(9), mDataChanged(false), mCurrentId(-1){
+SeriesMetadataModel::SeriesMetadataModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mColumns(3), mDataFields(8), mCurrentId(-1){
 	//setup database
 	mDb = QSqlDatabase::database("treedb");
 	mPopulateQuery = new QSqlQuery(mDb);
-	mPopulateQuery->prepare("SELECT iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded FROM metadata WHERE iseriespart_id = :id");
+	mPopulateQuery->prepare("SELECT sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded FROM metadata WHERE iseriespart_id = :id");
 	mPresentQuery = new QSqlQuery(mDb);
 	mPresentQuery->prepare("SELECT COUNT(*) FROM metadata WHERE iseriespart_id = :id");
-	mUpdateQuery = new QSqlQuery(mDb);
-	mUpdateQuery->prepare("UPDATE metadata SET sireleaseyear = :year, tsourcemedium = :source, tsubject = :subject, treleasegroup = :group, tencoderopts = :encopts, tcomment = :comment, sipasses = :passes, dadded = :added WHERE iseriespart_id = :id");
+	mUpdateAllQuery = new QSqlQuery(mDb);
+	mUpdateAllQuery->prepare("UPDATE metadata SET sireleaseyear = :year, tsourcemedium = :source, tsubject = :subject, treleasegroup = :group, tencoderopts = :encopts, tcomment = :comment, sipasses = :passes, dadded = :added WHERE iseriespart_id = :id");
 	mInsertQuery = new QSqlQuery(mDb);
 	mInsertQuery->prepare("INSERT INTO metadata (iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded) VALUES(:id, :year, :source, :subject, :group, :encopts, :comment, :passes, :added)");
 
 	//misc
-	mColumnNames.insert(SeriesPartId, "iseriespart_id");
-	mColumnNames.insert(ReleaseYear, "sireleaseyear");
-	mColumnNames.insert(SourceMedium, "tsourcemedium");
-	mColumnNames.insert(Subject, "tsubject");
-	mColumnNames.insert(ReleaseGroup, "treleasegroup");
-	mColumnNames.insert(EncoderOpts, "tencoderopts");
-	mColumnNames.insert(Comment, "tcomment");
-	mColumnNames.insert(Passes, "sipasses");
-	mColumnNames.insert(Added, "dadded");
+	mDbColumnNames.insert(ReleaseYear, "sireleaseyear");
+	mDbColumnNames.insert(SourceMedium, "tsourcemedium");
+	mDbColumnNames.insert(Subject, "tsubject");
+	mDbColumnNames.insert(ReleaseGroup, "treleasegroup");
+	mDbColumnNames.insert(EncoderOpts, "tencoderopts");
+	mDbColumnNames.insert(Comment, "tcomment");
+	mDbColumnNames.insert(Passes, "sipasses");
+	mDbColumnNames.insert(Added, "dadded");
+
+	for(int i = 0; i < mDataFields; ++i){
+		mData << QVariant();
+	}
+	mDisplayColumnNames.insert(ReleaseYear, "Release year");
+	mDisplayColumnNames.insert(SourceMedium, "Source medium");
+	mDisplayColumnNames.insert(Subject, "Usenet subject");
+	mDisplayColumnNames.insert(ReleaseGroup, "Release group");
+	mDisplayColumnNames.insert(EncoderOpts, "Encoder options");
+	mDisplayColumnNames.insert(Comment, "Comment");
+	mDisplayColumnNames.insert(Passes, "Encoding passes");
+	mDisplayColumnNames.insert(Added, "Date added");
 }
 
 SeriesMetadataModel::~SeriesMetadataModel(){
 	delete mPopulateQuery;
 	delete mPresentQuery;
-	delete mUpdateQuery;
+	delete mUpdateAllQuery;
 	delete mInsertQuery;
 	mDb = QSqlDatabase();
 }
 
-QVariant SeriesMetadataModel::data(const QModelIndex &index, int role) const{
-	if(!index.isValid()){
+QVariant SeriesMetadataModel::data(int column) const {
+	if((column < 0 ) || (column >= mDataFields)){
 		return QVariant();
 	}
-	SmTreeItem *item = itemAt(index);
-	if(role == SeriesPartIdRole){
-		return item->data(SeriesPartId);
-	}
-	if(role == ReleaseYearRole){
-		return item->data(ReleaseYear);
-	}
-	if(role == SourceMediumRole){
-		return item->data(SourceMedium);
-	}
-	if(role == SubjectRole){
-		return item->data(Subject);
-	}
-	if(role == ReleaseGroupRole){
-		return item->data(ReleaseGroup);
-	}
-	if(role == EncoderOptsRole){
-		return item->data(EncoderOpts);
-	}
-	if(role == CommentRole){
-		return item->data(Comment);
-	}
-	if(role == PassesRole){
-		return item->data(Passes);
-	}
-	if(role == AddedRole){
-		return item->data(Added);
-	}
-	return SmTreeModel::data(index, role);
+	return mData.at(column);
 }
 
 const QList<QVariant> SeriesMetadataModel::dataList(const QModelIndex &index) const{
 	if(!index.isValid()){
 		return QList<QVariant>();
 	}
-	QList<QVariant> retval;
-	SmTreeItem *item = itemAt(index);
-	for(int i = 0; i < mColumns; ++i){
-		retval << item->data(i);
-	}
-	return retval;
+	return mData;
 }
 
 const QList<QVariant> SeriesMetadataModel::fieldList(int field, bool distinct) const{
-	if(field >= mColumns){
+	if(field >= mDataFields){
 		return QList<QVariant>();
 	}
 	QString queryTempl;
 	if(distinct){
-		queryTempl = QString("SELECT DISTINCT(%1) FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
+		queryTempl = QString("SELECT DISTINCT(%1) FROM metadata ORDER BY %1").arg(mDbColumnNames.value(field));
 	}else{
-		queryTempl = QString("SELECT %1 FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
+		queryTempl = QString("SELECT %1 FROM metadata ORDER BY %1").arg(mDbColumnNames.value(field));
 	}
 	QList<QVariant> retval;
 	QSqlQuery query(queryTempl, mDb);
@@ -127,16 +104,28 @@ bool SeriesMetadataModel::setData(const QModelIndex &index, const QVariant &valu
 	if(!index.isValid()){
 		return false;
 	}
-	mDataChanged = true;
-	return SmTreeModel::setData(index, value, role);
+	if(index.row() >= mDataFields){
+		return false;
+	}
+	if(role != Qt::EditRole){
+		return false;
+	}
+	SmTreeItem *item = static_cast<SmTreeItem*>(index.internalPointer());
+	Q_ASSERT(item);
+	item->setData(index.column(), value);
+	mData[item->data(2).toInt()] = value;
+	update();
+	return true;
 }
 
-bool SeriesMetadataModel::setData(const QModelIndex &parent, const QVariant &value, int row, int column, int role){
-	if(row >= mColumns){
-		return false;
+void SeriesMetadataModel::setAllData(int seriesId, const QList<QVariant> &data){
+	if(data.size() != mDataFields){
+		return;
 	}
-	QModelIndex idx = index(row, column, parent);
-	return setData(idx, value, role);
+	mCurrentId = seriesId;
+	mData = data;
+	createTree(mData);
+	update();
 }
 
 bool SeriesMetadataModel::hasRecord(int seriesPartId) const{
@@ -150,54 +139,65 @@ bool SeriesMetadataModel::hasRecord(int seriesPartId) const{
 	return (count > 0);
 }
 
+Qt::ItemFlags SeriesMetadataModel::flags(const QModelIndex &index) const{
+	Qt::ItemFlags retval;
+	retval |= Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+	if(index.column() == 1){
+		retval |= Qt::ItemIsEditable;
+	}
+	return retval;
+}
+
 void SeriesMetadataModel::populate(int seriesPartId){
-	mDataChanged = false;
 	mCurrentId = seriesPartId;
-	SmTreeItem *rootItem = new SmTreeItem(mColumns);
-	rootItem->setData(SeriesPartId, -1);
 	if(hasRecord(seriesPartId)){
-		QList<QVariant> items;
 		mPopulateQuery->bindValue(":id", seriesPartId);
-		mPopulateQuery->exec();
-		while(mPopulateQuery->next()){
-			for(int i = 0; i < mColumns; ++i){
-				items << mPopulateQuery->value(i);
+		if(mPopulateQuery->exec()){
+			while(mPopulateQuery->next()){
+				for(int i = 0; i < mDataFields; ++i){
+					mData[i] = mPopulateQuery->value(i);
+				}
+
 			}
 		}
-		SmTreeItem *childItem = new SmTreeItem(items, rootItem);
-		rootItem->appendChild(childItem);
 	}else{
-		SmTreeItem *childItem = new SmTreeItem(mColumns, rootItem);
-		childItem->setData(0, seriesPartId);
-		rootItem->appendChild(childItem);
+		for(int i = 0; i < numFields(); ++i){
+			mData[i] = QVariant();
+		}
 	}
-	setRoot(rootItem);
+	createTree(mData);
 }
 
 void SeriesMetadataModel::update(){
 	QSqlQuery *query;
 	if(hasRecord(mCurrentId)){
-		query = mUpdateQuery;
+		query = mUpdateAllQuery;
 	}else{
 		query = mInsertQuery;
 	}
-	QModelIndex curIdx = find(mCurrentId, SeriesPartId);
-	if(!curIdx.isValid()){
-		return;
-	}
-	SmTreeItem *item = itemAt(curIdx);
 	query->bindValue(":id", mCurrentId);
-	query->bindValue(":year", item->data(ReleaseYear));
-	query->bindValue(":source", item->data(SourceMedium));
-	query->bindValue(":subject", item->data(Subject));
-	query->bindValue(":group", item->data(ReleaseGroup));
-	query->bindValue(":encopts", item->data(EncoderOpts));
-	query->bindValue(":comment", item->data(Comment));
-	query->bindValue(":passes", item->data(Passes));
-	query->bindValue(":added", item->data(Added));
+	query->bindValue(":year", mData.at(ReleaseYear));
+	query->bindValue(":source", mData.at(SourceMedium));
+	query->bindValue(":subject", mData.at(Subject));
+	query->bindValue(":group", mData.at(ReleaseGroup));
+	query->bindValue(":encopts", mData.at(EncoderOpts));
+	query->bindValue(":comment", mData.at(Comment));
+	query->bindValue(":passes", mData.at(Passes));
+	query->bindValue(":added", mData.at(Added));
 	query->exec();
 }
 
+void SeriesMetadataModel::createTree(const QList<QVariant> &data){
+	SmTreeItem *rootItem = new SmTreeItem(mColumns);
+	for(int i = 0; i < mDataFields; ++i){
+		QList<QVariant> itemData;
+		itemData << mDisplayColumnNames.value(i) << data.at(i) << i;
+		SmTreeItem *item = new SmTreeItem(itemData, rootItem);
+		rootItem->appendChild(item);
+	}
+	setRoot(rootItem);
+}
+
 MetadataWidget::MetadataWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f){
 	//model
 	mModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));
@@ -207,23 +207,23 @@ MetadataWidget::MetadataWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(par
 	mReleaseYear = new QSpinBox;
 	mReleaseYear->setMaximum(3000);
 	mReleaseYear->setMinimum(1900);
-	rowLayout->addRow(tr("Release year"), mReleaseYear);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::ReleaseYear), mReleaseYear);
 	mReleaseGroup = new QComboBox;
 	mPasses = new QSpinBox;
-	rowLayout->addRow(tr("Encoding passes"), mPasses);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Passes), mPasses);
 	mReleaseGroup->setEditable(true);
-	rowLayout->addRow(tr("Release group"), mReleaseGroup);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::ReleaseGroup), mReleaseGroup);
 	mSourceMedium = new QComboBox;
 	mSourceMedium->setEditable(true);
-	rowLayout->addRow(tr("Source medium"), mSourceMedium);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::SourceMedium), mSourceMedium);
 	mSubject = new QLineEdit;
-	rowLayout->addRow(tr("Usenet subject"), mSubject);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Subject), mSubject);
 	mEncoderOpts = new QLineEdit;
-	rowLayout->addRow(tr("Encoder options"), mEncoderOpts);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::EncoderOpts), mEncoderOpts);
 	mAdded = new QDateEdit(QDate::currentDate());
-	rowLayout->addRow(tr("Date added"), mAdded);
+	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Added), mAdded);
 	QVBoxLayout *commentLayout = new QVBoxLayout;
-	QLabel *commentLabel = new QLabel(tr("Comment"));
+	QLabel *commentLabel = new QLabel(mModel->columnName(SeriesMetadataModel::Comment));
 	commentLayout->addWidget(commentLabel);
 	mComment = new QPlainTextEdit;
 	commentLayout->addWidget(mComment);
@@ -244,38 +244,35 @@ void MetadataWidget::setSeriesPartId(int id){
 		return;
 	}
 	mModel->populate(id);
-	QModelIndex idx = mModel->find(id, SeriesMetadataModel::SeriesPartId);
-	if(idx.isValid()){
-		mReleaseYear->setValue(idx.data(SeriesMetadataModel::ReleaseYearRole).toInt());
-		mPasses->setValue(idx.data(SeriesMetadataModel::PassesRole).toInt());
-		int relGroupIdx = mReleaseGroup->findText(idx.data(SeriesMetadataModel::ReleaseGroupRole).toString());
-		if(relGroupIdx != -1){
-			mReleaseGroup->setCurrentIndex(relGroupIdx);
-		}
-		int sourceMedIdx = mSourceMedium->findData(idx.data(SeriesMetadataModel::PassesRole));
-		if(sourceMedIdx != -1){
-			mSourceMedium->setCurrentIndex(sourceMedIdx);
-		}
-		mSubject->setText(idx.data(SeriesMetadataModel::SubjectRole).toString());
-		mEncoderOpts->setText(idx.data(SeriesMetadataModel::EncoderOptsRole).toString());
-		mAdded->setDate(idx.data(SeriesMetadataModel::AddedRole).toDate());
-		mComment->setPlainText(idx.data(SeriesMetadataModel::CommentRole).toString());
+	mReleaseYear->setValue(mModel->data(SeriesMetadataModel::ReleaseYear).toInt());
+	mPasses->setValue(mModel->data(SeriesMetadataModel::Passes).toInt());
+	mSubject->setText(mModel->data(SeriesMetadataModel::Subject).toString());
+	mEncoderOpts->setText(mModel->data(SeriesMetadataModel::EncoderOpts).toString());
+	mAdded->setDate(mModel->data(SeriesMetadataModel::Added).toDate());
+	int relGroupIdx = mReleaseGroup->findText(mModel->data(SeriesMetadataModel::ReleaseGroup).toString());
+	if(relGroupIdx != -1){
+		mReleaseGroup->setCurrentIndex(relGroupIdx);
+	}
+	int sourceMediumIdx = mSourceMedium->findData(mModel->data(SeriesMetadataModel::SourceMedium).toString());
+	if(sourceMediumIdx != -1){
+		mSourceMedium->setCurrentIndex(sourceMediumIdx);
 	}
 }
 
 void MetadataWidget::accept(){
-	QModelIndex curIdx = mModel->find(mModel->currentId(), SeriesMetadataModel::SeriesPartId);
-	QModelIndex parent = curIdx.parent();
-	int row = curIdx.row();
-	mModel->setData(parent, mReleaseYear->value(), row, SeriesMetadataModel::ReleaseYear);
-	mModel->setData(parent, mPasses->value(), row, SeriesMetadataModel::Passes);
-	mModel->setData(parent, mReleaseGroup->currentText(), row, SeriesMetadataModel::ReleaseGroup);
-	mModel->setData(parent, mSourceMedium->currentText(), row, SeriesMetadataModel::SourceMedium);
-	mModel->setData(parent, mSubject->text(), row, SeriesMetadataModel::Subject);
-	mModel->setData(parent, mEncoderOpts->text(), row, SeriesMetadataModel::EncoderOpts);
-	mModel->setData(parent, mAdded->date(), row, SeriesMetadataModel::Added);
-	mModel->setData(parent, mComment->toPlainText(), row, SeriesMetadataModel::Comment);
-	mModel->update();
+	QList<QVariant> metaData;
+	for(int i = 0; i < mModel->numFields(); ++i){
+		metaData << QVariant();
+	}
+
+	metaData[SeriesMetadataModel::ReleaseYear] = mReleaseYear->value();
+	metaData[SeriesMetadataModel::Subject] = mSubject->text();
+	metaData[SeriesMetadataModel::EncoderOpts] = mEncoderOpts->text();
+	metaData[SeriesMetadataModel::Passes] = mPasses->value();
+	metaData[SeriesMetadataModel::SourceMedium] = mSourceMedium->currentText();
+	metaData[SeriesMetadataModel::ReleaseGroup] = mReleaseGroup->currentText();
+	metaData[SeriesMetadataModel::Added] = mAdded->date();
+	mModel->setAllData(mModel->currentId(), metaData);
 }
 
 MetadataDisplay::MetadataDisplay(QWidget *parent) : QWidget(parent){
@@ -285,13 +282,12 @@ MetadataDisplay::MetadataDisplay(QWidget *parent) : QWidget(parent){
 	//display
 	QGroupBox *gb = new QGroupBox(tr("Metadata"));
 	QHBoxLayout *gbLayout = new QHBoxLayout;
-	mDisplay = new QLabel(tr("No metadata available"));
-	mDisplay->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
-	mDisplay->setWordWrap(true);
-	QScrollArea *sa = new QScrollArea;
-	sa->setWidgetResizable(true);
-	sa->setWidget(mDisplay);
-	gbLayout->addWidget(sa);
+	mDisplay = new QTreeView;
+	mDisplay->setModel(mModel);
+	mDisplay->setSelectionBehavior(QAbstractItemView::SelectRows);
+	mDisplay->setAlternatingRowColors(true);
+	mDisplay->setHeaderHidden(true);
+	gbLayout->addWidget(mDisplay);
 	gb->setLayout(gbLayout);
 
 	//laoyut
@@ -301,29 +297,8 @@ MetadataDisplay::MetadataDisplay(QWidget *parent) : QWidget(parent){
 }
 
 void MetadataDisplay::setSeriesPartId(int seriesPartId){
-	//setup label + model
-	if(mModel->hasRecord(seriesPartId)){
-		mModel->populate(seriesPartId);
-		QSettings s;
-		QColor baseColor = s.value("ui/basecolor").value<QColor>();
-		QString baseHtml = Helper::colorToHtml(baseColor);
-		QColor alternateColor = s.value("ui/alternatecolor").value<QColor>();
-		QString alternateHtml = Helper::colorToHtml(alternateColor);
-		QModelIndex mdIdx = mModel->index(0, 0, QModelIndex());
-		QList<QVariant> metaData = mModel->dataList(mdIdx);
-		QString text("<table>");
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Release Year</span></td><td>%2</td></tr>")).arg(baseHtml).arg(QString::number(metaData.at(SeriesMetadataModel::ReleaseYear).toInt())));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Encoding Passes</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(QString::number(metaData.at(SeriesMetadataModel::Passes).toInt())));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Release Group</span></td><td>%2</td></tr>")).arg(baseHtml).arg(metaData.at(SeriesMetadataModel::ReleaseGroup).toString()));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Source Medium</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::SourceMedium).toString()));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Usenet Subject</span></td><td>%2</td></tr>")).arg(baseHtml).arg(metaData.at(SeriesMetadataModel::Subject).toString()));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Encoder Options</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::EncoderOpts).toString()));
-		QDate dateAdded = metaData.at(SeriesMetadataModel::Added).toDate();
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Added</span></td><td>%2</td></tr>")).arg(baseHtml).arg(dateAdded.toString(Qt::ISODate)));
-		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Comment</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::Comment).toString()));
-		text.append("</table>");
-		mDisplay->setText(text);
-	}else{
-		mDisplay->setText(tr("No metadata available"));
-	}
+	mModel->populate(seriesPartId);
+	mDisplay->setColumnHidden(2, true);
+	mDisplay->resizeColumnToContents(0);
+	mDisplay->resizeColumnToContents(1);
 }
diff --git a/seriesmetadatamodel.h b/seriesmetadatamodel.h
index a6c74c3..b96ef90 100644
--- a/seriesmetadatamodel.h
+++ b/seriesmetadatamodel.h
@@ -19,42 +19,48 @@ class QLineEdit;
 class QPlainTextEdit;
 class QDateEdit;
 class QLabel;
+class QTreeView;
 
 #include "smtreemodel.h"
 
 class SeriesMetadataModel : public SmTreeModel {
     Q_OBJECT
 	public:
-		enum CumstomRoles { SeriesPartIdRole = Qt::UserRole + 1, ReleaseYearRole = Qt::UserRole + 2, SourceMediumRole = Qt::UserRole + 3, SubjectRole = Qt::UserRole + 4, ReleaseGroupRole = Qt::UserRole + 5, EncoderOptsRole = Qt::UserRole + 6, CommentRole = Qt::UserRole + 7, PassesRole = Qt::UserRole + 8, AddedRole = Qt::UserRole + 9 };
-		enum Fields { SeriesPartId = 0, ReleaseYear = 1, SourceMedium = 2, Subject = 3, ReleaseGroup = 4, EncoderOpts = 5, Comment = 6, Passes = 7, Added = 8 };
+		enum Fields { ReleaseYear = 0, SourceMedium = 1, Subject = 2, ReleaseGroup = 3, EncoderOpts = 4, Comment = 5, Passes = 6, Added = 7 };
 		explicit SeriesMetadataModel(const QStringList &headers, QObject *parent = 0);
 		virtual ~SeriesMetadataModel();
 
 		//data
 		int currentId() const { return mCurrentId; }
-		virtual QVariant data(const QModelIndex &index, int role) const;
+		int numFields() const { return mDataFields; }
+		virtual QVariant data(int column) const;
 		const QList<QVariant> dataList(const QModelIndex &index) const;
 		const QList<QVariant> fieldList(int field, bool distinct = true) const;
 		virtual bool setData(const QModelIndex &index, const QVariant &value, int role);
-		virtual bool setData(const QModelIndex &parent, const QVariant &value, int row, int column, int role = Qt::EditRole);
+		void setAllData(int seriesId, const QList<QVariant> &data);
+		const QString columnName(int column) const { return mDisplayColumnNames.value(column); }
 
 		//misc
 		bool hasRecord(int seriesPartId) const;
+		Qt::ItemFlags flags(const QModelIndex &index) const;
 
 	public slots:
 		void populate(int seriesPartId);
 		void update();
 
 	private:
+		void createTree(const QList<QVariant> &data);
 		const int mColumns;
-		bool mDataChanged;
+		const int mDataFields;
 		int mCurrentId;
 		QSqlDatabase mDb;
 		QSqlQuery *mPopulateQuery;
 		QSqlQuery *mPresentQuery;
-		QSqlQuery *mUpdateQuery;
+		QSqlQuery *mUpdateAllQuery;
 		QSqlQuery *mInsertQuery;
-		QHash<int, QString> mColumnNames;
+		QHash<int, QString> mDbColumnNames;
+		QHash<int, QString> mDisplayColumnNames;
+		QList<QVariant> mData;
 };
 
 class MetadataWidget : public QWidget {
@@ -90,7 +96,7 @@ class MetadataDisplay : public QWidget {
 
 	private:
 		SeriesMetadataModel *mModel;
-		QLabel *mDisplay;
+		QTreeView *mDisplay;
 
 };
 
diff --git a/smtreemodel.cpp b/smtreemodel.cpp
index bcd1a8a..743e8be 100644
--- a/smtreemodel.cpp
+++ b/smtreemodel.cpp
@@ -84,7 +84,7 @@ const QHash<QString, int> SmTreeModel::headerData() const{
 
 bool SmTreeModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role){
 	if((orientation == Qt::Horizontal) && (role == Qt::DisplayRole)){
-		mRootItem->setData(section, value);
+		mHeaders[section] = value.toString();
 		emit headerDataChanged(orientation, section, section);
 		return true;
 	}