diff --git a/src/kjotsmodel.cpp b/src/kjotsmodel.cpp
index 3c27d31..b2ef66d 100644
--- a/src/kjotsmodel.cpp
+++ b/src/kjotsmodel.cpp
@@ -1,393 +1,393 @@
 /*
     This file is part of KJots.
 
     Copyright (c) 2009 Stephen Kelly <steveire@gmail.com>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "kjotsmodel.h"
 
 #include <QTextDocument>
 #include <QIcon>
 
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/EntityDisplayAttribute>
 #include <Akonadi/Notes/NoteUtils>
 
 #include <KMime/Message>
 #include <KPIMTextEdit/TextUtils>
 #include <KPIMTextEdit/RichTextComposerImages>
 #include <KLocalizedString>
 #include <KFormat>
 
 #include <grantlee/markupdirector.h>
 #include <grantlee/texthtmlbuilder.h>
 #include <grantlee/plaintextmarkupbuilder.h>
 
 #include "noteshared/notelockattribute.h"
 
 Q_DECLARE_METATYPE(QTextDocument *)
 Q_DECLARE_METATYPE(KPIMTextEdit::ImageList)
 
 using namespace Akonadi;
 
 KJotsEntity::KJotsEntity(const QModelIndex &index, QObject *parent)
     : QObject(parent)
     , m_index(index)
 {
 }
 
 void KJotsEntity::setIndex(const QModelIndex &index)
 {
     m_index = QPersistentModelIndex(index);
 }
 
 QString KJotsEntity::title() const
 {
     return m_index.data().toString();
 }
 
 QString KJotsEntity::content() const
 {
     auto *document = m_index.data(KJotsModel::DocumentRole).value<QTextDocument *>();
     if (!document) {
         return QString();
     }
 
     Grantlee::TextHTMLBuilder builder;
     Grantlee::MarkupDirector director(&builder);
 
     director.processDocument(document);
     QString result = builder.getResult();
 
     return result;
 }
 
 QString KJotsEntity::plainContent() const
 {
     auto *document = m_index.data(KJotsModel::DocumentRole).value<QTextDocument *>();
     if (!document) {
         return QString();
     }
 
     Grantlee::PlainTextMarkupBuilder builder;
     Grantlee::MarkupDirector director(&builder);
 
     director.processDocument(document);
     QString result = builder.getResult();
 
     return result;
 }
 
 QString KJotsEntity::url() const
 {
     return m_index.data(KJotsModel::EntityUrlRole).toString();
 }
 
 qint64 KJotsEntity::entityId() const
 {
     Item item = m_index.data(EntityTreeModel::ItemRole).value<Item>();
     if (!item.isValid()) {
         Collection col = m_index.data(EntityTreeModel::CollectionRole).value<Collection>();
         if (!col.isValid()) {
             return -1;
         }
         return col.id();
     }
     return item.id();
 }
 
 bool KJotsEntity::isBook() const
 {
     Collection col = m_index.data(EntityTreeModel::CollectionRole).value<Collection>();
 
     if (col.isValid()) {
         return col.contentMimeTypes().contains(Akonadi::NoteUtils::noteMimeType());
     }
     return false;
 }
 
 bool KJotsEntity::isPage() const
 {
     Item item = m_index.data(EntityTreeModel::ItemRole).value<Item>();
     if (item.isValid()) {
         return item.hasPayload<KMime::Message::Ptr>();
     }
     return false;
 }
 
 QVariantList KJotsEntity::entities() const
 {
     const QAbstractItemModel *model = m_index.model();
     QVariantList list;
     int row = 0;
     const int column = 0;
     QModelIndex childIndex = model->index(row++, column, m_index);
     while (childIndex.isValid()) {
         auto *obj = new KJotsEntity(childIndex);
         list << QVariant::fromValue(obj);
         childIndex = model->index(row++, column, m_index);
     }
     return list;
 }
 
 QVariantList KJotsEntity::breadcrumbs() const
 {
     QVariantList list;
     QModelIndex parent = m_index.parent();
 
     while (parent.isValid()) {
         QObject *obj = new KJotsEntity(parent);
         list << QVariant::fromValue(obj);
         parent = parent.parent();
     }
     return list;
 }
 
 KJotsModel::KJotsModel(ChangeRecorder *monitor, QObject *parent)
     : EntityTreeModel(monitor, parent)
 {
 
 }
 
 KJotsModel::~KJotsModel()
 {
     qDeleteAll(m_documents);
 }
 
 bool KJotsModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role == Qt::EditRole) {
         Item item = index.data(ItemRole).value<Item>();
 
         if (!item.isValid()) {
             Collection col = index.data(CollectionRole).value<Collection>();
             col.setName(value.toString());
             if (col.hasAttribute<EntityDisplayAttribute>()) {
                 auto *eda = col.attribute<EntityDisplayAttribute>();
                 eda->setDisplayName(value.toString());
             }
             return EntityTreeModel::setData(index, QVariant::fromValue(col), CollectionRole);
         }
         NoteUtils::NoteMessageWrapper note(item.payload<KMime::Message::Ptr>());
         note.setTitle(value.toString());
         item.setPayload(note.message());
 
         if (item.hasAttribute<EntityDisplayAttribute>()) {
             auto *displayAttribute = item.attribute<EntityDisplayAttribute>();
             displayAttribute->setDisplayName(value.toString());
         }
         return EntityTreeModel::setData(index, QVariant::fromValue(item), ItemRole);
     }
 
     if (role == KJotsModel::DocumentRole) {
         Item item = updateItem(index, value.value<QTextDocument *>());
         return EntityTreeModel::setData(index, QVariant::fromValue(item), ItemRole);
     }
 
     return EntityTreeModel::setData(index, value, role);
 }
 
 QVariant KJotsModel::data(const QModelIndex &index, int role) const
 {
     if (GrantleeObjectRole == role) {
         auto *obj = new KJotsEntity(index);
         obj->setIndex(index);
         return QVariant::fromValue(obj);
     }
 
     if (role == KJotsModel::DocumentRole) {
         const Item item = index.data(ItemRole).value<Item>();
         Item::Id itemId = item.id();
         if (m_documents.contains(itemId)) {
             return QVariant::fromValue(m_documents.value(itemId));
         }
         if (!item.hasPayload<KMime::Message::Ptr>()) {
             return QVariant();
         }
 
         NoteUtils::NoteMessageWrapper note(item.payload<KMime::Message::Ptr>());
         const QString doc = note.text();
         auto *document = new QTextDocument();
         if (note.textFormat() == Qt::RichText
                 || doc.startsWith(u"<!DOCTYPE")
                 || doc.startsWith(u"<html>"))
         {
             document->setHtml(doc);
         } else {
             document->setPlainText(doc);
         }
         document->setModified(false);
         // Loading embedded images
         const QVector<NoteUtils::Attachment> attachments = note.attachments();
         for (const auto &attachment : attachments) {
             if (attachment.mimetype() == QStringLiteral("image/png") && !attachment.contentID().isEmpty()) {
                 QImage img = QImage::fromData(attachment.data(), "PNG");
                 document->addResource(QTextDocument::ImageResource,
                                       QUrl(QStringLiteral("cid:")+attachment.contentID()), img);
             }
         }
 
         m_documents.insert(itemId, document);
         return QVariant::fromValue(document);
     }
 
     if (role == Qt::DecorationRole) {
         const Item item = index.data(ItemRole).value<Item>();
         if (item.isValid() && item.hasAttribute<NoteShared::NoteLockAttribute>()) {
             return QIcon::fromTheme(QStringLiteral("emblem-locked"));
         }
         const Collection col = index.data(CollectionRole).value<Collection>();
         if (col.isValid() && col.hasAttribute<NoteShared::NoteLockAttribute>()) {
             return QIcon::fromTheme(QStringLiteral("emblem-locked"));
         }
     }
 
     return EntityTreeModel::data(index, role);
 }
 
 QVariant KJotsModel::entityData(const Akonadi::Item &item, int column, int role) const
 {
     if (item.hasPayload<KMime::Message::Ptr>()) {
         auto message = item.payload<KMime::Message::Ptr>();
         NoteUtils::NoteMessageWrapper note(message);
         if (role == Qt::DisplayRole) {
             switch (column) {
             case Title:
                 return note.title();
             case ModificationTime:
                 return KFormat().formatRelativeDateTime(note.lastModifiedDate(), QLocale::ShortFormat);
             case CreationTime:
                 return KFormat().formatRelativeDateTime(note.creationDate(), QLocale::ShortFormat);
             case Size:
-                return KFormat().formatByteSize(message->size());
+                return KFormat().formatByteSize(message->storageSize());
             }
         } else if (role == Qt::EditRole) {
             switch (column) {
             case Title:
                 return note.title();
             case ModificationTime:
                 return note.lastModifiedDate();
             case CreationTime:
                 return note.creationDate();
             case Size:
                 return message->size();
             }
 
         }
     }
     return EntityTreeModel::entityData(item, column, role);
 }
 
 QVariant KJotsModel::entityHeaderData(int section, Qt::Orientation orientation, int role, HeaderGroup headerGroup) const
 {
     if (role != Qt::DisplayRole || orientation != Qt::Horizontal) {
         return EntityTreeModel:: entityHeaderData(section, orientation, role, headerGroup);
     }
     if (headerGroup == EntityTreeModel::CollectionTreeHeaders) {
         return i18nc("@title:column", "Name");
     } else if (headerGroup == EntityTreeModel::ItemListHeaders) {
         switch (section) {
         case Title:
             return i18nc("@title:column title of a note", "Title");
         case CreationTime:
             return i18nc("@title:column creation date and time of a note", "Created");
         case ModificationTime:
             return i18nc("@title:column last modification date and time of a note", "Modified");
         case Size:
             return i18nc("@title:column size of a note", "Size");
         }
     }
     return EntityTreeModel::entityHeaderData(section, orientation, role, headerGroup);
 }
 
 int KJotsModel::entityColumnCount(HeaderGroup headerGroup) const
 {
     if (headerGroup == EntityTreeModel::CollectionTreeHeaders) {
         return 1;
     } else if (headerGroup == EntityTreeModel::ItemListHeaders) {
         return 4;
     } else {
         return EntityTreeModel::entityColumnCount(headerGroup);
     }
 }
 
 QModelIndex KJotsModel::modelIndexForUrl(const QAbstractItemModel *model, const QUrl &url)
 {
     if (url.scheme() != QStringLiteral("akonadi")) {
         return {};
     }
     const auto item = Item::fromUrl(url);
     const auto col = Collection::fromUrl(url);
     if (item.isValid()) {
         const QModelIndexList idxs = EntityTreeModel::modelIndexesForItem(model, item);
         if (!idxs.isEmpty()) {
             return idxs.first();
         }
     } else if (col.isValid()) {
         return EntityTreeModel::modelIndexForCollection(model, col);
     }
     return {};
 }
 
 Item KJotsModel::updateItem(const QModelIndex &index, QTextDocument *document)
 {
     Item item = index.data(ItemRole).value<Item>();
     if (!item.hasPayload<KMime::Message::Ptr>()) {
         return Item();
     }
     NoteUtils::NoteMessageWrapper note(item.payload<KMime::Message::Ptr>());
     // Saving embedded images
     const auto images = document->property("images").value<KPIMTextEdit::ImageList>();
     QVector<NoteUtils::Attachment> &attachments = note.attachments();
     attachments.clear();
     attachments.reserve(images.count());
     std::transform(images.cbegin(), images.cend(), std::back_inserter(attachments),
                    [](const QSharedPointer<KPIMTextEdit::EmbeddedImage> &img) {
             NoteUtils::Attachment attachment(img->image, QStringLiteral("image/png"));
             attachment.setDataBase64Encoded(true);
             attachment.setContentID(img->contentID);
             return attachment;
         });
     // Setting text
     bool isRichText = KPIMTextEdit::TextUtils::containsFormatting(document);
     if (isRichText) {
         const QByteArray html = KPIMTextEdit::RichTextComposerImages::imageNamesToContentIds( document->toHtml().toUtf8(), images);
         note.setText( QString::fromUtf8(html), Qt::RichText );
     } else {
         note.setText( document->toPlainText(), Qt::PlainText );
     }
     note.setLastModifiedDate(QDateTime::currentDateTime());
     item.setPayload(note.message());
     return item;
 }
 
 QString KJotsModel::itemPath(const QModelIndex &index, const QString &sep)
 {
     QString caption;
     QModelIndex curIndex = index;
     while (curIndex.isValid()) {
         QModelIndex parentBook = curIndex.parent();
         if (parentBook.isValid()) {
             caption = sep + curIndex.data().toString() + caption;
         } else {
             caption = curIndex.data().toString() + caption;
         }
         curIndex = parentBook;
     }
     return caption;
 }
diff --git a/src/kjotsui.rc b/src/kjotsui.rc
index 78cc4de..8d08270 100644
--- a/src/kjotsui.rc
+++ b/src/kjotsui.rc
@@ -1,155 +1,161 @@
 <!DOCTYPE kpartgui>
-<kpartgui version="16" name="kjots" >
+<kpartgui version="17" name="kjots" >
 <MenuBar>
   <Menu name="file">
    <Action name="akonadi_note_create"/>
    <Action name="akonadi_collection_create"/>
    <Separator/>
    <Action name="file_save"/>
    <Action name="save_to"/>
    <Action name="import"/>
    <Separator/>
    <Action name="renamefile"/>
    <Action name="deletefile"/>
    <Separator/>
    <Action name="file_print"/>
    <Action name="file_print_preview"/>
    <Separator/>
   </Menu>
 
   <Menu noMerge="1" name="format">
       <text>F&amp;ormat</text>
       <Action name="format_text_bold"/>
       <Action name="format_text_italic"/>
       <Action name="format_text_underline"/>
       <Action name="format_text_strikeout"/>
       <Action name="format_text_foreground_color"/>
       <Action name="format_text_background_color"/>
       <Separator/>
       <Action name="format_heading_level"/>
       <Separator/>
       <Action name="format_align_left"/>
       <Action name="format_align_center"/>
       <Action name="format_align_right"/>
       <Action name="format_align_justify"/>
       <Separator/>
       <Action name="format_list_style"/>
       <Action name="format_list_indent_more"/>
       <Action name="format_list_indent_less"/>
       <Action name="format_list_checkbox"/>
       <Separator/>
       <Action name="format_painter"/>
   </Menu>
 
+  <Menu name="view">
+    <text>&amp;View</text>
+    <Action name="view_mode_two_columns" />
+    <Action name="view_mode_three_columns" />
+  </Menu>
+
   <Menu name="go">
    <text>&amp;Go</text>
    <Action name="go_next"/>
    <Action name="go_previous"/>
    <Separator/>
    <Action name="go_prev_book"/>
    <Action name="go_next_book"/>
   </Menu>
 
   <Menu name="tools">
    <text>&amp;Tools</text>
    <Action name="add_image"/>
    <Action name="insert_table"/>
    <Action name="insert_horizontal_rule"/>
    <Action name="manage_note_link"/>
    <Action name="insert_date"/>
    <Action name="copy_into_title"/>
   </Menu>
 
   <Action name="bookmarks"/>
 
   <Menu name="settings">
     <Action name="kjots_configure"/>
   </Menu>
 
   <Menu name="help">
   </Menu>
 </MenuBar>
 
 <Menu name="akonadi_itemview_contextmenu">
   <Action name="akonadi_note_create"/>
   <Separator/>
   <Action name="renamefile"/>
   <Action name="akonadi_note_change_color"/>
   <Separator/>
   <Action name="akonadi_item_copy"/>
   <Action name="akonadi_item_delete"/>
   <Separator/>
   <Action name="save_to"/>
   <Separator/>
   <Action name="akonadi_note_lock_unlock"/>
 </Menu>
 
 <Menu name="akonadi_collectionview_contextmenu">
   <Action name="akonadi_note_create"/>
   <Action name="akonadi_collection_create"/>
   <Separator/>
   <Action name="renamefile"/>
   <Action name="akonadi_notebook_change_color"/>
   <Separator/>
   <Action name="akonadi_collection_copy"/>
   <Action name="akonadi_collection_delete"/>
   <Separator/>
   <Action name="save_to"/>
   <Separator/>
   <Action name="akonadi_notebook_lock_unlock"/>
 </Menu>
 
 <ToolBar name="mainToolBar" fullWidth="true" noMerge="1" iconText="icononly">
   <text>Main Toolbar</text>
   <Action name="akonadi_note_create"/>
   <Action name="akonadi_collection_create"/>
   <Separator/>
   <Action name="file_save"/>
   <Action name="file_print"/>
   <Separator/>
   <Action name="edit_cut"/>
   <Action name="edit_copy"/>
   <Action name="edit_paste"/>
   <Separator/>
   <Action name="edit_find"/>
 </ToolBar>
 
      
 <ToolBar name="textToolBar" iconText="icononly">
     <text>Text Toolbar</text>
     <Action name="format_text_bold"/>
     <Action name="format_text_italic"/>
     <Action name="format_text_underline"/>
     <Action name="format_text_strikeout"/>
     <Action name="format_text_foreground_color"/>
     <Action name="format_text_background_color"/>
     <Separator/>
     <Action name="format_font_family"/>
     <Action name="format_font_size"/>
     <Separator/>
     <Action name="format_painter"/>
 </ToolBar>
 
 <ToolBar name="formatToolBar" iconText="icononly">
     <text>Format Toolbar</text>
     <Action name="format_heading_level"/>
     <Separator/>
     <Action name="format_align_left"/>
     <Action name="format_align_center"/>
     <Action name="format_align_right"/>
     <Action name="format_align_justify"/>
     <Separator/>
     <Action name="format_list_style"/>
     <Action name="format_list_indent_more"/>
     <Action name="format_list_indent_less"/>
     <Action name="format_list_checkbox"/>
 </ToolBar>
 
 <ToolBar name="toolsToolBar">
     <text>Tools Toolbar</text>
     <Action name="add_image"/>
     <Action name="insert_table"/>
     <Action name="insert_horizontal_rule"/>
     <Action name="manage_note_link"/>
 </ToolBar>
 </kpartgui>
diff --git a/src/kjotswidget.cpp b/src/kjotswidget.cpp
index 7529aca..7190d41 100644
--- a/src/kjotswidget.cpp
+++ b/src/kjotswidget.cpp
@@ -1,746 +1,756 @@
 /*
     This file is part of KJots.
 
     Copyright (C) 1997 Christoph Neerfeld <Christoph.Neerfeld@home.ivm.de>
     Copyright (C) 2002, 2003 Aaron J. Seigo <aseigo@kde.org>
     Copyright (C) 2003 Stanislav Kljuhhin <crz@hot.ee>
     Copyright (C) 2005-2006 Jaison Lee <lee.jaison@gmail.com>
     Copyright (C) 2007-2009 Stephen Kelly <steveire@gmail.com>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "kjotswidget.h"
 
 // Qt
 #include <QHBoxLayout>
 #include <QSplitter>
 #include <QStackedWidget>
 #include <QTextCursor>
 #include <QTextDocument>
 #include <QTextDocumentFragment>
 #include <QTimer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QDBusConnection>
 #include <QMenu>
 #include <QFileDialog>
 #include <QAction>
 #include <QIcon>
 #include <QItemDelegate>
 #include <QHeaderView>
 #include <QDebug>
 
 // Akonadi
 #include <Akonadi/Notes/NoteUtils>
 #include <AkonadiCore/CollectionCreateJob>
 #include <AkonadiCore/CollectionDeleteJob>
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/EntityDisplayAttribute>
 #include <AkonadiCore/EntityMimeTypeFilterModel>
 #include <AkonadiCore/Item>
 #include <AkonadiCore/ItemCreateJob>
 #include <AkonadiCore/ItemModifyJob>
 #include <AkonadiCore/ItemDeleteJob>
 #include <AkonadiCore/ItemFetchScope>
 #include <AkonadiCore/EntityOrderProxyModel>
 #include <AkonadiWidgets/EntityTreeView>
 #include <AkonadiWidgets/ETMViewStateSaver>
 #include <AkonadiWidgets/ControlGui>
 
 // Grantlee
 #include <grantlee/template.h>
 #include <grantlee/engine.h>
 #include <grantlee/context.h>
 
 // KDE
 #include <KActionCollection>
 #include <KBookmarkMenu>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSelectionProxyModel>
 #include <KXMLGUIClient>
 #include <KActionMenu>
 #include <KRandom>
 #include <KSharedConfig>
 #include <KRun>
 #include <KConfigDialog>
 
 #include <KPIMTextEdit/RichTextComposerActions>
 #include <KPIMTextEdit/RichTextEditorWidget>
 
 #include <Libkdepim/UiStateSaver>
 
 // KMime
 #include <KMime/Message>
 
 // KJots
 #include "kjotsbookmarks.h"
 #include "kjotssortproxymodel.h"
 #include "kjotsmodel.h"
 #include "kjotsedit.h"
 #include "kjotsconfigdlg.h"
 #include "KJotsSettings.h"
 #include "kjotsbrowser.h"
 #include "noteshared/notelockattribute.h"
 #include "noteshared/standardnoteactionmanager.h"
 
 #include <memory>
 
 using namespace Akonadi;
 using namespace Grantlee;
 
 KJotsWidget::KJotsWidget(QWidget *parent, KXMLGUIClient *xmlGuiClient, Qt::WindowFlags f)
     : QWidget(parent, f)
     , m_xmlGuiClient(xmlGuiClient)
 {
     ControlGui::widgetNeedsAkonadi(this);
 
     // Grantlee
     m_loader = QSharedPointer<FileSystemTemplateLoader>(new FileSystemTemplateLoader());
     m_loader->setTemplateDirs(QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
                                                         QStringLiteral("kjots/themes"),
                                                         QStandardPaths::LocateDirectory));
     m_loader->setTheme(QStringLiteral("default"));
     m_templateEngine = new Engine(this);
     m_templateEngine->addTemplateLoader(m_loader);
 
     // GUI & Actions
     setupGui();
     setupActions();
     // Models
     ItemFetchScope scope;
     scope.fetchFullPayload(true);   // Need to have full item when adding it to the internal data structure
     scope.fetchAttribute< EntityDisplayAttribute >();
     scope.fetchAttribute< NoteShared::NoteLockAttribute >();
 
     auto *monitor = new ChangeRecorder(this);
     monitor->fetchCollection(true);
     monitor->setItemFetchScope(scope);
     monitor->setCollectionMonitored(Collection::root());
     monitor->setMimeTypeMonitored(NoteUtils::noteMimeType());
 
     m_kjotsModel = new KJotsModel(monitor, this);
 
     m_collectionModel = new EntityMimeTypeFilterModel(this);
     m_collectionModel->setSourceModel(m_kjotsModel);
     m_collectionModel->addMimeTypeInclusionFilter(Collection::mimeType());
     m_collectionModel->setHeaderGroup(EntityTreeModel::CollectionTreeHeaders);
     m_collectionModel->setDynamicSortFilter(true);
     m_collectionModel->setSortCaseSensitivity(Qt::CaseInsensitive);
 
     m_orderProxy = new EntityOrderProxyModel(this);
     m_orderProxy->setSourceModel(m_collectionModel);
     KConfigGroup cfg(KSharedConfig::openConfig(), "KJotsEntityOrder");
     m_orderProxy->setOrderConfig(cfg);
 
     m_collectionView->setModel(m_orderProxy);
 
     m_collectionSelectionProxyModel = new KSelectionProxyModel(m_collectionView->selectionModel(), this);
     m_collectionSelectionProxyModel->setSourceModel(m_kjotsModel);
     m_collectionSelectionProxyModel->setFilterBehavior(KSelectionProxyModel::ChildrenOfExactSelection);
 
     m_itemModel = new EntityMimeTypeFilterModel(this);
     m_itemModel->setSourceModel(m_collectionSelectionProxyModel);
     m_itemModel->addMimeTypeExclusionFilter(Collection::mimeType());
     m_itemModel->setHeaderGroup(EntityTreeModel::ItemListHeaders);
     m_itemModel->setSortRole(Qt::EditRole);
 
     m_itemView->setModel(m_itemModel);
 
     m_actionManager->setCollectionSelectionModel(m_collectionView->selectionModel());
     m_actionManager->setItemSelectionModel(m_itemView->selectionModel());
 
     connect(m_kjotsModel, &EntityTreeModel::modelAboutToBeReset, this, &KJotsWidget::saveState);
     connect(m_kjotsModel, &EntityTreeModel::modelReset, this, &KJotsWidget::restoreState);
 
     // TODO: handle dataChanged properly, i.e. if item was changed from outside
     connect(m_collectionView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::renderSelection);
     connect(m_collectionView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::updateMenu);
     connect(m_collectionView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::updateCaption);
     connect(m_collectionView->model(), &QAbstractItemModel::dataChanged, this, &KJotsWidget::renderSelection);
     connect(m_collectionView->model(), &QAbstractItemModel::dataChanged, this, &KJotsWidget::updateCaption);
 
     connect(m_itemView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::renderSelection);
     connect(m_itemView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::updateMenu);
     connect(m_itemView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KJotsWidget::updateCaption);
     connect(m_itemView->model(), &QAbstractItemModel::dataChanged, this, &KJotsWidget::renderSelection);
     connect(m_itemView->model(), &QAbstractItemModel::dataChanged, this, &KJotsWidget::updateCaption);
 
     connect(m_editor, &KJotsEdit::documentModified, this, &KJotsWidget::updateCaption);
 
     QTimer::singleShot(0, this, &KJotsWidget::delayedInitialization);
 
     // Autosave timer
     m_autosaveTimer = new QTimer(this);
     updateConfiguration();
     connect(m_autosaveTimer, &QTimer::timeout, m_editor, &KJotsEdit::savePage);
     connect(m_collectionView->selectionModel(), &QItemSelectionModel::selectionChanged, m_autosaveTimer, qOverload<>(&QTimer::start));
 
     restoreState();
 
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/KJotsWidget"), this, QDBusConnection::ExportScriptableContents);
 }
 
 KJotsWidget::~KJotsWidget()
 {
     saveState();
 }
 
 void KJotsWidget::setupGui()
 {
     // Main horizontal layout
     auto *layout = new QHBoxLayout(this);
     layout->setMargin(0);
 
     // Splitter between (collection view) and (item view + editor)
     m_splitter1 = new QSplitter(this);
     m_splitter1->setObjectName(QStringLiteral("CollectionSplitter"));
     m_splitter1->setStretchFactor(1, 1);
     layout->addWidget(m_splitter1);
 
     // Collection view
     m_collectionView = new EntityTreeView(m_xmlGuiClient, m_splitter1);
     m_collectionView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_collectionView->setEditTriggers(QAbstractItemView::DoubleClicked);
     m_collectionView->setManualSortingActive(true);
     m_collectionView->header()->setDefaultAlignment(Qt::AlignCenter);
 
     // Splitter between item view and editor
     m_splitter2 = new QSplitter(m_splitter1);
     m_splitter2->setObjectName(QStringLiteral("EditorSplitter"));
 
     // Item view
     m_itemView = new EntityTreeView(m_xmlGuiClient, m_splitter2);
     m_itemView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_itemView->setEditTriggers(QAbstractItemView::DoubleClicked);
     m_itemView->setRootIsDecorated(false);
     m_itemView->header()->setDefaultAlignment(Qt::AlignCenter);
 
     // Stacked widget containing editor & browser
     m_stackedWidget = new QStackedWidget(m_splitter2);
 
     // Editor
     m_editor = new KJotsEdit(m_stackedWidget, m_xmlGuiClient->actionCollection());
     m_editorWidget = new KPIMTextEdit::RichTextEditorWidget(m_editor, m_stackedWidget);
     m_editor->setParent(m_editorWidget);
     m_stackedWidget->addWidget(m_editorWidget);
     connect(m_editor, &KJotsEdit::linkClicked, this, &KJotsWidget::openLink);
     // Browser
     m_browserWidget = new KJotsBrowserWidget(std::make_unique<KJotsBrowser>(m_kjotsModel, m_xmlGuiClient->actionCollection()),
                                              m_stackedWidget);
     m_stackedWidget->addWidget(m_browserWidget);
     m_stackedWidget->setCurrentWidget(m_browserWidget);
     connect(m_browserWidget->browser(), &KJotsBrowser::linkClicked, this, &KJotsWidget::openLink);
 
     // Make sure the editor gets focus again after naming a new book/page.
     connect(m_collectionView->itemDelegate(), &QItemDelegate::closeEditor, this, [this](){
             activeEditor()->setFocus();
         });
-
-    // Load view mode and splitters
-    setViewMode(0);
 }
 
 void KJotsWidget::restoreState()
 {
     {
         auto *saver = new ETMViewStateSaver;
         saver->setView(m_collectionView);
         KConfigGroup cfg(KSharedConfig::openConfig(), "CollectionViewState");
         saver->restoreState(cfg);
     }
     {
         auto *saver = new ETMViewStateSaver;
         saver->setView(m_itemView);
         KConfigGroup cfg(KSharedConfig::openConfig(), "ItemViewState");
         saver->restoreState(cfg);
     }
 }
 
 void KJotsWidget::saveState()
 {
     {
         ETMViewStateSaver saver;
         saver.setView(m_collectionView);
         KConfigGroup cfg(KSharedConfig::openConfig(), "CollectionViewState");
         saver.saveState(cfg);
         cfg.sync();
     }
     {
         ETMViewStateSaver saver;
         saver.setView(m_itemView);
         KConfigGroup cfg(KSharedConfig::openConfig(), "ItemViewState");
         saver.saveState(cfg);
         cfg.sync();
     }
 }
 
 void KJotsWidget::saveSplitterStates() const
 {
     const QString groupName = QStringLiteral("UiState_MainWidgetSplitter_%1").arg(KJotsSettings::viewMode());
     KConfigGroup group(KSharedConfig::openConfig(), groupName);
     KPIM::UiStateSaver::saveState(m_splitter1, group);
     KPIM::UiStateSaver::saveState(m_splitter2, group);
 }
 
 void KJotsWidget::restoreSplitterStates()
 {
     const QString groupName = QStringLiteral("UiState_MainWidgetSplitter_%1").arg(KJotsSettings::viewMode());
     KConfigGroup group(KSharedConfig::openConfig(), groupName);
     KPIM::UiStateSaver::restoreState(m_splitter1, group);
     KPIM::UiStateSaver::restoreState(m_splitter2, group);
 }
 
 void KJotsWidget::setViewMode(int mode)
 {
     const int newMode = (mode == 0) ? KJotsSettings::viewMode() : mode;
     m_splitter2->setOrientation(newMode == 1 ? Qt::Vertical : Qt::Horizontal);
     if (mode != 0) {
         KJotsSettings::setViewMode(mode);
         saveSplitterStates();
     }
     restoreSplitterStates();
+    m_viewModeGroup->actions().at(newMode-1)->setChecked(true);
 }
 
 void KJotsWidget::setupActions()
 {
     KActionCollection *actionCollection = m_xmlGuiClient->actionCollection();
     // Default Akonadi Notes actions
     m_actionManager = new StandardNoteActionManager(actionCollection, this);
     m_actionManager->createAllActions();
 
     actionCollection->setDefaultShortcut(m_actionManager->action(StandardActionManager::CreateCollection),
                                          QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_N));
 
     QAction *action;
     // Standard actions
     KStandardAction::preferences(this, &KJotsWidget::configure, actionCollection);
 
     KStandardAction::save( m_editor, &KJotsEdit::savePage, actionCollection);
 
     action = KStandardAction::next(this, [this](){
             m_itemView->selectionModel()->select(previousNextEntity(m_itemView, +1), QItemSelectionModel::ClearAndSelect);
         }, actionCollection);
     actionCollection->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_PageDown));
     connect(this, &KJotsWidget::canGoNextPageChanged, action, &QAction::setEnabled);
 
     action = KStandardAction::prior(this, [this](){
             m_itemView->selectionModel()->select(previousNextEntity(m_itemView, -1), QItemSelectionModel::ClearAndSelect);
         }, actionCollection);
     actionCollection->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_PageUp));
     connect(this, &KJotsWidget::canGoPreviousPageChanged, action, &QAction::setEnabled);
 
     KStandardAction::renameFile(this, [this](){
             EntityTreeView *activeView;
             if (m_collectionView->hasFocus()) {
                 activeView = m_collectionView;
             } else {
                 activeView = m_itemView;
             }
 
             const QModelIndexList rows = activeView->selectionModel()->selectedRows();
             if (rows.size() != 1) {
                 return;
             }
             activeView->edit(rows.first());
         }, actionCollection);
 
     action = KStandardAction::deleteFile(this, [this](){
             if (m_collectionView->hasFocus()) {
                 m_actionManager->action(StandardActionManager::DeleteCollections)->trigger();
             } else {
                 m_actionManager->action(StandardActionManager::DeleteItems)->trigger();
             }
         }, actionCollection);
 
     action = KStandardAction::cut(m_editor, &KJotsEdit::cut, actionCollection);
     connect(m_editor, &KJotsEdit::copyAvailable, action, &QAction::setEnabled);
     action->setEnabled(false);
 
     action = KStandardAction::copy(this, [this](){
             activeEditor()->copy();
         }, actionCollection);
     connect(m_editor, &KJotsEdit::copyAvailable, action, &QAction::setEnabled);
     connect(m_browserWidget->browser(), &KJotsBrowser::copyAvailable, action, &QAction::setEnabled);
     action->setEnabled(false);
 
     KStandardAction::paste(m_editor, &KJotsEdit::paste, actionCollection);
     KStandardAction::undo(m_editor, &KJotsEdit::undo, actionCollection);
     KStandardAction::redo(m_editor, &KJotsEdit::redo, actionCollection);
     KStandardAction::selectAll(m_editor, &KJotsEdit::selectAll, actionCollection);
 
     KStandardAction::find(this, [this](){
             if (m_editorWidget->isVisible()) {
                 m_editorWidget->slotFind();
             } else {
                 m_browserWidget->slotFind();
             }
         }, actionCollection);
     KStandardAction::findNext(this, [this](){
             if (m_editorWidget->isVisible()) {
                 m_editorWidget->slotFindNext();
             } else {
                 m_browserWidget->slotFindNext();
             }
         }, actionCollection);
     KStandardAction::replace(this, [this](){
             if (m_editorWidget->isVisible()) {
                 m_editorWidget->slotReplace();
             }
         }, actionCollection);
 
     KStandardAction::print(this, &KJotsWidget::printSelection, actionCollection);
     KStandardAction::printPreview(this, &KJotsWidget::printPreviewSelection, actionCollection);
 
     // Bookmarks actions
     auto *bookmarkMenu = actionCollection->add<KActionMenu>(QStringLiteral("bookmarks"));
     bookmarkMenu->setText(i18n("&Bookmarks"));
     auto *bookmarks = new KJotsBookmarks(m_collectionView->selectionModel(), this);
     connect(bookmarks, &KJotsBookmarks::openLink, this, &KJotsWidget::openLink);
     auto *bmm = new KBookmarkMenu(
         KBookmarkManager::managerForFile(
             QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QStringLiteral("/kjots/bookmarks.xml"),
             QStringLiteral("kjots")),
         bookmarks, bookmarkMenu->menu());
     // "Add bookmark" and "make text bold" actions have conflicting shortcuts (ctrl + b)
     // Make add_bookmark use ctrl+shift+b to resolve that.
     action = bmm->addBookmarkAction();
     actionCollection->addAction(QStringLiteral("add_bookmark"), action);
     actionCollection->setDefaultShortcut(action, Qt::CTRL | Qt::SHIFT | Qt::Key_B);
     actionCollection->addAction(QStringLiteral("edit_bookmark"), bmm->editBookmarksAction());
     actionCollection->addAction(QStringLiteral("add_bookmarks_list"), bmm->bookmarkTabsAsFolderAction());
 
     // Export actions
     auto *exportMenu = actionCollection->add<KActionMenu>(QStringLiteral("save_to"));
     exportMenu->setText(i18n("Export"));
     exportMenu->setIcon(QIcon::fromTheme(QStringLiteral("document-export")));
 
     action = actionCollection->addAction(QStringLiteral("save_to_ascii"));
     action->setText(i18n("To Text File..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("text-plain")));
     connect(action, &QAction::triggered, this, [this](){
             exportSelection(QStringLiteral("plain_text"), QStringLiteral("template.txt"));
         });
     exportMenu->menu()->addAction(action);
 
     action = actionCollection->addAction(QStringLiteral("save_to_html"));
     action->setText(i18n("To HTML File..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("text-html")));
     connect(action, &QAction::triggered, this, [this](){
             exportSelection(QStringLiteral("default"), QStringLiteral("template.html"));
         });
     exportMenu->menu()->addAction(action);
 
-    // Some extra actions
+    // Move actions
     action = actionCollection->addAction(QStringLiteral("go_next_book"));
     action->setText(i18n("Next Book"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
     actionCollection->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_PageDown));
     connect(action, &QAction::triggered, this, [this](){
             const QModelIndex idx = previousNextEntity(m_collectionView, +1);
             m_collectionView->selectionModel()->select(idx, QItemSelectionModel::SelectCurrent);
             m_collectionView->expand(idx);
         });
     connect(this, &KJotsWidget::canGoNextBookChanged, action, &QAction::setEnabled);
 
     action = actionCollection->addAction(QStringLiteral("go_prev_book"));
     action->setText(i18n("Previous Book"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     actionCollection->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_PageUp));
     connect(action, &QAction::triggered, this, [this](){
             const QModelIndex idx = previousNextEntity(m_collectionView, -1);
             m_collectionView->selectionModel()->select(idx, QItemSelectionModel::SelectCurrent);
             m_collectionView->expand(idx);
         });
     connect(this, &KJotsWidget::canGoPreviousBookChanged, action, &QAction::setEnabled);
+
+    // View mode actions
+    m_viewModeGroup = new QActionGroup(this);
+
+    action = new QAction(i18nc("@action:inmenu", "Two Columns"), m_viewModeGroup);
+    action->setCheckable(true);
+    action->setData(1);
+    actionCollection->addAction(QStringLiteral("view_mode_two_columns"), action);
+
+    action = new QAction(i18nc("@action:inmenu", "Three Columns"), m_viewModeGroup);
+    action->setCheckable(true);
+    action->setData(2);
+    actionCollection->addAction(QStringLiteral("view_mode_three_columns"), action);
+
+    connect(m_viewModeGroup, &QActionGroup::triggered, this, [this](QAction *action){
+            setViewMode(action->data().toInt());
+        });
 }
 
 void KJotsWidget::delayedInitialization()
 {
-    // Actions are enabled or disabled based on whether the selection is a single page, a single book
-    // multiple selections, or no selection.
-    //
-    // The entryActions are enabled for all single pages and single books, and the multiselectionActions
-    // are enabled when the user has made multiple selections.
-    //
-    // Some actions are in neither (eg, new book) and are available even when there is no selection.
-    //
-    // Some actions are in both, so that they are available for valid selections, but not available
-    // for invalid selections (eg, print/find are disabled when there is no selection)
+    // anySelectionActions are available when at least something is selected (i.e. editor/browser are not empty
+    // editorActions are only available when there is a single selection, i.e. when the editor is visible
 
     KActionCollection *actionCollection = m_xmlGuiClient->actionCollection();
 
     // Actions for a single item selection.
     anySelectionActions = { actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Find))),
                             actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Print))),
                             actionCollection->action(QStringLiteral("save_to")) };
 
-    // Actions that are used only when a page is selected.
+    // Actions that are used only when a note is selected.
     editorActions = { actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Cut))),
                       actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Paste))),
                       actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Replace))),
                       actionCollection->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Save))) };
 
     updateMenu();
+
+    // Load view mode and splitters
+    setViewMode(0);
 }
 
 inline QTextEdit *KJotsWidget::activeEditor()
 {
     if (m_browserWidget->isVisible()) {
         return m_browserWidget->browser();
     } else {
         return m_editor;
     }
 }
 
 void KJotsWidget::updateMenu()
 {
     const int collectionsSelected = m_collectionView->selectionModel()->selectedRows().count();
     const int itemsSelected = m_itemView->selectionModel()->selectedRows().count();
     const int selectionSize = itemsSelected + collectionsSelected;
 
     // Actions available only when editor is shown
     m_editor->setEnableActions(itemsSelected == 1);
     for (QAction *action : qAsConst(editorActions)) {
         action->setEnabled(itemsSelected == 1);
     }
 
     // Rename is available only when single something is selected
     m_xmlGuiClient->actionCollection()
             ->action(QString::fromLatin1(KStandardAction::name(KStandardAction::RenameFile)))
             ->setEnabled((itemsSelected == 1) || (m_collectionView->hasFocus() && collectionsSelected == 1));
 
     // Actions available when at least something is shown
     for (QAction *action : qAsConst(anySelectionActions)) {
         action->setEnabled(selectionSize >= 1);
     }
 }
 
 void KJotsWidget::configure()
 {
     if (KConfigDialog::showDialog(QStringLiteral("kjotssettings"))) {
         return;
     }
     auto* dialog = new KConfigDialog(this, QStringLiteral("kjotssettings"), KJotsSettings::self());
     dialog->addPage(new KJotsConfigMisc(dialog), i18nc("@title:window config dialog page", "Misc"), QStringLiteral("preferences-other"));
     connect(dialog, &KConfigDialog::settingsChanged, this, &KJotsWidget::updateConfiguration);
     dialog->show();
 }
 
 void KJotsWidget::updateConfiguration()
 {
     if (KJotsSettings::autoSave()) {
         m_autosaveTimer->setInterval(KJotsSettings::autoSaveInterval() * 1000 * 60);
         m_autosaveTimer->start();
     } else {
         m_autosaveTimer->stop();
     }
 }
 
 QString KJotsWidget::renderSelectionTo(const QString &theme, const QString &templ)
 {
     QList<QVariant> objectList;
 
     const QModelIndexList selectedItems = m_itemView->selectionModel()->selectedRows();
     if (selectedItems.count() > 0) {
         objectList.reserve(selectedItems.size());
         std::transform(selectedItems.cbegin(), selectedItems.cend(), std::back_inserter(objectList),
             [](const QModelIndex &idx){
                 return idx.data(KJotsModel::GrantleeObjectRole);
             });
     } else {
         const QModelIndexList selectedCollections = m_collectionView->selectionModel()->selectedRows();
         objectList.reserve(selectedCollections.size());
         std::transform(selectedCollections.cbegin(), selectedCollections.cend(), std::back_inserter(objectList),
             [](const QModelIndex &idx){
                 return idx.data(KJotsModel::GrantleeObjectRole);
             });
     }
     QHash<QString, QVariant> hash = {{QStringLiteral("entities"), objectList},
                                      {QStringLiteral("i18n_TABLE_OF_CONTENTS"), i18nc("Header for 'Table of contents' section of rendered output", "Table of contents")}};
     Context c(hash);
 
     const QString currentTheme = m_loader->themeName();
     m_loader->setTheme(theme);
     Template t = m_templateEngine->loadByName(templ);
     const QString result = t->render(&c);
     m_loader->setTheme(currentTheme);
     return result;
 }
 
 QString KJotsWidget::renderSelectionToHtml()
 {
     return renderSelectionTo(QStringLiteral("default"), QStringLiteral("template.html"));
 }
 
 void KJotsWidget::exportSelection(const QString &theme, const QString &templ)
 {
     // TODO: dialog captions & etc
     QString filename = QFileDialog::getSaveFileName();
     if (filename.isEmpty()) {
         return;
     }
     QFile exportFile(filename);
     if (!exportFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
         KMessageBox::error(this, i18n("<qt>Could not open \"%1\" for writing</qt>", filename));
         return;
     }
     exportFile.write(renderSelectionTo(theme, templ).toUtf8());
     exportFile.close();
 }
 
 std::unique_ptr<QPrinter> KJotsWidget::setupPrinter(QPrinter::PrinterMode mode)
 {
     auto printer = std::make_unique<QPrinter>(mode);
     printer->setDocName(QStringLiteral("KJots_Print"));
     printer->setCreator(QStringLiteral("KJots"));
     if (!activeEditor()->textCursor().selection().isEmpty()) {
         printer->setPrintRange(QPrinter::Selection);
     }
     return printer;
 }
 
 void KJotsWidget::printPreviewSelection()
 {
     auto printer = setupPrinter(QPrinter::ScreenResolution);
     QPrintPreviewDialog previewdlg(printer.get(), this);
     connect(&previewdlg, &QPrintPreviewDialog::paintRequested, this, &KJotsWidget::print);
     previewdlg.exec();
 }
 
 void KJotsWidget::printSelection()
 {
     auto printer = setupPrinter(QPrinter::HighResolution);
     QPrintDialog printDialog(printer.get(), this);
     if (printDialog.exec() == QDialog::Accepted) {
         print(printer.get());
     }
 }
 
 void KJotsWidget::print(QPrinter *printer)
 {
     QTextDocument printDocument;
     if (printer->printRange() == QPrinter::Selection) {
         printDocument.setHtml(activeEditor()->textCursor().selection().toHtml());
     } else {
         QString currentTheme = m_loader->themeName();
         m_loader->setTheme(QStringLiteral("default"));
         printDocument.setHtml(renderSelectionToHtml());
         m_loader->setTheme(currentTheme);
     }
     printDocument.print(printer);
 }
 
 QModelIndex KJotsWidget::previousNextEntity(QTreeView *view, int step)
 {
     const QModelIndexList selection = view->selectionModel()->selectedRows();
     if (selection.size() == 0) {
         return step > 0 ? view->model()->index(0, 0) : view->model()->index(view->model()->rowCount()-1, 0);
     }
     if (selection.size() != 1) {
         return {};
     }
     return step > 0 ? view->indexBelow(selection.first()) : view->indexAbove(selection.first());
 }
 
 void KJotsWidget::renderSelection()
 {
     Q_EMIT canGoNextBookChanged(previousNextEntity(m_collectionView, +1).isValid());
     Q_EMIT canGoNextPageChanged(previousNextEntity(m_itemView, +1).isValid());
     Q_EMIT canGoPreviousBookChanged(previousNextEntity(m_collectionView, -1).isValid());
     Q_EMIT canGoPreviousPageChanged(previousNextEntity(m_itemView, -1).isValid());
 
     const QModelIndexList selectedItems = m_itemView->selectionModel()->selectedRows();
 
     // If the selection is a single note, present it for editing...
     if (selectedItems.count() == 1) {
         if (m_editor->setModelIndex(selectedItems.first())) {
             m_stackedWidget->setCurrentWidget(m_editorWidget);
             return;
         }
         // If something went wrong, we show user the browser
     }
     // ... Otherwise, render the selection read-only.
     m_browserWidget->browser()->setHtml(renderSelectionToHtml());
     m_stackedWidget->setCurrentWidget(m_browserWidget);
 }
 
 void KJotsWidget::updateCaption()
 {
     const QModelIndexList selection = m_collectionView->selectionModel()->selectedRows();
     QString caption;
     if (selection.size() == 1) {
         caption = KJotsModel::itemPath(selection.first());
         if (m_editor->modified()) {
             caption.append(QStringLiteral(" *"));
         }
     } else if (selection.size() > 1) {
         caption = i18nc("@title:window", "Multiple selection");
     }
     Q_EMIT captionChanged(caption);
 }
 
 bool KJotsWidget::queryClose()
 {
     // Saving the current note
     // We cannot use async interface (i.e. ETM) here
     // because we need to abort the close if something went wrong
     if ((m_collectionSelectionProxyModel->rowCount() == 1) && (m_editor->document()->isModified())) {
         QModelIndex idx = m_collectionSelectionProxyModel->mapToSource(m_collectionSelectionProxyModel->index(0, 0, QModelIndex()));
         auto job = new ItemModifyJob(KJotsModel::updateItem(idx, m_editor->document()));
         if (!job->exec()) {
             int res = KMessageBox::warningContinueCancelDetailed(this,
                                                                  i18n("Unable to save the note.\n"
                                                                       "You can save your note to a local file using the \"File - Export\" menu,\n"
                                                                       "otherwise you will lose your changes!\n"
                                                                       "Do you want to close anyways?"),
                                                                  i18n("Close Document"),
                                                                  KStandardGuiItem::quit(),
                                                                  KStandardGuiItem::cancel(),
                                                                  QString(),
                                                                  KMessageBox::Notify,
                                                                  i18n("Error message:\n"
                                                                       "%1", job->errorString()));
             if (res == KMessageBox::Cancel) {
                 return false;
             }
         } else {
             // Saved successfully.
             // However, KJotsEdit will still catch focusOutEvent and try saving using async interface
             // (application will quit soon, so it doesn't really make much sense doing it)
             // Marking the document as saved explicitly it order to avoid it
             m_editor->document()->setModified(false);
         }
 
     }
 
     saveSplitterStates();
     KJotsSettings::self()->save();
     m_orderProxy->saveOrder();
 
     return true;
 }
 
 void KJotsWidget::openLink(const QUrl &url)
 {
     if (url.scheme() == QStringLiteral("akonadi")) {
         m_collectionView->selectionModel()->select(KJotsModel::modelIndexForUrl(m_collectionView->model(), url), QItemSelectionModel::ClearAndSelect);
     } else {
         new KRun(url, this);
     }
 }
diff --git a/src/kjotswidget.h b/src/kjotswidget.h
index c590454..f651e53 100644
--- a/src/kjotswidget.h
+++ b/src/kjotswidget.h
@@ -1,166 +1,168 @@
 /*
     This file is part of KJots.
 
     Copyright (C) 1997 Christoph Neerfeld <Christoph.Neerfeld@home.ivm.de>
     Copyright (C) 2002, 2003 Aaron J. Seigo <aseigo@kde.org>
     Copyright (C) 2003 Stanislav Kljuhhin <crz@hot.ee>
     Copyright (C) 2005-2006 Jaison Lee <lee.jaison@gmail.com>
     Copyright (C) 2007-2009 Stephen Kelly <steveire@gmail.com>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #ifndef KJOTSWIDGET_H
 #define KJOTSWIDGET_H
 
 #include <QWidget>
 #include <QAbstractItemDelegate>
 #include <QPrinter>
 
 #include <AkonadiCore/Collection>
 
 #include <grantlee/templateloader.h>
 
+class QActionGroup;
 class QCheckBox;
 class QTextEdit;
 class QTextCharFormat;
 class QSplitter;
 class QStackedWidget;
 class QModelIndex;
 class QTreeView;
 
 class KActionMenu;
 class KFindDialog;
 class KJob;
 class KReplaceDialog;
 class KSelectionProxyModel;
 class KJotsBrowser;
 class KJotsBrowserWidget;
 class KXMLGUIClient;
 
 namespace Akonadi
 {
 class EntityMimeTypeFilterModel;
 class EntityOrderProxyModel;
 class EntityTreeView;
 class StandardNoteActionManager;
 }
 
 namespace Grantlee
 {
 class Engine;
 }
 
 namespace KPIMTextEdit
 {
 class RichTextEditorWidget;
 }
 
 class KJotsEdit;
 class KJotsModel;
 class KJotsTreeView;
 class KJotsSortProxyModel;
 
 class KJotsWidget : public QWidget
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KJotsWidget")
 
 public:
     explicit KJotsWidget(QWidget *parent, KXMLGUIClient *xmlGuiclient, Qt::WindowFlags f = Qt::WindowFlags());
     ~KJotsWidget();
 
     QTextEdit *activeEditor();
 public Q_SLOTS:
     void configure();
     void updateCaption();
     void updateMenu();
 
     Q_SCRIPTABLE bool queryClose();
 
     void setViewMode(int mode);
 
 Q_SIGNALS:
     void canGoNextPageChanged(bool);
     void canGoPreviousPageChanged(bool);
     void canGoNextBookChanged(bool);
     void canGoPreviousBookChanged(bool);
 
     void captionChanged(const QString &newCaption);
 
 protected:
     static QModelIndex previousNextEntity(QTreeView *view, int step);
 
     void setupGui();
     void setupActions();
 
     QString renderSelectionTo(const QString &theme, const QString &templ);
     QString renderSelectionToHtml();
 
     std::unique_ptr<QPrinter> setupPrinter(QPrinter::PrinterMode mode = QPrinter::ScreenResolution);
 
     void saveSplitterStates() const;
     void restoreSplitterStates();
 protected Q_SLOTS:
     /**
      * Renders contents on either KJotsEdit or KJotsBrowser based on KJotsTreeView selection
      */
     void renderSelection();
     void exportSelection(const QString &theme, const QString &templ);
     void printSelection();
     void printPreviewSelection();
 
     void openLink(const QUrl &url);
 private Q_SLOTS:
     void delayedInitialization();
 
     void saveState();
     void restoreState();
     void updateConfiguration();
 
     void print(QPrinter *printer);
 private:
     // Grantlee
     Grantlee::Engine *m_templateEngine = nullptr;
     QSharedPointer<Grantlee::FileSystemTemplateLoader> m_loader;
 
     // XMLGui && Actions
     KXMLGUIClient  *m_xmlGuiClient = nullptr;
     Akonadi::StandardNoteActionManager *m_actionManager = nullptr;
     QSet<QAction *> anySelectionActions, editorActions;
+    QActionGroup *m_viewModeGroup = nullptr;
 
     // UI
     QSplitter *m_splitter1 = nullptr;
     QSplitter *m_splitter2 = nullptr;
     QStackedWidget *m_stackedWidget = nullptr;
     Akonadi::EntityTreeView *m_collectionView = nullptr;
     Akonadi::EntityTreeView *m_itemView = nullptr;
     KJotsEdit      *m_editor = nullptr;
     KPIMTextEdit::RichTextEditorWidget *m_editorWidget = nullptr;
     KJotsBrowserWidget *m_browserWidget = nullptr;
 
     // Models
     KJotsModel *m_kjotsModel = nullptr;
     Akonadi::EntityMimeTypeFilterModel *m_collectionModel = nullptr;
     Akonadi::EntityMimeTypeFilterModel *m_itemModel = nullptr;
     KSelectionProxyModel *m_collectionSelectionProxyModel = nullptr;
     KJotsSortProxyModel *m_sortProxyModel = nullptr;
     Akonadi::EntityOrderProxyModel *m_orderProxy = nullptr;
 
     QTimer *m_autosaveTimer = nullptr;
 };
 
 #endif