diff --git a/CMakeLists.txt b/CMakeLists.txt
index f28a2d567ec02172bcdffffd18e681fae15ab45c..d0ff2ce921d267d93a343d411264247ce48feab4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -177,12 +177,12 @@ SET( libringclient_LIB_SRCS
   src/accountmodel.cpp
   src/availableaccountmodel.cpp
   src/callmodel.cpp
-  src/historymodel.cpp
-  src/bookmarkmodel.cpp
+  src/categorizedhistorymodel.cpp
+  src/categorizedbookmarkmodel.cpp
   src/credentialmodel.cpp
   src/instantmessagingmodel.cpp
   src/imconversationmanager.cpp
-  src/contactproxymodel.cpp
+  src/categorizedcontactmodel.cpp
   src/useractionmodel.cpp
   src/presencestatusmodel.cpp
   src/phonedirectorymodel.cpp
@@ -266,16 +266,16 @@ SET( libringclient_LIB_HDRS
   src/availableaccountmodel.h
   src/call.h
   src/callmodel.h
-  src/historymodel.h
+  src/categorizedhistorymodel.h
   src/person.h
   src/bootstrapmodel.h
   src/collectioninterface.h
   src/collectioninterface.hpp
-  src/bookmarkmodel.h
+  src/categorizedbookmarkmodel.h
   src/credentialmodel.h
   src/instantmessagingmodel.h
   src/imconversationmanager.h
-  src/contactproxymodel.h
+  src/categorizedcontactmodel.h
   src/useractionmodel.h
   src/presencestatusmodel.h
   src/contactmethod.h
diff --git a/src/call.cpp b/src/call.cpp
index fecf1372c5baa29b657a13b97d2681a8262d35cd..81e9c4d5b762c465b115e67f779e3d19abcc32e7 100644
--- a/src/call.cpp
+++ b/src/call.cpp
@@ -42,7 +42,7 @@
 #include "accountmodel.h"
 #include "availableaccountmodel.h"
 #include "private/videorenderermanager.h"
-#include "historymodel.h"
+#include "categorizedhistorymodel.h"
 #include "instantmessagingmodel.h"
 #include "useractionmodel.h"
 #include "callmodel.h"
diff --git a/src/call.h b/src/call.h
index 7d17005ff5deb09d65b6084766477b5152bc7c9e..6ec4ab6bd440a9ac74598faba8f9faf590145546 100644
--- a/src/call.h
+++ b/src/call.h
@@ -70,7 +70,7 @@ class  LIB_EXPORT Call : public ItemBase<QObject>
    #pragma GCC diagnostic pop
 public:
    friend class CallModel            ;
-   friend class HistoryModel         ;
+   friend class CategorizedHistoryModel         ;
    friend class CallModelPrivate     ;
    friend class IMConversationManager;
    friend class VideoRendererManager;
diff --git a/src/callmodel.cpp b/src/callmodel.cpp
index 0b337e7e5b8fff25d38b3584a855ab6292cb6129..613c4eb911291f2d7419d30b0637298806bd60bb 100644
--- a/src/callmodel.cpp
+++ b/src/callmodel.cpp
@@ -39,7 +39,7 @@
 #include "typedefs.h"
 #include "collectioninterface.h"
 #include "dbus/videomanager.h"
-#include "historymodel.h"
+#include "categorizedhistorymodel.h"
 #include "delegates/phonenumberselectordelegate.h"
 #include "personmodel.h"
 #include "useractionmodel.h"
@@ -169,11 +169,11 @@ void CallModelPrivate::init()
       #endif
       /*                                                                                                                           */
 
-      connect(HistoryModel::instance(),SIGNAL(newHistoryCall(Call*)),this,SLOT(slotAddPrivateCall(Call*)));
+      connect(CategorizedHistoryModel::instance(),SIGNAL(newHistoryCall(Call*)),this,SLOT(slotAddPrivateCall(Call*)));
 
       dbusInit = true;
 
-      HistoryModel::instance();
+      CategorizedHistoryModel::instance();
    }
    static bool m_sInstanceInit = false;
    if (!m_sInstanceInit)
@@ -1047,7 +1047,7 @@ void CallModelPrivate::slotCallStateChanged(const QString& callID, const QString
    //Add to history
    if (call->lifeCycleState() == Call::LifeCycleState::FINISHED) {
       if (!call->collection()) {
-         foreach (CollectionInterface* backend, HistoryModel::instance()->collections(CollectionInterface::ADD)) {
+         foreach (CollectionInterface* backend, CategorizedHistoryModel::instance()->collections(CollectionInterface::ADD)) {
             if (backend->editor<Call>()->addNew(call))
                call->setCollection(backend);
          }
diff --git a/src/bookmarkmodel.cpp b/src/categorizedbookmarkmodel.cpp
similarity index 80%
rename from src/bookmarkmodel.cpp
rename to src/categorizedbookmarkmodel.cpp
index ff0ff3de5da8dd77e6f0e9ecd8d92f777333af5a..66df2e0ae15cfc2290b116c9329648e9fbd8657a 100644
--- a/src/bookmarkmodel.cpp
+++ b/src/categorizedbookmarkmodel.cpp
@@ -15,14 +15,14 @@
  *   You should have received a copy of the GNU General Public License      *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  ***************************************************************************/
-#include "bookmarkmodel.h"
+#include "categorizedbookmarkmodel.h"
 
 //Qt
 #include <QtCore/QMimeData>
 #include <QtCore/QCoreApplication>
 
 //Ring
-#include "historymodel.h"
+#include "categorizedhistorymodel.h"
 #include "dbus/presencemanager.h"
 #include "phonedirectorymodel.h"
 #include "contactmethod.h"
@@ -36,7 +36,7 @@
 
 ///Top level bookmark item
 class BookmarkTopLevelItem : public CategorizedCompositeNode {
-   friend class BookmarkModel;
+   friend class CategorizedBookmarkModel;
    public:
       virtual QObject* getSelf() const;
       int m_Row;
@@ -47,11 +47,11 @@ class BookmarkTopLevelItem : public CategorizedCompositeNode {
       bool m_MostPopular;
 };
 
-class BookmarkModelPrivate : public QObject
+class CategorizedBookmarkModelPrivate : public QObject
 {
    Q_OBJECT
 public:
-   BookmarkModelPrivate(BookmarkModel* parent);
+   CategorizedBookmarkModelPrivate(CategorizedBookmarkModel* parent);
 
 //    QVector<CollectionInterface*> m_lBackends;
 
@@ -72,10 +72,10 @@ private Q_SLOTS:
    void slotIndexChanged(const QModelIndex& idx);
 
 private:
-   BookmarkModel* q_ptr;
+   CategorizedBookmarkModel* q_ptr;
 };
 
-BookmarkModel* BookmarkModel::m_spInstance = nullptr;
+CategorizedBookmarkModel* CategorizedBookmarkModel::m_spInstance = nullptr;
 
 class BookmarkItemNode;
 
@@ -83,7 +83,7 @@ static bool test = false;
 //Model item/index
 class NumberTreeBackend : public CategorizedCompositeNode
 {
-   friend class BookmarkModel;
+   friend class CategorizedBookmarkModel;
    public:
       NumberTreeBackend(ContactMethod* number);
       virtual ~NumberTreeBackend();
@@ -99,18 +99,18 @@ class BookmarkItemNode : public QObject //TODO remove this once Qt4 support is d
 {
    Q_OBJECT
 public:
-   BookmarkItemNode(BookmarkModel* m, ContactMethod* n, NumberTreeBackend* backend);
+   BookmarkItemNode(CategorizedBookmarkModel* m, ContactMethod* n, NumberTreeBackend* backend);
 private:
    ContactMethod* m_pNumber;
    NumberTreeBackend* m_pBackend;
-   BookmarkModel* m_pModel;
+   CategorizedBookmarkModel* m_pModel;
 private Q_SLOTS:
    void slotNumberChanged();
 Q_SIGNALS:
    void changed(const QModelIndex& idx);
 };
 
-BookmarkModelPrivate::BookmarkModelPrivate(BookmarkModel* parent) : QObject(parent), q_ptr(parent)
+CategorizedBookmarkModelPrivate::CategorizedBookmarkModelPrivate(CategorizedBookmarkModel* parent) : QObject(parent), q_ptr(parent)
 {
    
 }
@@ -124,7 +124,7 @@ NumberTreeBackend::~NumberTreeBackend() {
    if (m_pNode) delete m_pNode;
 }
 
-BookmarkItemNode::BookmarkItemNode(BookmarkModel* m, ContactMethod* n, NumberTreeBackend* backend) :
+BookmarkItemNode::BookmarkItemNode(CategorizedBookmarkModel* m, ContactMethod* n, NumberTreeBackend* backend) :
 m_pNumber(n),m_pBackend(backend),m_pModel(m){
    connect(n,SIGNAL(changed()),this,SLOT(slotNumberChanged()));
 }
@@ -139,10 +139,10 @@ QObject* BookmarkTopLevelItem::getSelf() const
    return nullptr;
 }
 
-BookmarkModel::BookmarkModel(QObject* parent) : QAbstractItemModel(parent), CollectionManagerInterface<ContactMethod>(this),
-d_ptr(new BookmarkModelPrivate(this))
+CategorizedBookmarkModel::CategorizedBookmarkModel(QObject* parent) : QAbstractItemModel(parent), CollectionManagerInterface<ContactMethod>(this),
+d_ptr(new CategorizedBookmarkModelPrivate(this))
 {
-   setObjectName("BookmarkModel");
+   setObjectName("CategorizedBookmarkModel");
    reloadCategories();
    d_ptr->m_lMimes << RingMimes::PLAIN_TEXT << RingMimes::PHONENUMBER;
 
@@ -153,14 +153,14 @@ d_ptr(new BookmarkModelPrivate(this))
 //    } //TODO implement reordering
 }
 
-BookmarkModel* BookmarkModel::instance()
+CategorizedBookmarkModel* CategorizedBookmarkModel::instance()
 {
    if (! m_spInstance )
-      m_spInstance = new BookmarkModel(QCoreApplication::instance());
+      m_spInstance = new CategorizedBookmarkModel(QCoreApplication::instance());
    return m_spInstance;
 }
 
-QHash<int,QByteArray> BookmarkModel::roleNames() const
+QHash<int,QByteArray> CategorizedBookmarkModel::roleNames() const
 {
    static QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
    static bool initRoles = false;
@@ -172,7 +172,7 @@ QHash<int,QByteArray> BookmarkModel::roleNames() const
 }
 
 ///Reload bookmark cateogries
-void BookmarkModel::reloadCategories()
+void CategorizedBookmarkModel::reloadCategories()
 {
    test = true;
    beginResetModel(); {
@@ -238,7 +238,7 @@ void BookmarkModel::reloadCategories()
 } //reloadCategories
 
 //Do nothing
-bool BookmarkModel::setData( const QModelIndex& index, const QVariant &value, int role)
+bool CategorizedBookmarkModel::setData( const QModelIndex& index, const QVariant &value, int role)
 {
    Q_UNUSED(index)
    Q_UNUSED(value)
@@ -247,7 +247,7 @@ bool BookmarkModel::setData( const QModelIndex& index, const QVariant &value, in
 }
 
 ///Get bookmark model data CategorizedCompositeNode::Type and Call::Role
-QVariant BookmarkModel::data( const QModelIndex& index, int role) const
+QVariant CategorizedBookmarkModel::data( const QModelIndex& index, int role) const
 {
    if (!index.isValid() || test)
       return QVariant();
@@ -281,7 +281,7 @@ QVariant BookmarkModel::data( const QModelIndex& index, int role) const
 } //Data
 
 ///Get header data
-QVariant BookmarkModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant CategorizedBookmarkModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
    Q_UNUSED(section)
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
@@ -291,7 +291,7 @@ QVariant BookmarkModel::headerData(int section, Qt::Orientation orientation, int
 
 
 ///Get the number of child of "parent"
-int BookmarkModel::rowCount( const QModelIndex& parent ) const
+int CategorizedBookmarkModel::rowCount( const QModelIndex& parent ) const
 {
    if (test) return 0; //HACK
    if (!parent.isValid())
@@ -303,7 +303,7 @@ int BookmarkModel::rowCount( const QModelIndex& parent ) const
    return 0;
 }
 
-Qt::ItemFlags BookmarkModel::flags( const QModelIndex& index ) const
+Qt::ItemFlags CategorizedBookmarkModel::flags( const QModelIndex& index ) const
 {
    if (!index.isValid())
       return 0;
@@ -311,14 +311,14 @@ Qt::ItemFlags BookmarkModel::flags( const QModelIndex& index ) const
 }
 
 ///There is only 1 column
-int BookmarkModel::columnCount ( const QModelIndex& parent) const
+int CategorizedBookmarkModel::columnCount ( const QModelIndex& parent) const
 {
    Q_UNUSED(parent)
    return 1;
 }
 
 ///Get the bookmark parent
-QModelIndex BookmarkModel::parent( const QModelIndex& idx) const
+QModelIndex CategorizedBookmarkModel::parent( const QModelIndex& idx) const
 {
    if (!idx.isValid()) {
       return QModelIndex();
@@ -334,7 +334,7 @@ QModelIndex BookmarkModel::parent( const QModelIndex& idx) const
 } //parent
 
 ///Get the index
-QModelIndex BookmarkModel::index(int row, int column, const QModelIndex& parent) const
+QModelIndex CategorizedBookmarkModel::index(int row, int column, const QModelIndex& parent) const
 {
    if (parent.isValid() && !column)
       return createIndex(row,column,(void*) static_cast<CategorizedCompositeNode*>(d_ptr->m_lCategoryCounter[parent.row()]->m_lChildren[row]));
@@ -345,13 +345,13 @@ QModelIndex BookmarkModel::index(int row, int column, const QModelIndex& parent)
 }
 
 ///Get bookmarks mime types
-QStringList BookmarkModel::mimeTypes() const
+QStringList CategorizedBookmarkModel::mimeTypes() const
 {
    return d_ptr->m_lMimes;
 }
 
 ///Generate mime data
-QMimeData* BookmarkModel::mimeData(const QModelIndexList &indexes) const
+QMimeData* CategorizedBookmarkModel::mimeData(const QModelIndexList &indexes) const
 {
    QMimeData *mimeData = new QMimeData();
    foreach (const QModelIndex &index, indexes) {
@@ -366,13 +366,13 @@ QMimeData* BookmarkModel::mimeData(const QModelIndexList &indexes) const
 } //mimeData
 
 ///Return valid payload types
-int BookmarkModel::acceptedPayloadTypes()
+int CategorizedBookmarkModel::acceptedPayloadTypes()
 {
    return CallModel::DropPayloadType::CALL;
 }
 
 ///Get call info TODO use Call:: one
-QVariant BookmarkModelPrivate::commonCallInfo(NumberTreeBackend* number, int role) const
+QVariant CategorizedBookmarkModelPrivate::commonCallInfo(NumberTreeBackend* number, int role) const
 {
    if (!number)
       return QVariant();
@@ -424,7 +424,7 @@ QVariant BookmarkModelPrivate::commonCallInfo(NumberTreeBackend* number, int rol
 } //commonCallInfo
 
 ///Get category
-QString BookmarkModelPrivate::category(NumberTreeBackend* number) const
+QString CategorizedBookmarkModelPrivate::category(NumberTreeBackend* number) const
 {
    QString cat = commonCallInfo(number).toString();
    if (cat.size())
@@ -432,7 +432,7 @@ QString BookmarkModelPrivate::category(NumberTreeBackend* number) const
    return cat;
 }
 
-void BookmarkModelPrivate::slotRequest(const QString& uri)
+void CategorizedBookmarkModelPrivate::slotRequest(const QString& uri)
 {
    Q_UNUSED(uri)
    qDebug() << "Presence Request" << uri << "denied";
@@ -441,7 +441,7 @@ void BookmarkModelPrivate::slotRequest(const QString& uri)
 
 
 
-QVector<ContactMethod*> BookmarkModelPrivate::serialisedToList(const QStringList& list)
+QVector<ContactMethod*> CategorizedBookmarkModelPrivate::serialisedToList(const QStringList& list)
 {
    QVector<ContactMethod*> numbers;
    foreach(const QString& item,list) {
@@ -455,12 +455,12 @@ QVector<ContactMethod*> BookmarkModelPrivate::serialisedToList(const QStringList
    return numbers;
 }
 
-bool BookmarkModelPrivate::displayFrequentlyUsed() const
+bool CategorizedBookmarkModelPrivate::displayFrequentlyUsed() const
 {
    return true;
 }
 
-QVector<ContactMethod*> BookmarkModelPrivate::bookmarkList() const
+QVector<ContactMethod*> CategorizedBookmarkModelPrivate::bookmarkList() const
 {
    return (q_ptr->collections().size() > 0) ? q_ptr->collections()[0]->items<ContactMethod>() : QVector<ContactMethod*>();
 }
@@ -471,7 +471,7 @@ BookmarkTopLevelItem::BookmarkTopLevelItem(QString name)
 {
 }
 
-bool BookmarkModel::removeRows( int row, int count, const QModelIndex & parent)
+bool CategorizedBookmarkModel::removeRows( int row, int count, const QModelIndex & parent)
 {
    if (parent.isValid()) {
       const int parentRow = parent.row();
@@ -493,7 +493,7 @@ bool BookmarkModel::removeRows( int row, int count, const QModelIndex & parent)
    return false;
 }
 
-void BookmarkModel::addBookmark(ContactMethod* number)
+void CategorizedBookmarkModel::addBookmark(ContactMethod* number)
 {
    Q_UNUSED(number)
    if (collections().size())
@@ -502,12 +502,12 @@ void BookmarkModel::addBookmark(ContactMethod* number)
       qWarning() << "No bookmark backend is set";
 }
 
-void BookmarkModel::removeBookmark(ContactMethod* number)
+void CategorizedBookmarkModel::removeBookmark(ContactMethod* number)
 {
    Q_UNUSED(number)
 }
 
-void BookmarkModel::remove(const QModelIndex& idx)
+void CategorizedBookmarkModel::remove(const QModelIndex& idx)
 {
    Q_UNUSED(idx)
 //    ContactMethod* nb = getNumber(idx);
@@ -519,7 +519,7 @@ void BookmarkModel::remove(const QModelIndex& idx)
 //    }
 }
 
-ContactMethod* BookmarkModel::getNumber(const QModelIndex& idx)
+ContactMethod* CategorizedBookmarkModel::getNumber(const QModelIndex& idx)
 {
    if (idx.isValid()) {
       if (idx.parent().isValid() && idx.parent().row() < d_ptr->m_lCategoryCounter.size()) {
@@ -530,18 +530,18 @@ ContactMethod* BookmarkModel::getNumber(const QModelIndex& idx)
 }
 
 ///Callback when an item change
-void BookmarkModelPrivate::slotIndexChanged(const QModelIndex& idx)
+void CategorizedBookmarkModelPrivate::slotIndexChanged(const QModelIndex& idx)
 {
    emit q_ptr->dataChanged(idx,idx);
 }
 
 
-// bool BookmarkModel::hasCollections() const
+// bool CategorizedBookmarkModel::hasCollections() const
 // {
 //    return d_ptr->m_lBackends.size();
 // }
 
-// bool BookmarkModel::hasEnabledCollections() const
+// bool CategorizedBookmarkModel::hasEnabledCollections() const
 // {
 //    foreach(CollectionInterface* b, d_ptr->m_lBackends) {
 //       if (b->isEnabled())
@@ -550,36 +550,36 @@ void BookmarkModelPrivate::slotIndexChanged(const QModelIndex& idx)
 //    return false;
 // }
 
-// const QVector<CollectionInterface*> BookmarkModel::collections() const
+// const QVector<CollectionInterface*> CategorizedBookmarkModel::collections() const
 // {
 //    return d_ptr->m_lBackends;
 // }
 
 
-bool BookmarkModel::addItemCallback(const ContactMethod* item)
+bool CategorizedBookmarkModel::addItemCallback(const ContactMethod* item)
 {
    Q_UNUSED(item)
    reloadCategories(); //TODO this is far from optimal
    return true;
 }
 
-bool BookmarkModel::removeItemCallback(const ContactMethod* item)
+bool CategorizedBookmarkModel::removeItemCallback(const ContactMethod* item)
 {
    Q_UNUSED(item)
    return false;
 }
 
-// const QVector<CollectionInterface*> BookmarkModel::enabledCollections() const
+// const QVector<CollectionInterface*> CategorizedBookmarkModel::enabledCollections() const
 // {
 //    return d_ptr->m_lBackends; //TODO filter them
 // }
 
-// CommonCollectionModel* BookmarkModel::backendModel() const
+// CommonCollectionModel* CategorizedBookmarkModel::backendModel() const
 // {
 //    return nullptr; //TODO
 // }
 
-bool BookmarkModel::clearAllCollections() const
+bool CategorizedBookmarkModel::clearAllCollections() const
 {
    foreach (CollectionInterface* backend, collections()) {
       if (backend->supportedFeatures() & CollectionInterface::ADD) {
@@ -589,14 +589,14 @@ bool BookmarkModel::clearAllCollections() const
    return true;
 }
 
-// bool BookmarkModel::enableBackend(CollectionInterface* backend, bool enable)
+// bool CategorizedBookmarkModel::enableBackend(CollectionInterface* backend, bool enable)
 // {
 //    Q_UNUSED(backend)
 //    Q_UNUSED(enable)
 //    return false; //TODO
 // }
 
-// void BookmarkModel::addBackend(CollectionInterface* backend, LoadOptions options)
+// void CategorizedBookmarkModel::addBackend(CollectionInterface* backend, LoadOptions options)
 // {
 //    d_ptr->m_lBackends << backend;
 //    connect(backend,SIGNAL(newBookmarkAdded(ContactMethod*)),this,SLOT(reloadCategories()));
@@ -604,14 +604,14 @@ bool BookmarkModel::clearAllCollections() const
 //       backend->load();
 // }
 
-void BookmarkModel::collectionAddedCallback(CollectionInterface* backend)
+void CategorizedBookmarkModel::collectionAddedCallback(CollectionInterface* backend)
 {
    Q_UNUSED(backend)
 }
 
-// QString BookmarkModel::backendCategoryName() const
+// QString CategorizedBookmarkModel::backendCategoryName() const
 // {
 //    return tr("Bookmarks");
 // }
 
-#include <bookmarkmodel.moc>
+#include <categorizedbookmarkmodel.moc>
diff --git a/src/bookmarkmodel.h b/src/categorizedbookmarkmodel.h
similarity index 88%
rename from src/bookmarkmodel.h
rename to src/categorizedbookmarkmodel.h
index 83067a300b6a28da30eefb10745efd1ea662d105..0ed7c0dc7855a6b55e76c15ee2a469bcc8bdff1f 100644
--- a/src/bookmarkmodel.h
+++ b/src/categorizedbookmarkmodel.h
@@ -15,8 +15,8 @@
  *   You should have received a copy of the GNU General Public License      *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  ***************************************************************************/
-#ifndef BOOKMARKMODEL_H
-#define BOOKMARKMODEL_H
+#ifndef CATEGORIZEDBOOKMARKMODEL_H
+#define CATEGORIZEDBOOKMARKMODEL_H
 
 #include <QtCore/QAbstractItemModel>
 #include <QtCore/QHash>
@@ -33,10 +33,10 @@
 class PersonBackend;
 class NumberTreeBackend;
 
-class BookmarkModelPrivate;
+class CategorizedBookmarkModelPrivate;
 class CollectionInterface2;
 
-class LIB_EXPORT BookmarkModel :  public QAbstractItemModel, public CollectionManagerInterface<ContactMethod>
+class LIB_EXPORT CategorizedBookmarkModel :  public QAbstractItemModel, public CollectionManagerInterface<ContactMethod>
 {
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
@@ -45,8 +45,8 @@ class LIB_EXPORT BookmarkModel :  public QAbstractItemModel, public CollectionMa
 public:
    friend class NumberTreeBackend;
    //Constructor
-   virtual ~BookmarkModel() {}
-   explicit BookmarkModel(QObject* parent);
+   virtual ~CategorizedBookmarkModel() {}
+   explicit CategorizedBookmarkModel(QObject* parent);
 
    //Setters
    void setRole(int role);
@@ -79,13 +79,13 @@ public:
    ContactMethod* getNumber(const QModelIndex& idx);
 
    //Singleton
-   static BookmarkModel* instance();
+   static CategorizedBookmarkModel* instance();
 
 private:
-   static BookmarkModel* m_spInstance;
+   static CategorizedBookmarkModel* m_spInstance;
 
-   BookmarkModelPrivate* d_ptr;
-   Q_DECLARE_PRIVATE(BookmarkModel)
+   CategorizedBookmarkModelPrivate* d_ptr;
+   Q_DECLARE_PRIVATE(CategorizedBookmarkModel)
 
    //Backend interface
    virtual void collectionAddedCallback(CollectionInterface* backend) override;
diff --git a/src/contactproxymodel.cpp b/src/categorizedcontactmodel.cpp
similarity index 84%
rename from src/contactproxymodel.cpp
rename to src/categorizedcontactmodel.cpp
index ddd25b7ad975c9cd8af207f8bde1f8a69db556f4..dec3f572d3ddfa90c537187e52a7b2fc23eb7ba7 100644
--- a/src/contactproxymodel.cpp
+++ b/src/categorizedcontactmodel.cpp
@@ -15,7 +15,7 @@
  *   You should have received a copy of the GNU General Public License      *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  ***************************************************************************/
-#include "contactproxymodel.h"
+#include "categorizedcontactmodel.h"
 
 //Qt
 #include <QtCore/QDebug>
@@ -25,7 +25,7 @@
 
 //Ring
 #include "callmodel.h"
-#include "historymodel.h"
+#include "categorizedhistorymodel.h"
 #include "contactmethod.h"
 #include "phonedirectorymodel.h"
 #include "historytimecategorymodel.h"
@@ -38,8 +38,8 @@ class ContactTreeNode;
 
 class ContactTreeNode : public CategorizedCompositeNode {
 public:
-   friend class ContactProxyModel;
-   friend class ContactProxyModelPrivate;
+   friend class CategorizedContactModel;
+   friend class CategorizedContactModelPrivate;
    friend class ContactTreeBinder;
 
    enum class NodeType {
@@ -49,9 +49,9 @@ public:
    };
 
    //Constructor
-   ContactTreeNode( Person* ct          , ContactProxyModel* parent);
-   ContactTreeNode( ContactMethod* cm   , ContactProxyModel* parent);
-   ContactTreeNode( const QString& name , ContactProxyModel* parent);
+   ContactTreeNode( Person* ct          , CategorizedContactModel* parent);
+   ContactTreeNode( ContactMethod* cm   , CategorizedContactModel* parent);
+   ContactTreeNode( const QString& name , CategorizedContactModel* parent);
    virtual ~ContactTreeNode();
 
    virtual QObject* getSelf() const override;
@@ -64,7 +64,7 @@ public:
    NodeType                  m_Type          ;
    ContactTreeNode*          m_pParent       ;
    QVector<ContactTreeNode*> m_lChildren     ;
-   ContactProxyModel*        m_pModel        ;
+   CategorizedContactModel*        m_pModel        ;
 
    //Helpers
    void slotChanged                        (       );
@@ -72,11 +72,11 @@ public:
    void slotContactMethodCountAboutToChange(int,int);
 };
 
-class ContactProxyModelPrivate : public QObject
+class CategorizedContactModelPrivate : public QObject
 {
    Q_OBJECT
 public:
-   ContactProxyModelPrivate(ContactProxyModel* parent);
+   CategorizedContactModelPrivate(CategorizedContactModel* parent);
 
    //Helpers
    QString category(const Person* ct) const;
@@ -93,14 +93,14 @@ public:
    QModelIndex getIndex(int row, int column, ContactTreeNode* parent);
 
 private:
-   ContactProxyModel* q_ptr;
+   CategorizedContactModel* q_ptr;
 
 public Q_SLOTS:
    void reloadCategories();
    void slotContactAdded(Person* c);
 };
 
-ContactTreeNode::ContactTreeNode(Person* ct, ContactProxyModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CONTACT),
+ContactTreeNode::ContactTreeNode(Person* ct, CategorizedContactModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CONTACT),
    m_pContact(ct),m_Index(-1),m_pContactMethod(nullptr),m_Type(ContactTreeNode::NodeType::PERSON),m_pParent(nullptr),m_pModel(parent)
 {
    QObject::connect(m_pContact,&Person::changed                      ,[this](            ){ slotChanged                        (   ); });
@@ -108,13 +108,13 @@ ContactTreeNode::ContactTreeNode(Person* ct, ContactProxyModel* parent) : Catego
    QObject::connect(m_pContact,&Person::phoneNumberCountAboutToChange,[this](int n, int o){ slotContactMethodCountAboutToChange(n,o); });
 }
 
-ContactTreeNode::ContactTreeNode(ContactMethod* cm, ContactProxyModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::NUMBER),
+ContactTreeNode::ContactTreeNode(ContactMethod* cm, CategorizedContactModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::NUMBER),
    m_pContactMethod(cm),m_Index(-1),m_pContact(nullptr),m_Type(ContactTreeNode::NodeType::CONTACTMETHOD),m_pParent(nullptr),m_pModel(parent)
 {
    QObject::connect(m_pContactMethod,&ContactMethod::changed,[this](){ slotChanged(); });
 }
 
-ContactTreeNode::ContactTreeNode(const QString& name, ContactProxyModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CONTACT),
+ContactTreeNode::ContactTreeNode(const QString& name, CategorizedContactModel* parent) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CONTACT),
    m_pContactMethod(nullptr),m_Index(-1),m_pContact(nullptr),m_Type(ContactTreeNode::NodeType::CATEGORY),m_Name(name),m_pParent(nullptr),m_pModel(parent)
 {
 }
@@ -123,7 +123,7 @@ ContactTreeNode::~ContactTreeNode()
 {
 }
 
-QModelIndex ContactProxyModelPrivate::getIndex(int row, int column, ContactTreeNode* parent)
+QModelIndex CategorizedContactModelPrivate::getIndex(int row, int column, ContactTreeNode* parent)
 {
    return q_ptr->createIndex(row,column,parent);
 }
@@ -172,16 +172,16 @@ void ContactTreeNode::slotContactMethodCountAboutToChange(int count, int oldCoun
    }
 }
 
-ContactProxyModelPrivate::ContactProxyModelPrivate(ContactProxyModel* parent) : QObject(parent), q_ptr(parent),
+CategorizedContactModelPrivate::CategorizedContactModelPrivate(CategorizedContactModel* parent) : QObject(parent), q_ptr(parent),
 m_lCategoryCounter(),m_Role(Qt::DisplayRole)
 {
 
 }
 
 //
-ContactProxyModel::ContactProxyModel(int role) : QAbstractItemModel(QCoreApplication::instance()),d_ptr(new ContactProxyModelPrivate(this))
+CategorizedContactModel::CategorizedContactModel(int role) : QAbstractItemModel(QCoreApplication::instance()),d_ptr(new CategorizedContactModelPrivate(this))
 {
-   setObjectName("ContactProxyModel");
+   setObjectName("CategorizedContactModel");
    d_ptr->m_Role    = role;
    d_ptr->m_lCategoryCounter.reserve(32);
    d_ptr->m_lMimes << RingMimes::PLAIN_TEXT << RingMimes::PHONENUMBER;
@@ -195,14 +195,14 @@ ContactProxyModel::ContactProxyModel(int role) : QAbstractItemModel(QCoreApplica
 
 }
 
-ContactProxyModel::~ContactProxyModel()
+CategorizedContactModel::~CategorizedContactModel()
 {
    foreach(ContactTreeNode* item,d_ptr->m_lCategoryCounter) {
       delete item;
    }
 }
 
-QHash<int,QByteArray> ContactProxyModel::roleNames() const
+QHash<int,QByteArray> CategorizedContactModel::roleNames() const
 {
    static QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
    static bool initRoles = false;
@@ -221,7 +221,7 @@ QHash<int,QByteArray> ContactProxyModel::roleNames() const
    return roles;
 }
 
-ContactTreeNode* ContactProxyModelPrivate::getContactTopLevelItem(const QString& category)
+ContactTreeNode* CategorizedContactModelPrivate::getContactTopLevelItem(const QString& category)
 {
    if (!m_hCategories[category]) {
       ContactTreeNode* item = new ContactTreeNode(category,q_ptr);
@@ -237,7 +237,7 @@ ContactTreeNode* ContactProxyModelPrivate::getContactTopLevelItem(const QString&
    return item;
 }
 
-void ContactProxyModelPrivate::reloadCategories()
+void CategorizedContactModelPrivate::reloadCategories()
 {
    emit q_ptr->layoutAboutToBeChanged(); //FIXME far from optimal
    q_ptr->beginResetModel();
@@ -256,7 +256,7 @@ void ContactProxyModelPrivate::reloadCategories()
    emit q_ptr->layoutChanged();
 }
 
-void ContactProxyModelPrivate::slotContactAdded(Person* c)
+void CategorizedContactModelPrivate::slotContactAdded(Person* c)
 {
    if (!c) return;
    const QString val = category(c);
@@ -283,7 +283,7 @@ void ContactProxyModelPrivate::slotContactAdded(Person* c)
    //emit layoutChanged();
 }
 
-bool ContactProxyModel::setData( const QModelIndex& index, const QVariant &value, int role)
+bool CategorizedContactModel::setData( const QModelIndex& index, const QVariant &value, int role)
 {
    if (index.isValid() && index.parent().isValid()) {
       ContactTreeNode* modelItem = (ContactTreeNode*)index.internalPointer();
@@ -296,7 +296,7 @@ bool ContactProxyModel::setData( const QModelIndex& index, const QVariant &value
    return false;
 }
 
-QVariant ContactProxyModel::data( const QModelIndex& index, int role) const
+QVariant CategorizedContactModel::data( const QModelIndex& index, int role) const
 {
    if (!index.isValid())
       return QVariant();
@@ -336,7 +336,7 @@ QVariant ContactProxyModel::data( const QModelIndex& index, int role) const
    return QVariant();
 }
 
-QVariant ContactProxyModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant CategorizedContactModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
    Q_UNUSED(section)
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
@@ -344,7 +344,7 @@ QVariant ContactProxyModel::headerData(int section, Qt::Orientation orientation,
    return QVariant();
 }
 
-bool ContactProxyModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
+bool CategorizedContactModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
    Q_UNUSED( action )
    setData(parent,-1,static_cast<int>(Call::Role::DropState));
@@ -386,7 +386,7 @@ bool ContactProxyModel::dropMimeData(const QMimeData *data, Qt::DropAction actio
 }
 
 
-int ContactProxyModel::rowCount( const QModelIndex& parent ) const
+int CategorizedContactModel::rowCount( const QModelIndex& parent ) const
 {
    if (!parent.isValid() || !parent.internalPointer())
       return d_ptr->m_lCategoryCounter.size();
@@ -398,20 +398,20 @@ int ContactProxyModel::rowCount( const QModelIndex& parent ) const
    return 0;
 }
 
-Qt::ItemFlags ContactProxyModel::flags( const QModelIndex& index ) const
+Qt::ItemFlags CategorizedContactModel::flags( const QModelIndex& index ) const
 {
    if (!index.isValid())
       return Qt::NoItemFlags;
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | (index.parent().isValid()?Qt::ItemIsDragEnabled|Qt::ItemIsDropEnabled:Qt::ItemIsEnabled);
 }
 
-int ContactProxyModel::columnCount ( const QModelIndex& parent) const
+int CategorizedContactModel::columnCount ( const QModelIndex& parent) const
 {
    Q_UNUSED(parent)
    return 1;
 }
 
-QModelIndex ContactProxyModel::parent( const QModelIndex& index) const
+QModelIndex CategorizedContactModel::parent( const QModelIndex& index) const
 {
    if (!index.isValid() || !index.internalPointer())
       return QModelIndex();
@@ -424,7 +424,7 @@ QModelIndex ContactProxyModel::parent( const QModelIndex& index) const
    return QModelIndex();
 }
 
-QModelIndex ContactProxyModel::index( int row, int column, const QModelIndex& parent) const
+QModelIndex CategorizedContactModel::index( int row, int column, const QModelIndex& parent) const
 {
    if (!parent.isValid() && row < d_ptr->m_lCategoryCounter.size()) {
       return createIndex(row,column,d_ptr->m_lCategoryCounter[row]);
@@ -438,12 +438,12 @@ QModelIndex ContactProxyModel::index( int row, int column, const QModelIndex& pa
    return QModelIndex();
 }
 
-QStringList ContactProxyModel::mimeTypes() const
+QStringList CategorizedContactModel::mimeTypes() const
 {
    return d_ptr->m_lMimes;
 }
 
-QMimeData* ContactProxyModel::mimeData(const QModelIndexList &indexes) const
+QMimeData* CategorizedContactModel::mimeData(const QModelIndexList &indexes) const
 {
    QMimeData *mimeData = new QMimeData();
    foreach (const QModelIndex &index, indexes) {
@@ -481,7 +481,7 @@ QMimeData* ContactProxyModel::mimeData(const QModelIndexList &indexes) const
 }
 
 ///Return valid payload types
-int ContactProxyModel::acceptedPayloadTypes()
+int CategorizedContactModel::acceptedPayloadTypes()
 {
    return CallModel::DropPayloadType::CALL;
 }
@@ -495,7 +495,7 @@ int ContactProxyModel::acceptedPayloadTypes()
  ****************************************************************************/
 
 
-QString ContactProxyModelPrivate::category(const Person* ct) const {
+QString CategorizedContactModelPrivate::category(const Person* ct) const {
    if (!ct)
       return QString();
 
@@ -507,7 +507,7 @@ QString ContactProxyModelPrivate::category(const Person* ct) const {
    return cat;
 }
 
-void ContactProxyModel::setRole(int role)
+void CategorizedContactModel::setRole(int role)
 {
    if (role != d_ptr->m_Role) {
       d_ptr->m_Role = role;
@@ -515,4 +515,4 @@ void ContactProxyModel::setRole(int role)
    }
 }
 
-#include <contactproxymodel.moc>
+#include <categorizedcontactmodel.moc>
diff --git a/src/contactproxymodel.h b/src/categorizedcontactmodel.h
similarity index 91%
rename from src/contactproxymodel.h
rename to src/categorizedcontactmodel.h
index 7926c40afb160210c5f7d2cbcc0bec3eea6542c0..4ed5680ef473add7345f1b5bbe1828e3bc2b9733 100644
--- a/src/contactproxymodel.h
+++ b/src/categorizedcontactmodel.h
@@ -29,9 +29,9 @@ class PersonModel;
 class ContactTreeNode;
 class TopLevelItem;
 class ContactTreeBinder;
-class ContactProxyModelPrivate;
+class CategorizedContactModelPrivate;
 
-class LIB_EXPORT ContactProxyModel :  public QAbstractItemModel
+class LIB_EXPORT CategorizedContactModel :  public QAbstractItemModel
 {
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
@@ -41,8 +41,8 @@ public:
    friend class PersonModel;
    friend class ContactTreeNode;
    friend class ContactTreeBinder;
-   explicit ContactProxyModel(int role = Qt::DisplayRole);
-   virtual ~ContactProxyModel();
+   explicit CategorizedContactModel(int role = Qt::DisplayRole);
+   virtual ~CategorizedContactModel();
 
    //Setters
    void setRole(int role);
@@ -65,8 +65,8 @@ public:
    static int acceptedPayloadTypes();
 
 private:
-   QScopedPointer<ContactProxyModelPrivate> d_ptr;
-   Q_DECLARE_PRIVATE(ContactProxyModel)
+   QScopedPointer<CategorizedContactModelPrivate> d_ptr;
+   Q_DECLARE_PRIVATE(CategorizedContactModel)
 };
 
 #endif
diff --git a/src/historymodel.cpp b/src/categorizedhistorymodel.cpp
similarity index 81%
rename from src/historymodel.cpp
rename to src/categorizedhistorymodel.cpp
index 090414ec1afa69debe2e2c9b5f2172764469681e..41a796e191a5a529b97d9aed1e3c2ea670bcf313 100644
--- a/src/historymodel.cpp
+++ b/src/categorizedhistorymodel.cpp
@@ -15,7 +15,7 @@
  *   You should have received a copy of the GNU General Public License      *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  ***************************************************************************/
-#include "historymodel.h"
+#include "categorizedhistorymodel.h"
 
 //C include
 #include <time.h>
@@ -46,11 +46,11 @@
 
 class HistoryTopLevelItem;
 
-class HistoryModelPrivate : public QObject
+class CategorizedHistoryModelPrivate : public QObject
 {
    Q_OBJECT
 public:
-   HistoryModelPrivate(HistoryModel* parent);
+   CategorizedHistoryModelPrivate(CategorizedHistoryModel* parent);
 
    //Model
    class HistoryItem : public CategorizedCompositeNode {
@@ -80,7 +80,7 @@ public:
    QStringList                  m_lMimes           ;
 
 private:
-   HistoryModel* q_ptr;
+   CategorizedHistoryModel* q_ptr;
 
 public Q_SLOTS:
    void add(Call* call);
@@ -89,14 +89,14 @@ public Q_SLOTS:
 };
 
 class HistoryTopLevelItem : public CategorizedCompositeNode,public QObject {
-   friend class HistoryModel;
-   friend class HistoryModelPrivate;
+   friend class CategorizedHistoryModel;
+   friend class CategorizedHistoryModelPrivate;
 public:
    virtual QObject* getSelf() const;
    virtual ~HistoryTopLevelItem();
    int m_Index;
    int m_AbsoluteIndex;
-   QVector<HistoryModelPrivate::HistoryItem*> m_lChildren;
+   QVector<CategorizedHistoryModelPrivate::HistoryItem*> m_lChildren;
 private:
    explicit HistoryTopLevelItem(const QString& name, int index);
    QString m_NameStr;
@@ -107,18 +107,18 @@ class HistoryItemNode : public QObject //TODO remove this once Qt4 support is dr
 {
    Q_OBJECT
 public:
-   HistoryItemNode(HistoryModel* m, Call* c, HistoryModelPrivate::HistoryItem* backend);
+   HistoryItemNode(CategorizedHistoryModel* m, Call* c, CategorizedHistoryModelPrivate::HistoryItem* backend);
    Call* m_pCall;
 private:
-   HistoryModelPrivate::HistoryItem* m_pBackend;
-   HistoryModel* m_pModel;
+   CategorizedHistoryModelPrivate::HistoryItem* m_pBackend;
+   CategorizedHistoryModel* m_pModel;
 private Q_SLOTS:
    void slotNumberChanged();
 Q_SIGNALS:
    void changed(const QModelIndex& idx);
 };
 
-HistoryItemNode::HistoryItemNode(HistoryModel* m, Call* c, HistoryModelPrivate::HistoryItem* backend) :
+HistoryItemNode::HistoryItemNode(CategorizedHistoryModel* m, Call* c, CategorizedHistoryModelPrivate::HistoryItem* backend) :
 m_pCall(c),m_pBackend(backend),m_pModel(m){
    connect(c,SIGNAL(changed()),this,SLOT(slotNumberChanged()));
 }
@@ -128,8 +128,8 @@ void HistoryItemNode::slotNumberChanged()
    emit changed(m_pModel->index(m_pBackend->m_Index,0,m_pModel->index(m_pBackend->m_pParent->m_AbsoluteIndex,0)));
 }
 
-HistoryModel* HistoryModel::m_spInstance    = nullptr;
-CallMap       HistoryModelPrivate::m_sHistoryCalls          ;
+CategorizedHistoryModel* CategorizedHistoryModel::m_spInstance    = nullptr;
+CallMap       CategorizedHistoryModelPrivate::m_sHistoryCalls          ;
 
 HistoryTopLevelItem::HistoryTopLevelItem(const QString& name, int index) : 
    CategorizedCompositeNode(CategorizedCompositeNode::Type::TOP_LEVEL),QObject(nullptr),m_Index(index),m_NameStr(name),
@@ -137,11 +137,11 @@ HistoryTopLevelItem::HistoryTopLevelItem(const QString& name, int index) :
 {}
 
 HistoryTopLevelItem::~HistoryTopLevelItem() {
-   const int idx = HistoryModel::m_spInstance->d_ptr->m_lCategoryCounter.indexOf(this);
+   const int idx = CategorizedHistoryModel::m_spInstance->d_ptr->m_lCategoryCounter.indexOf(this);
    if (idx != -1)
-      HistoryModel::m_spInstance->d_ptr->m_lCategoryCounter.remove(idx);
+      CategorizedHistoryModel::m_spInstance->d_ptr->m_lCategoryCounter.remove(idx);
    while(m_lChildren.size()) {
-      HistoryModelPrivate::HistoryItem* item = m_lChildren[0];
+      CategorizedHistoryModelPrivate::HistoryItem* item = m_lChildren[0];
       m_lChildren.remove(0);
       delete item;
    }
@@ -152,24 +152,24 @@ QObject* HistoryTopLevelItem::getSelf() const
    return const_cast<HistoryTopLevelItem*>(this);
 }
 
-HistoryModelPrivate::HistoryItem::HistoryItem(Call* call) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CALL),m_pCall(call),
+CategorizedHistoryModelPrivate::HistoryItem::HistoryItem(Call* call) : CategorizedCompositeNode(CategorizedCompositeNode::Type::CALL),m_pCall(call),
 m_Index(0),m_pParent(nullptr),m_pNode(nullptr)
 {
    
 }
 
-HistoryModelPrivate::HistoryItem::~HistoryItem()
+CategorizedHistoryModelPrivate::HistoryItem::~HistoryItem()
 {
    delete m_pNode;
 }
 
 
-QObject* HistoryModelPrivate::HistoryItem::getSelf() const
+QObject* CategorizedHistoryModelPrivate::HistoryItem::getSelf() const
 {
    return const_cast<Call*>(m_pCall);
 }
 
-Call* HistoryModelPrivate::HistoryItem::call() const
+Call* CategorizedHistoryModelPrivate::HistoryItem::call() const
 {
    return m_pCall;
 }
@@ -181,21 +181,21 @@ Call* HistoryModelPrivate::HistoryItem::call() const
  *                                                                           *
  ****************************************************************************/
 
-HistoryModelPrivate::HistoryModelPrivate(HistoryModel* parent) : QObject(parent), q_ptr(parent),
+CategorizedHistoryModelPrivate::CategorizedHistoryModelPrivate(CategorizedHistoryModel* parent) : QObject(parent), q_ptr(parent),
 m_Role(static_cast<int>(Call::Role::FuzzyDate))
 {
 }
 
 ///Constructor
-HistoryModel::HistoryModel():QAbstractItemModel(QCoreApplication::instance()),CollectionManagerInterface<Call>(this),
-d_ptr(new HistoryModelPrivate(this))
+CategorizedHistoryModel::CategorizedHistoryModel():QAbstractItemModel(QCoreApplication::instance()),CollectionManagerInterface<Call>(this),
+d_ptr(new CategorizedHistoryModelPrivate(this))
 {
    m_spInstance  = this;
    d_ptr->m_lMimes << RingMimes::PLAIN_TEXT << RingMimes::PHONENUMBER << RingMimes::HISTORYID;
 } //initHistory
 
 ///Destructor
-HistoryModel::~HistoryModel()
+CategorizedHistoryModel::~CategorizedHistoryModel()
 {
    for (int i=0; i<d_ptr->m_lCategoryCounter.size();i++) {
       delete d_ptr->m_lCategoryCounter[i];
@@ -209,7 +209,7 @@ HistoryModel::~HistoryModel()
    m_spInstance = nullptr;
 }
 
-QHash<int,QByteArray> HistoryModel::roleNames() const
+QHash<int,QByteArray> CategorizedHistoryModel::roleNames() const
 {
    static QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
    static bool initRoles = false;
@@ -244,10 +244,10 @@ QHash<int,QByteArray> HistoryModel::roleNames() const
 }
 
 ///Singleton
-HistoryModel* HistoryModel::instance()
+CategorizedHistoryModel* CategorizedHistoryModel::instance()
 {
    if (!m_spInstance)
-      m_spInstance = new HistoryModel();
+      m_spInstance = new CategorizedHistoryModel();
    return m_spInstance;
 }
 
@@ -258,7 +258,7 @@ HistoryModel* HistoryModel::instance()
  *                                                                           *
  ****************************************************************************/
 ///Get the top level item based on a call
-HistoryTopLevelItem* HistoryModelPrivate::getCategory(const Call* call)
+HistoryTopLevelItem* CategorizedHistoryModelPrivate::getCategory(const Call* call)
 {
    HistoryTopLevelItem* category = nullptr;
    static QString name;
@@ -276,25 +276,25 @@ HistoryTopLevelItem* HistoryModelPrivate::getCategory(const Call* call)
       category = new HistoryTopLevelItem(name,index);
       category->modelRow = m_lCategoryCounter.size();
       //emit layoutAboutToBeChanged(); //Not necessary
-      HistoryModel::instance()->beginInsertRows(QModelIndex(),m_lCategoryCounter.size(),m_lCategoryCounter.size());
+      CategorizedHistoryModel::instance()->beginInsertRows(QModelIndex(),m_lCategoryCounter.size(),m_lCategoryCounter.size());
       category->m_AbsoluteIndex = m_lCategoryCounter.size();
       m_lCategoryCounter << category;
       m_hCategories    [index] = category;
       m_hCategoryByName[name ] = category;
-      HistoryModel::instance()->endInsertRows();
+      CategorizedHistoryModel::instance()->endInsertRows();
       //emit layoutChanged();
    }
    return category;
 }
 
 
-const CallMap HistoryModel::getHistoryCalls() const
+const CallMap CategorizedHistoryModel::getHistoryCalls() const
 {
    return d_ptr->m_sHistoryCalls;
 }
 
 ///Add to history
-void HistoryModelPrivate::add(Call* call)
+void CategorizedHistoryModelPrivate::add(Call* call)
 {
    if (!call || call->lifeCycleState() != Call::LifeCycleState::FINISHED || !call->startTimeStamp()) {
       return;
@@ -310,7 +310,7 @@ void HistoryModelPrivate::add(Call* call)
    HistoryTopLevelItem* tl = getCategory(call);
    const QModelIndex& parentIdx = q_ptr->index(tl->modelRow,0);
    q_ptr->beginInsertRows(parentIdx,tl->m_lChildren.size(),tl->m_lChildren.size());
-   HistoryModelPrivate::HistoryItem* item = new HistoryModelPrivate::HistoryItem(call);
+   CategorizedHistoryModelPrivate::HistoryItem* item = new CategorizedHistoryModelPrivate::HistoryItem(call);
    item->m_pParent = tl;
    item->m_pNode = new HistoryItemNode(q_ptr,call,item);
    connect(item->m_pNode,SIGNAL(changed(QModelIndex)),this,SLOT(slotChanged(QModelIndex)));
@@ -339,26 +339,26 @@ void HistoryModelPrivate::add(Call* call)
 }
 
 ///Set if the history has a limit
-void HistoryModel::setHistoryLimited(bool isLimited)
+void CategorizedHistoryModel::setHistoryLimited(bool isLimited)
 {
    if (!isLimited)
       DBus::ConfigurationManager::instance().setHistoryLimit(0);
 }
 
 ///Set the number of days before history items are discarded
-void HistoryModel::setHistoryLimit(int numberOfDays)
+void CategorizedHistoryModel::setHistoryLimit(int numberOfDays)
 {
    DBus::ConfigurationManager::instance().setHistoryLimit(numberOfDays);
 }
 
 ///Is history items are being deleted after "historyLimit()" days
-bool HistoryModel::isHistoryLimited() const
+bool CategorizedHistoryModel::isHistoryLimited() const
 {
    return DBus::ConfigurationManager::instance().getHistoryLimit() != 0;
 }
 
 ///Number of days before items are discarded (0 = never)
-int HistoryModel::historyLimit() const
+int CategorizedHistoryModel::historyLimit() const
 {
    return DBus::ConfigurationManager::instance().getHistoryLimit();
 }
@@ -370,7 +370,7 @@ int HistoryModel::historyLimit() const
  *                                                                           *
  ****************************************************************************/
 
-void HistoryModelPrivate::reloadCategories()
+void CategorizedHistoryModelPrivate::reloadCategories()
 {
    q_ptr->beginResetModel();
    m_hCategories.clear();
@@ -398,12 +398,12 @@ void HistoryModelPrivate::reloadCategories()
    emit q_ptr->dataChanged(q_ptr->index(0,0),q_ptr->index(q_ptr->rowCount()-1,0));
 }
 
-void HistoryModelPrivate::slotChanged(const QModelIndex& idx)
+void CategorizedHistoryModelPrivate::slotChanged(const QModelIndex& idx)
 {
    emit q_ptr->dataChanged(idx,idx);
 }
 
-bool HistoryModel::setData( const QModelIndex& idx, const QVariant &value, int role)
+bool CategorizedHistoryModel::setData( const QModelIndex& idx, const QVariant &value, int role)
 {
    if (idx.isValid() && idx.parent().isValid()) {
       CategorizedCompositeNode* modelItem = (CategorizedCompositeNode*)idx.internalPointer();
@@ -415,7 +415,7 @@ bool HistoryModel::setData( const QModelIndex& idx, const QVariant &value, int r
    return false;
 }
 
-QVariant HistoryModel::data( const QModelIndex& idx, int role) const
+QVariant CategorizedHistoryModel::data( const QModelIndex& idx, int role) const
 {
    if (!idx.isValid())
       return QVariant();
@@ -452,7 +452,7 @@ QVariant HistoryModel::data( const QModelIndex& idx, int role) const
    return QVariant();
 }
 
-QVariant HistoryModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant CategorizedHistoryModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
    Q_UNUSED(section)
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
@@ -462,7 +462,7 @@ QVariant HistoryModel::headerData(int section, Qt::Orientation orientation, int
    return QVariant();
 }
 
-int HistoryModel::rowCount( const QModelIndex& parentIdx ) const
+int CategorizedHistoryModel::rowCount( const QModelIndex& parentIdx ) const
 {
    if ((!parentIdx.isValid()) || (!parentIdx.internalPointer())) {
       return d_ptr->m_lCategoryCounter.size();
@@ -482,20 +482,20 @@ int HistoryModel::rowCount( const QModelIndex& parentIdx ) const
    }
 }
 
-Qt::ItemFlags HistoryModel::flags( const QModelIndex& idx ) const
+Qt::ItemFlags CategorizedHistoryModel::flags( const QModelIndex& idx ) const
 {
    if (!idx.isValid())
       return Qt::NoItemFlags;
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | (idx.parent().isValid()?Qt::ItemIsDragEnabled|Qt::ItemIsDropEnabled:Qt::ItemIsEnabled);
 }
 
-int HistoryModel::columnCount ( const QModelIndex& parentIdx) const
+int CategorizedHistoryModel::columnCount ( const QModelIndex& parentIdx) const
 {
    Q_UNUSED(parentIdx)
    return 1;
 }
 
-QModelIndex HistoryModel::parent( const QModelIndex& idx) const
+QModelIndex CategorizedHistoryModel::parent( const QModelIndex& idx) const
 {
    if (!idx.isValid() || !idx.internalPointer()) {
       return QModelIndex();
@@ -506,12 +506,12 @@ QModelIndex HistoryModel::parent( const QModelIndex& idx) const
       //TODO this is called way to often to use getCategory, make sure getSelf return the node and cache this
       HistoryTopLevelItem* tli = d_ptr->getCategory(call);
       if (tli)
-         return HistoryModel::index(tli->modelRow,0);
+         return CategorizedHistoryModel::index(tli->modelRow,0);
    }
    return QModelIndex();
 }
 
-QModelIndex HistoryModel::index( int row, int column, const QModelIndex& parentIdx) const
+QModelIndex CategorizedHistoryModel::index( int row, int column, const QModelIndex& parentIdx) const
 {
    if (!parentIdx.isValid()) {
       if (row >= 0 && d_ptr->m_lCategoryCounter.size() > row) {
@@ -536,7 +536,7 @@ QModelIndex HistoryModel::index( int row, int column, const QModelIndex& parentI
 }
 
 ///Called when dynamically adding calls, otherwise the proxy filter will segfault
-bool HistoryModel::insertRows( int row, int count, const QModelIndex & parent)
+bool CategorizedHistoryModel::insertRows( int row, int count, const QModelIndex & parent)
 {
    if (parent.isValid()) {
       beginInsertRows(parent,row,row+count-1);
@@ -546,12 +546,12 @@ bool HistoryModel::insertRows( int row, int count, const QModelIndex & parent)
    return false;
 }
 
-QStringList HistoryModel::mimeTypes() const
+QStringList CategorizedHistoryModel::mimeTypes() const
 {
    return d_ptr->m_lMimes;
 }
 
-QMimeData* HistoryModel::mimeData(const QModelIndexList &indexes) const
+QMimeData* CategorizedHistoryModel::mimeData(const QModelIndexList &indexes) const
 {
    QMimeData *mimeData2 = new QMimeData();
    foreach (const QModelIndex &idx, indexes) {
@@ -569,7 +569,7 @@ QMimeData* HistoryModel::mimeData(const QModelIndexList &indexes) const
    return mimeData2;
 }
 
-bool HistoryModel::dropMimeData(const QMimeData *mime, Qt::DropAction action, int row, int column, const QModelIndex &parentIdx)
+bool CategorizedHistoryModel::dropMimeData(const QMimeData *mime, Qt::DropAction action, int row, int column, const QModelIndex &parentIdx)
 {
    Q_UNUSED(row)
    Q_UNUSED(column)
@@ -595,13 +595,13 @@ bool HistoryModel::dropMimeData(const QMimeData *mime, Qt::DropAction action, in
    return false;
 }
 
-void HistoryModel::collectionAddedCallback(CollectionInterface* backend)
+void CategorizedHistoryModel::collectionAddedCallback(CollectionInterface* backend)
 {
    Q_UNUSED(backend)
 }
 
 ///Call all collections that support clearing
-bool HistoryModel::clearAllCollections() const
+bool CategorizedHistoryModel::clearAllCollections() const
 {
    foreach (CollectionInterface* backend, collections()) { //TODO use the filter API
       if (backend->supportedFeatures() & CollectionInterface::CLEAR) {
@@ -611,25 +611,25 @@ bool HistoryModel::clearAllCollections() const
    return true;
 }
 
-bool HistoryModel::addItemCallback(const Call* item)
+bool CategorizedHistoryModel::addItemCallback(const Call* item)
 {
    d_ptr->add(const_cast<Call*>(item));
    return true;
 }
 
-bool HistoryModel::removeItemCallback(const Call* item)
+bool CategorizedHistoryModel::removeItemCallback(const Call* item)
 {
    Q_UNUSED(item)
    return false;
 }
 
 ///Return valid payload types
-int HistoryModel::acceptedPayloadTypes() const
+int CategorizedHistoryModel::acceptedPayloadTypes() const
 {
    return CallModel::DropPayloadType::CALL;
 }
 
-void HistoryModel::setCategoryRole(int role)
+void CategorizedHistoryModel::setCategoryRole(int role)
 {
    if (d_ptr->m_Role != role) {
       d_ptr->m_Role = role;
@@ -637,4 +637,4 @@ void HistoryModel::setCategoryRole(int role)
    }
 }
 
-#include <historymodel.moc>
+#include <categorizedhistorymodel.moc>
diff --git a/src/historymodel.h b/src/categorizedhistorymodel.h
similarity index 89%
rename from src/historymodel.h
rename to src/categorizedhistorymodel.h
index 3ab9c2e09a50a3a587007a51cc798194eba1f8db..c5f5f59d7e2bb01d61e2275378862c1cb297ceb4 100644
--- a/src/historymodel.h
+++ b/src/categorizedhistorymodel.h
@@ -15,8 +15,8 @@
  *   You should have received a copy of the GNU General Public License      *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  ***************************************************************************/
-#ifndef HISTORY_MODEL_H
-#define HISTORY_MODEL_H
+#ifndef CATEGORIZED_HISTORY_MODEL_H
+#define CATEGORIZED_HISTORY_MODEL_H
 //Base
 #include "typedefs.h"
 #include <QtCore/QObject>
@@ -35,10 +35,10 @@ typedef QList<Call*>       CallList;
 
 class HistoryItemNode;
 class AbstractHistoryBackend;
-class HistoryModelPrivate;
+class CategorizedHistoryModelPrivate;
 //TODO split ASAP
-///HistoryModel: History call manager
-class LIB_EXPORT HistoryModel : public QAbstractItemModel, public CollectionManagerInterface<Call> {
+///CategorizedHistoryModel: History call manager
+class LIB_EXPORT CategorizedHistoryModel : public QAbstractItemModel, public CollectionManagerInterface<Call> {
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
    Q_OBJECT
@@ -51,7 +51,7 @@ public:
    Q_PROPERTY(bool hasCollections   READ hasCollections  )
 
    //Singleton
-   static HistoryModel* instance();
+   static CategorizedHistoryModel* instance();
 
    //Getters
    int  acceptedPayloadTypes       () const;
@@ -85,13 +85,13 @@ public:
 
 private:
    //Constructor
-   explicit HistoryModel();
-   ~HistoryModel();
-   QScopedPointer<HistoryModelPrivate> d_ptr;
-   Q_DECLARE_PRIVATE(HistoryModel)
+   explicit CategorizedHistoryModel();
+   ~CategorizedHistoryModel();
+   QScopedPointer<CategorizedHistoryModelPrivate> d_ptr;
+   Q_DECLARE_PRIVATE(CategorizedHistoryModel)
 
    //Static attributes
-   static HistoryModel* m_spInstance;
+   static CategorizedHistoryModel* m_spInstance;
 
    //Backend interface
    virtual void collectionAddedCallback(CollectionInterface* collection) override;
diff --git a/src/collectioninterface.h b/src/collectioninterface.h
index ba5391e1a56de3bff475b7a7e769870c636ecd81..82e61f06efa3e21c020f8e2bccf8d264bdce5a33 100644
--- a/src/collectioninterface.h
+++ b/src/collectioninterface.h
@@ -212,7 +212,7 @@ public:
     * Return an object that has been associated with this collection type
     * 
     * It can be set using registerConfigarator() available in every collection
-    * manager objects such as PersonModel, HistoryModel and others.
+    * manager objects such as PersonModel, CategorizedHistoryModel and others.
     */
    CollectionConfigurationInterface* configurator() const;
 
diff --git a/src/delegates/presenceserializationdelegate.h b/src/delegates/presenceserializationdelegate.h
index e6ec4b96528da4083902a171cdbe2f58946bdf58..2e78d335b48acb61c15b09c49a0f36230943da35 100644
--- a/src/delegates/presenceserializationdelegate.h
+++ b/src/delegates/presenceserializationdelegate.h
@@ -20,7 +20,7 @@
 
 #include <typedefs.h>
 
-class AbstractBookmarkModel;
+class AbstractCategorizedBookmarkModel;
 class CollectionInterface;
 
 class LIB_EXPORT PresenceSerializationDelegate {