diff --git a/src/app/qml/PeruseMain.qml b/src/app/qml/PeruseMain.qml
index eb68f5e..0f30408 100644
--- a/src/app/qml/PeruseMain.qml
+++ b/src/app/qml/PeruseMain.qml
@@ -1,299 +1,299 @@
 /*
  * Copyright (C) 2015 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtQuick.Controls 1.4 as QtControls
 import QtQuick.Window 2.2
 
 import org.kde.kirigami 2.1 as Kirigami
 import org.kde.peruse 0.1 as Peruse
 import org.kde.contentlist 0.1
 
 /**
  * @brief main application window.
  * 
  * This splits the window in two sections:
  * - A section where you can select comics.
  * - A "global drawer" which can be used to switch between categories
  *   and access settings and the open book dialog.
  * 
  * The global drawer controls which is the main component on the left.
  * It initializes on WelcomePage. The category filters are each handled
  * by a BookShelf. The store page by Store and the settings by Settings.
  * 
  * This also controls the bookViewer, which is a Book object where the
  * main reading of comics is done.
  * 
  * There is also the PeruseContextDrawer, which is only accesible on the book
  * page and requires flicking in from the right.
  */
 Kirigami.ApplicationWindow {
     id: mainWindow;
     title: "Comic Book Reader";
     property int animationDuration: 200;
     property bool isLoading: true;
     pageStack.initialPage: welcomePage;
     visible: true;
     // If the controls are not visible, being able to drag the pagestack feels really weird,
     // so we just turn that ability off :)
     pageStack.interactive: controlsVisible;
     /// Which type of device we're running on. 0 is desktop, 1 is phone
     property int deviceType: PLASMA_PLATFORM.substring(0, 5) === "phone" ? 1 : 0;
     property int deviceTypeDesktop: 0;
     property int deviceTypePhone: 1;
 
     function showBook(filename, currentPage) {
         if(mainWindow.pageStack.lastItem.objectName === "bookViewer") {
             mainWindow.pageStack.pop();
         }
         mainWindow.pageStack.layers.push(bookViewer, { focus: true, file: filename, currentPage: currentPage })
         peruseConfig.bookOpened(filename);
     }
 
     Peruse.BookListModel {
         id: contentList;
         contentModel: ContentList {
             autoSearch: false
 
             onSearchCompleted: {
                 mainWindow.isLoading = false;
                 mainWindow.globalDrawer.actions = globalDrawerActions;
             }
 
             ContentQuery {
                 type: ContentQuery.Comics
                 locations: peruseConfig.bookLocations
             }
         }
         onCacheLoadedChanged: {
             if(!cacheLoaded) {
                 return;
             }
             contentList.contentModel.setKnownFiles(contentList.knownBookFiles());
             contentList.contentModel.startSearch()
         }
     }
 
     Peruse.Config {
         id: peruseConfig;
     }
     function homeDir() {
         return peruseConfig.homeDir();
     }
 
     header: Kirigami.ApplicationHeader {}
 
     contextDrawer: PeruseContextDrawer {
         id: contextDrawer;
     }
 
     globalDrawer: Kirigami.GlobalDrawer {
         title: i18nc("application title for the sidebar", "Peruse");
         titleIcon: "peruse";
         drawerOpen: PLASMA_PLATFORM.substring(0, 5) === "phone" ? false : true;
         modal: PLASMA_PLATFORM.substring(0, 5) === "phone" ? true : false;
         actions: []
     }
     property list<QtObject> globalDrawerActions: [
             Kirigami.Action {
                 text: i18nc("Switch to the welcome page", "Welcome");
                 iconName: "start-over";
                 checked: mainWindow.currentCategory === "welcomePage";
                 onTriggered: {
                     changeCategory(welcomePage);
                     pageStack.currentItem.updateRecent();
                 }
             },
             Kirigami.Action {
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing the most recently discovered books", "Recently Added Books");
                 iconName: "appointment-new";
                 checked: mainWindow.currentCategory === "bookshelfAdded";
                 onTriggered: changeCategory(bookshelfAdded);
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing items grouped by title", "Group by Title");
                 iconName: "view-media-title";
                 checked: mainWindow.currentCategory === "bookshelfTitle";
                 onTriggered: changeCategory(bookshelfTitle);
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing items grouped by author", "Group by Author");
                 iconName: "actor";
                 checked: mainWindow.currentCategory === "bookshelfAuthor";
                 onTriggered: changeCategory(bookshelfAuthor);
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing items grouped by series", "Group by Series");
                 iconName: "edit-group";
                 checked: currentCategory === "bookshelfSeries";
                 onTriggered: changeCategory(bookshelfSeries);
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing items grouped by publisher", "Group by Publisher");
                 iconName: "view-media-publisher";
                 checked: mainWindow.currentCategory === "bookshelfPublisher";
                 onTriggered: changeCategory(bookshelfPublisher);
             },
             Kirigami.Action {
                 text: i18nc("Switch to the listing page showing items grouped by their filesystem folder", "Filter by Folder");
                 iconName: "tag-folder";
                 checked: mainWindow.currentCategory === "bookshelfFolder";
                 onTriggered: changeCategory(bookshelfFolder);
             },
             Kirigami.Action {
             },
             Kirigami.Action {
                 text: i18nc("Open a book from somewhere on disk (uses the open dialog, or a drilldown on touch devices)", "Open Other...");
                 iconName: "document-open";
                 onTriggered: openOther();
             },
             Kirigami.Action {
                 text: i18nc("Switch to the book store page", "Get Hot New Books");
                 iconName: "get-hot-new-stuff";
                 checked: mainWindow.currentCategory === "storePage";
                 onTriggered: changeCategory(storePage);
             },
             Kirigami.Action {
             },
             Kirigami.Action {
                 text: i18nc("Open the settings page", "Settings");
                 iconName: "configure"
                 checked: mainWindow.currentCategory === "settingsPage";
                 onTriggered: changeCategory(settingsPage);
             }
         ]
 
     Component {
         id: welcomePage;
         WelcomePage {
             onBookSelected: mainWindow.showBook(filename, currentPage);
         }
     }
 
     Component {
         id: bookViewer;
         Book {
             id: viewerRoot;
             onCurrentPageChanged: {
                 contentList.setBookData(viewerRoot.file, "currentPage", viewerRoot.currentPage);
             }
             onTotalPagesChanged: {
                 contentList.setBookData(viewerRoot.file, "totalPages", viewerRoot.totalPages);
             }
         }
     }
 
     Component {
         id: bookshelfTitle;
         Bookshelf {
             model: contentList.titleCategoryModel;
             headerText: i18nc("Title of the page with books grouped by the title start letters", "Group by Title");
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfTitle";
         }
     }
 
     Component {
         id: bookshelfAdded;
         Bookshelf {
             model: contentList.newlyAddedCategoryModel;
             headerText: i18nc("Title of the page with all books ordered by which was added most recently", "Recently Added Books");
             sectionRole: "created";
             sectionCriteria: ViewSection.FullString;
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfAdded";
         }
     }
 
     Component {
         id: bookshelfSeries;
         Bookshelf {
             model: contentList.seriesCategoryModel;
             headerText: i18nc("Title of the page with books grouped by what series they are in", "Group by Series");
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfSeries";
         }
     }
 
     Component {
         id: bookshelfAuthor;
         Bookshelf {
             model: contentList.authorCategoryModel;
             headerText: i18nc("Title of the page with books grouped by author", "Group by Author");
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfAuthor";
         }
     }
 
     Component {
         id: bookshelfPublisher;
         Bookshelf {
-            model: contentList;
+            model: contentList.publisherCategoryModel;
             headerText: i18nc("Title of the page with books grouped by who published them", "Group by Publisher");
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfPublisher";
         }
     }
 
     Component {
         id: bookshelfFolder;
         Bookshelf {
             model: contentList.folderCategoryModel;
             headerText: i18nc("Title of the page with books grouped by what folder they are in", "Filter by Folder");
             onBookSelected: mainWindow.showBook(filename, currentPage);
             categoryName: "bookshelfFolder";
         }
     }
 
     Component {
         id: bookshelf;
         Bookshelf {
             onBookSelected: mainWindow.showBook(filename, currentPage);
         }
     }
 
     Component {
         id: storePage;
         Store {
         }
     }
 
     Component {
         id: settingsPage;
         Settings {
         }
     }
 
     property string currentCategory: "welcomePage";
     function changeCategory(categoryItem) {
         // Clear all the way to the welcome page if we change the category...
         mainWindow.pageStack.clear();
         mainWindow.pageStack.push(categoryItem);
         currentCategory = mainWindow.pageStack.currentItem.categoryName;
         if (PLASMA_PLATFORM.substring(0, 5) === "phone") {
             globalDrawer.close();
         }
     }
 }
 
diff --git a/src/qtquick/BookListModel.cpp b/src/qtquick/BookListModel.cpp
index 9291a57..1412e28 100644
--- a/src/qtquick/BookListModel.cpp
+++ b/src/qtquick/BookListModel.cpp
@@ -1,383 +1,398 @@
 /*
  * Copyright (C) 2015 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "BookListModel.h"
 
 #include "BookDatabase.h"
 #include "CategoryEntriesModel.h"
 #include "ArchiveBookModel.h"
 
 #include "AcbfAuthor.h"
 #include "AcbfSequence.h"
 #include "AcbfBookinfo.h"
 
 #include <kio/deletejob.h>
 #include <KFileMetaData/UserMetaData>
 
 #include <QCoreApplication>
 #include <QDir>
 #include <QDebug>
 #include <QMimeDatabase>
 #include <QTimer>
 #include <QUrl>
 
 class BookListModel::Private {
 public:
     Private()
         : contentModel(nullptr)
         , titleCategoryModel(nullptr)
         , newlyAddedCategoryModel(nullptr)
         , authorCategoryModel(nullptr)
         , seriesCategoryModel(nullptr)
+        , publisherCategoryModel(nullptr)
         , folderCategoryModel(nullptr)
         , cacheLoaded(false)
     {
         db = new BookDatabase();
     };
     ~Private()
     {
         qDeleteAll(entries);
         db->deleteLater();
     }
     QList<BookEntry*> entries;
 
     QAbstractListModel* contentModel;
     CategoryEntriesModel* titleCategoryModel;
     CategoryEntriesModel* newlyAddedCategoryModel;
     CategoryEntriesModel* authorCategoryModel;
     CategoryEntriesModel* seriesCategoryModel;
+    CategoryEntriesModel* publisherCategoryModel;
     CategoryEntriesModel* folderCategoryModel;
 
     BookDatabase* db;
     bool cacheLoaded;
 
     void initializeSubModels(BookListModel* q) {
         if(!titleCategoryModel)
         {
             titleCategoryModel = new CategoryEntriesModel(q);
             connect(q, SIGNAL(entryDataUpdated(BookEntry*)), titleCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
             connect(q, SIGNAL(entryRemoved(BookEntry*)), titleCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
             emit q->titleCategoryModelChanged();
         }
         if(!newlyAddedCategoryModel)
         {
             newlyAddedCategoryModel = new CategoryEntriesModel(q);
             connect(q, SIGNAL(entryDataUpdated(BookEntry*)), newlyAddedCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
             connect(q, SIGNAL(entryRemoved(BookEntry*)), newlyAddedCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
             emit q->newlyAddedCategoryModelChanged();
         }
         if(!authorCategoryModel)
         {
             authorCategoryModel = new CategoryEntriesModel(q);
             connect(q, SIGNAL(entryDataUpdated(BookEntry*)), authorCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
             connect(q, SIGNAL(entryRemoved(BookEntry*)), authorCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
             emit q->authorCategoryModelChanged();
         }
         if(!seriesCategoryModel)
         {
             seriesCategoryModel = new CategoryEntriesModel(q);
             connect(q, SIGNAL(entryDataUpdated(BookEntry*)), seriesCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
             connect(q, SIGNAL(entryRemoved(BookEntry*)), seriesCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
             emit q->seriesCategoryModelChanged();
         }
+        if(!publisherCategoryModel)
+        {
+            publisherCategoryModel = new CategoryEntriesModel(q);
+            connect(q, SIGNAL(entryDataUpdated(BookEntry*)), publisherCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
+            connect(q, SIGNAL(entryRemoved(BookEntry*)), publisherCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
+            emit q->publisherCategoryModelChanged();
+        }
         if(!folderCategoryModel)
         {
             folderCategoryModel = new CategoryEntriesModel(q);
             connect(q, SIGNAL(entryDataUpdated(BookEntry*)), folderCategoryModel, SIGNAL(entryDataUpdated(BookEntry*)));
             connect(q, SIGNAL(entryRemoved(BookEntry*)), folderCategoryModel, SIGNAL(entryRemoved(BookEntry*)));
             emit q->folderCategoryModel();
         }
     }
 
     void addEntry(BookListModel* q, BookEntry* entry) {
         entries.append(entry);
         q->append(entry);
         titleCategoryModel->addCategoryEntry(entry->title.left(1).toUpper(), entry);
         for (int i=0; i<entry->author.size(); i++) {
             authorCategoryModel->addCategoryEntry(entry->author.at(i), entry);
         }
         for (int i=0; i<entry->series.size(); i++) {
             seriesCategoryModel->addCategoryEntry(entry->series.at(i), entry);
         }
         if (newlyAddedCategoryModel->indexOfFile(entry->filename) == -1) {
             newlyAddedCategoryModel->append(entry, CreatedRole);
         }
+        publisherCategoryModel->addCategoryEntry(entry->publisher, entry);
         QUrl url(entry->filename.left(entry->filename.lastIndexOf("/")));
         folderCategoryModel->addCategoryEntry(url.path().mid(1), entry);
         if (folderCategoryModel->indexOfFile(entry->filename) == -1) {
             folderCategoryModel->append(entry);
         }
     }
 
     void loadCache(BookListModel* q) {
         QList<BookEntry*> entries = db->loadEntries();
         if(entries.count() > 0)
         {
             initializeSubModels(q);
         }
         int i = 0;
         foreach(BookEntry* entry, entries)
         {
             addEntry(q, entry);
             if(++i % 100 == 0) {
                 emit q->countChanged();
                 qApp->processEvents();
             }
         }
         cacheLoaded = true;
         emit q->cacheLoadedChanged();
     }
 };
 
 BookListModel::BookListModel(QObject* parent)
     : CategoryEntriesModel(parent)
     , d(new Private)
 {
 }
 
 BookListModel::~BookListModel()
 {
     delete d;
 }
 
 void BookListModel::componentComplete()
 {
     QTimer::singleShot(0, this, [this](){ d->loadCache(this); });
 }
 
 bool BookListModel::cacheLoaded() const
 {
     return d->cacheLoaded;
 }
 
 void BookListModel::setContentModel(QObject* newModel)
 {
     if(d->contentModel)
     {
         d->contentModel->disconnect(this);
     }
     d->contentModel = qobject_cast<QAbstractListModel*>(newModel);
     if(d->contentModel)
     {
         connect(d->contentModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(contentModelItemsInserted(QModelIndex,int, int)));
     }
     emit contentModelChanged();
 }
 
 QObject * BookListModel::contentModel() const
 {
     return d->contentModel;
 }
 
 void BookListModel::contentModelItemsInserted(QModelIndex index, int first, int last)
 {
     d->initializeSubModels(this);
     int newRow = d->entries.count();
     beginInsertRows(QModelIndex(), newRow, newRow + (last - first));
     int role = d->contentModel->roleNames().key("filePath");
     for(int i = first; i < last + 1; ++i)
     {
         QVariant filePath = d->contentModel->data(d->contentModel->index(first, 0, index), role);
         BookEntry* entry = new BookEntry();
         entry->filename = filePath.toUrl().toLocalFile();
         QStringList splitName = entry->filename.split("/");
         if (!splitName.isEmpty())
             entry->filetitle = splitName.takeLast();
         if(!splitName.isEmpty())
             entry->series = QStringList(splitName.takeLast()); // hahahaheuristics (dumb assumptions about filesystems, go!)
         // just in case we end up without a title... using complete basename here,
         // as we would rather have "book one. part two" and the odd "book one - part two.tar"
         QFileInfo fileinfo(entry->filename);
         entry->title = fileinfo.completeBaseName();
 
         if(entry->filename.toLower().endsWith("cbr")) {
             entry->thumbnail = QString("image://comiccover/").append(entry->filename);
         }
 #ifdef USE_PERUSE_PDFTHUMBNAILER
         else if(entry->filename.toLower().endsWith("pdf")) {
             entry->thumbnail = QString("image://pdfcover/").append(entry->filename);
         }
 #endif
         else {
             entry->thumbnail = QString("image://preview/").append(entry->filename);
         }
 
         KFileMetaData::UserMetaData data(entry->filename);
         entry->rating = data.rating();
         entry->comment = data.userComment();
         entry->tags = data.tags();
 
         QVariantHash metadata = d->contentModel->data(d->contentModel->index(first, 0, index), Qt::UserRole + 2).toHash();
         QVariantHash::const_iterator it = metadata.constBegin();
         for (; it != metadata.constEnd(); it++) {
             if(it.key() == QLatin1String("author"))
             { entry->author = it.value().toStringList(); }
             else if(it.key() == QLatin1String("title"))
             { entry->title = it.value().toString().trimmed(); }
             else if(it.key() == QLatin1String("publisher"))
             { entry->publisher = it.value().toString().trimmed(); }
             else if(it.key() == QLatin1String("created"))
             { entry->created = it.value().toDateTime(); }
             else if(it.key() == QLatin1String("currentPage"))
             { entry->currentPage = it.value().toInt(); }
             else if(it.key() == QLatin1String("totalPages"))
             { entry->totalPages = it.value().toInt(); }
             else if(it.key() == QLatin1String("comments"))
             { entry->comment = it.value().toString();}
             else if(it.key() == QLatin1Literal("tags"))
             { entry->tags = it.value().toStringList();}
             else if(it.key() == QLatin1String("rating"))
             { entry->rating = it.value().toInt();}
         }
         // ACBF information is always preferred for CBRs, so let's just use that if it's there
         QMimeDatabase db;
         QString mimetype = db.mimeTypeForFile(entry->filename).name();
         if(mimetype == "application/x-cbz" || mimetype == "application/x-cbr" || mimetype == "application/vnd.comicbook+zip" || mimetype == "application/vnd.comicbook+rar") {
             ArchiveBookModel* bookModel = new ArchiveBookModel(this);
             bookModel->setFilename(entry->filename);
 
             AdvancedComicBookFormat::Document* acbfDocument = qobject_cast<AdvancedComicBookFormat::Document*>(bookModel->acbfData());
             if(acbfDocument) {
                 for(AdvancedComicBookFormat::Sequence* sequence : acbfDocument->metaData()->bookInfo()->sequence()) {
                     entry->series.append(sequence->title());
                 }
                 for(AdvancedComicBookFormat::Author* author : acbfDocument->metaData()->bookInfo()->author()) {
                     entry->author.append(author->displayName());
                 }
                 entry->description = acbfDocument->metaData()->bookInfo()->annotation("");
             }
 
             if (entry->author.isEmpty()) {
                 entry->author.append(bookModel->author());
             }
             entry->title = bookModel->title();
             entry->publisher = bookModel->publisher();
             entry->totalPages = bookModel->pageCount();
             bookModel->deleteLater();
         }
 
         d->addEntry(this, entry);
         d->db->addEntry(entry);
     }
     endInsertRows();
     emit countChanged();
     qApp->processEvents();
 }
 
 QObject * BookListModel::titleCategoryModel() const
 {
     return d->titleCategoryModel;
 }
 
 QObject * BookListModel::newlyAddedCategoryModel() const
 {
     return d->newlyAddedCategoryModel;
 }
 
 QObject * BookListModel::authorCategoryModel() const
 {
     return d->authorCategoryModel;
 }
 
 QObject * BookListModel::seriesCategoryModel() const
 {
     return d->seriesCategoryModel;
 }
 
 QObject * BookListModel::seriesModelForEntry(QString fileName)
 {
     Q_FOREACH(BookEntry* entry, d->entries)
     {
         if(entry->filename == fileName)
         {
             return d->seriesCategoryModel->leafModelForEntry(entry);
         }
     }
     return nullptr;
 }
 
+QObject *BookListModel::publisherCategoryModel() const
+{
+    return d->publisherCategoryModel;
+}
+
 QObject * BookListModel::folderCategoryModel() const
 {
     return d->folderCategoryModel;
 }
 
 int BookListModel::count() const
 {
     return d->entries.count();
 }
 
 void BookListModel::setBookData(QString fileName, QString property, QString value)
 {
     Q_FOREACH(BookEntry* entry, d->entries)
     {
         if(entry->filename == fileName)
         {
             if(property == "totalPages")
             {
                 entry->totalPages = value.toInt();
             }
             else if(property == "currentPage")
             {
                 entry->currentPage = value.toInt();
             }
             else if(property == "rating")
             {
                 entry->rating = value.toInt();
             }
             else if(property == "tags")
             {
                 entry->tags = value.split(",");
             }
             else if(property == "comment") {
                 entry->comment = value;
             }
             emit entryDataUpdated(entry);
             break;
         }
     }
 }
 
 void BookListModel::removeBook(QString fileName, bool deleteFile)
 {
     if(deleteFile) {
         KIO::DeleteJob* job = KIO::del(QUrl::fromLocalFile(fileName), KIO::HideProgressInfo);
         job->start();
     }
 
     Q_FOREACH(BookEntry* entry, d->entries)
     {
         if(entry->filename == fileName)
         {
             emit entryRemoved(entry);
             delete entry;
             break;
         }
     }
 }
 
 QStringList BookListModel::knownBookFiles() const
 {
     QStringList files;
     foreach(BookEntry* entry, d->entries) {
         files.append(entry->filename);
     }
     return files;
 }
diff --git a/src/qtquick/BookListModel.h b/src/qtquick/BookListModel.h
index b392404..d40a5e2 100644
--- a/src/qtquick/BookListModel.h
+++ b/src/qtquick/BookListModel.h
@@ -1,224 +1,236 @@
 /*
  * Copyright (C) 2015 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef BOOKLISTMODEL_H
 #define BOOKLISTMODEL_H
 
 #include "CategoryEntriesModel.h"
 #include <QQmlParserStatus>
 /**
  * \brief Main catalogue model class.
  * 
  * BookListModel extends CategoryEntriesModel, and is the main model that
  * handles book entries and the different categories that books can be in.
  * 
  * It also extends QQmlParseStatus to ensure that the loading the cache of
  * books is postponed until the application UI has been painted at least once.
  * 
  * BookListModel keeps track of which books there are, how they can be sorted
  * and how far the reader is in reading a specific book.
  * 
  * It caches its entries in the BookDataBase.
  * 
  * ContentModel is the model used to enable searching the collection, it is
  * typically a ContentList.
  */
 class BookListModel : public CategoryEntriesModel, public QQmlParserStatus
 {
     Q_OBJECT
     /**
      * \brief count holds how many entries there are in the catalogue.
      */
     Q_PROPERTY(int count READ count NOTIFY countChanged)
     /**
      * \brief The content model is an abstract list model that holds data to search through.
      */
     Q_PROPERTY(QObject* contentModel READ contentModel WRITE setContentModel NOTIFY contentModelChanged)
     /**
      * \brief The "newly added" category entries model manages the newly added entries.
      */
     Q_PROPERTY(QObject* newlyAddedCategoryModel READ newlyAddedCategoryModel NOTIFY newlyAddedCategoryModelChanged)
     /**
      * \brief The "title" category entries model manages the sorting of entries by title.
      */
     Q_PROPERTY(QObject* titleCategoryModel READ titleCategoryModel NOTIFY titleCategoryModelChanged)
     /**
      * \brief The "author" category entries model manages the sorting of entries by author.
      */
     Q_PROPERTY(QObject* authorCategoryModel READ authorCategoryModel NOTIFY authorCategoryModelChanged)
     /**
      * \brief The "series" category entries model managed the sorting of entry by series.
      */
     Q_PROPERTY(QObject* seriesCategoryModel READ seriesCategoryModel NOTIFY seriesCategoryModelChanged)
     /**
-     * \brief The "series" category entries model managed the sorting of entry by file system folder.
+     * \brief The "publisher" category entries model managed the sorting of entry by publisher.
+     */
+    Q_PROPERTY(QObject* publisherCategoryModel READ publisherCategoryModel NOTIFY publisherCategoryModelChanged)
+    /**
+     * \brief The "folder" category entries model managed the sorting of entry by file system folder.
      */
     Q_PROPERTY(QObject* folderCategoryModel READ folderCategoryModel NOTIFY folderCategoryModelChanged)
     /**
      * \brief cacheLoaded holds whether the database cache has been loaded..
      */
     Q_PROPERTY(bool cacheLoaded READ cacheLoaded NOTIFY cacheLoadedChanged)
     Q_ENUMS(Grouping)
     Q_INTERFACES(QQmlParserStatus)
 public:
     explicit BookListModel(QObject* parent = nullptr);
     ~BookListModel() override;
 
     /**
      * Inherited from QmlParserStatus, not implemented.
      */
     void classBegin() override {};
     /**
      * \brief triggers the loading of the cache.
      * Inherited from QmlParserStatus
      */
     void componentComplete() override;
 
     /**
      * \brief Enum holding the different categories implemented.
      */
     enum Grouping {
         GroupByNone = 0,
         GroupByRecentlyAdded,
         GroupByRecentlyRead,
         GroupByTitle,
         GroupByAuthor,
         GroupByPublisher
     };
 
     /**
      * @return the contentModel. Used for searching.
      */
     QObject* contentModel() const;
     /**
      * \brief set the ContentModel.
      * @param newModel The new content model.
      */
     void setContentModel(QObject* newModel);
     /**
      * \brief Fires when the content model has changed.
      */
     Q_SIGNAL void contentModelChanged();
 
     /**
      * @returns how many entries there are in the catelogue.
      */
     int count() const;
     /**
      * \brief Fires when the count has changed.
      */
     Q_SIGNAL void countChanged();
 
     /**
      * @return The categoryEntriesModel that manages the sorting of entries by title.
      */
     QObject* titleCategoryModel() const;
     /**
      * \brief Fires when the titleCategoryModel has changed or finished initializing.
      */
     Q_SIGNAL void titleCategoryModelChanged();
 
     /**
      * @return The categoryEntriesModel that manages the recently added entries.
      */
     QObject* newlyAddedCategoryModel() const;
     /**
      * \brief Fires when the newlyAddedCategoryModel has changed or finished initializing.
      */
     Q_SIGNAL void newlyAddedCategoryModelChanged();
 
     /**
      * @return The categoryEntriesModel that manages the sorting of entries by author.
      */
     QObject* authorCategoryModel() const;
     /**
      * \brief Fires when the authorCategoryModel has changed or finished initializing.
      */
     Q_SIGNAL void authorCategoryModelChanged();
 
     /**
      * @return The categoryEntriesModel that manages the sorting of entries by series.
      */
     QObject* seriesCategoryModel() const;
     /**
      * \brief Fires when the seriesCategoryModel has changed or finished initializing.
      */
     Q_SIGNAL void seriesCategoryModelChanged();
     
     /**
      * Returns the leaf model representing the series the entry with the passed URL is a part of
      * Base assumption: A book is only part of one series. This is not always true, but not sure how
      * to sensibly represent that.
      * 
      * @param fileName the File Name of the entry to get the series of.
      */
     Q_INVOKABLE QObject* seriesModelForEntry(QString fileName);
 
+    /**
+     * @return The categoryEntriesModel that manages the sorting of entries by publisher.
+     */
+    QObject* publisherCategoryModel() const;
+    /**
+     * \brief Fires when the publisherCategoryModel has changed or finished initializing.
+     */
+    Q_SIGNAL void publisherCategoryModelChanged();
     /**
      * @return The categoryEntriesModel that manages the sorting of entries by folder.
      */
     QObject* folderCategoryModel() const;
     /**
      * \brief Fires when the folderCategoryModel has changed or finished initializing.
      */
     Q_SIGNAL void folderCategoryModelChanged();
 
     /**
      * @returns whether the cache is loaded from the database.
      */
     bool cacheLoaded() const;
     /**
      * \brief Fires when the cache is done loading.
      */
     Q_SIGNAL void cacheLoadedChanged();
 
     /**
      * \brief Update the data of a book at runtime
      * 
      * This is used in to update totalPages and currentPage.
      * 
      * @param fileName The filename to update the page for.
      * @param property The property to update, can be "currentPage" or
      * "totalPages".
      * @param value The value to set it to.
      */
     Q_INVOKABLE void setBookData(QString fileName, QString property, QString value);
 
     /**
      * Delete a book from the model, and optionally delete the entry from file storage.
      * @param fileName The filename of the book to remove.
      * @param deleteFile Whether to also delete the file from the disk.
      */
     Q_INVOKABLE void removeBook(QString fileName, bool deleteFile = false);
 
     /**
      * \brief A list of the files currently known by the applications
      * @returns a QStringList with paths to known books.
      */
     Q_INVOKABLE QStringList knownBookFiles() const;
 private:
     class Private;
     Private* d;
 
     Q_SLOT void contentModelItemsInserted(QModelIndex index,int first, int last);
 };
 
 #endif//BOOKLISTMODEL_H