diff -Nru telepathy-logger-qt-0.6.0/.reviewboardrc telepathy-logger-qt-0.99.0+git20130621+r247/.reviewboardrc
--- telepathy-logger-qt-0.6.0/.reviewboardrc	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/.reviewboardrc	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,2 @@
+REVIEWBOARD_URL = 'https://git.reviewboard.kde.org'
+REPOSITORY = 'git://anongit.kde.org/telepathy-logger-qt'
diff -Nru telepathy-logger-qt-0.6.0/CMakeLists.txt telepathy-logger-qt-0.99.0+git20130621+r247/CMakeLists.txt
--- telepathy-logger-qt-0.6.0/CMakeLists.txt	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/CMakeLists.txt	2013-06-21 15:44:20.000000000 +0000
@@ -1,6 +1,6 @@
 project(TelepathyLoggerQt4)
 
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 2.8.6 FATAL_ERROR)
 
 # CMake policies are used for backwards compatibilty. Setting a policy to a behavior lets newer
 # CMake versions where some behaviors changed behave in a way or another. In our specific case,
@@ -39,8 +39,8 @@
 #   make the release, tag it
 #   set nano_version to 1
 set(TP_LOGGER_QT4_MAJOR_VERSION 0)
-set(TP_LOGGER_QT4_MINOR_VERSION 5)
-set(TP_LOGGER_QT4_MICRO_VERSION 60)
+set(TP_LOGGER_QT4_MINOR_VERSION 9)
+set(TP_LOGGER_QT4_MICRO_VERSION 0)
 set(TP_LOGGER_QT4_NANO_VERSION  0)
 
 # This value contains the library's SOVERSION. This value is to be increased everytime an API/ABI break
@@ -78,6 +78,7 @@
 
 # This file contains all the needed initialization macros
 include(TelepathyDefaults)
+include(FeatureSummary)
 
 # TelepathyLoggerQt4 specific defines needed to trigger deprecation warnings
 if (CXX_DEPRECATED_DECLARATIONS)
@@ -88,7 +89,6 @@
 include(TpQtMacros)
 
 include(Doxygen)
-include(MacroLogFeature)
 include(MacroWriteBasicCMakeVersionFile)
 
 # external dependencies
@@ -96,9 +96,18 @@
 # Required dependencies
 # Find qt4 version >= 4.5
 set (QT_MIN_VERSION "4.5.0")
-find_package(Qt REQUIRED)
+find_package(Qt ${QT_MIN_VERSION} REQUIRED)
+set_package_properties(Qt PROPERTIES
+                       DESCRIPTION "Qt 4 Framework"
+                       URL "http://www.qt-project.org"
+                       TYPE REQUIRED)
+
 set (TELEPATHYQT4_MIN_VERSION "0.9.1")
 find_package(TelepathyQt4 ${TELEPATHYQT4_MIN_VERSION} REQUIRED)
+set_package_properties(TelepathyQt4 PROPERTIES
+                       DESCRIPTION "Qt bindings for Telepathy"
+                       URL "http://telepathy.freedesktop.org"
+                       TYPE REQUIRED)
 
 #add_definitions(-DQT_NO_CAST_FROM_ASCII)
 
@@ -115,6 +124,10 @@
 else(${PYTHON_SHORT_VERSION} VERSION_GREATER ${REQUIRED_PY} OR ${PYTHON_SHORT_VERSION} VERSION_EQUAL ${REQUIRED_PY})
     message(SEND_ERROR "Python >= ${REQUIRED_PY} is required")
 endif(${PYTHON_SHORT_VERSION} VERSION_GREATER ${REQUIRED_PY} OR ${PYTHON_SHORT_VERSION} VERSION_EQUAL ${REQUIRED_PY})
+set_package_properties(PythonLibrary PROPERTIES
+                       DESCRIPTION "Python Library"
+                       URL "http://www.python.org"
+                       TYPE REQUIRED)
 
 # Check for Qt4 Glib support
 include(CheckCXXSourceCompiles)
@@ -132,24 +145,64 @@
 return 0;
 }"
 QT4_GLIB_SUPPORT)
-macro_log_feature(QT4_GLIB_SUPPORT "Qt4 Glib Support"
-                  "QtCore library using Glib's main event loop"
-                  "http://qt.nokia.com/" FALSE ""
-                  "Needed, together with Telepathy-Glib, to build most of the unit tests")
+if (QT4_GLIB_SUPPORT)
+    message(STATUS "Qt was compiled with GLib support enabled")
+else ()
+    message(FATAL_ERROR "Qt was not compiled with GLib support enabled")
+endif()
 
 find_package(GLIB2 REQUIRED)
+set_package_properties(GLIB2 PROPERTIES
+                       DESCRIPTION "A library containing many useful C routines"
+                       URL "http://developer.gnome.org/glib/"
+                       TYPE REQUIRED)
+
 find_package(GObject REQUIRED)
+set_package_properties(GObject PROPERTIES
+                       DESCRIPTION "GLib Object System"
+                       URL "http://developer.gnome.org/glib/"
+                       TYPE REQUIRED)
+
 find_package(DBus REQUIRED)
+set_package_properties(DBus PROPERTIES
+                       DESCRIPTION "Inter-process communication system"
+                       URL "http://dbus.freedesktop.org"
+                       TYPE REQUIRED)
+
 find_package(DBusGLib REQUIRED)
+set_package_properties(DBusGLib PROPERTIES
+                       DESCRIPTION "GLib bindings for DBus"
+                       URL "http://dbus.freedesktop.org"
+                       TYPE REQUIRED)
+
 find_package(LibXml2 REQUIRED)
+set_package_properties(LibXml2 PROPERTIES
+                       DESCRIPTION "XML C parser and toolkit"
+                       URL "http://www.xmlsoft.org"
+                       TYPE REQUIRED)
+
 find_package(QtGLib REQUIRED)
-find_package(TelepathyLogger REQUIRED)
+set_package_properties(QtGLib PROPERTIES
+                       DESCRIPTION "Qt bindings for GLib, part of QtGStreamer"
+                       URL "http://www.qt-project.org"
+                       TYPE REQUIRED)
+
+set(TELEPATHY_LOGGER_MIN_VERSION 0.8.0)
+find_package(TelepathyLogger ${TELEPATHY_LOGGER_MIN_VERSION} REQUIRED)
+set_package_properties(TelepathyLogger PROPERTIES
+                       DESCRIPTION "Daemon for logging Telepathy conversations"
+                       URL "http://telepathy.freedesktop.org"
+                       TYPE REQUIRED)
 
 #find_program(GLIB_GENMARSHAL glib-genmarshal)
 
 # Find telepathy-glib
 set(TELEPATHY_GLIB_MIN_VERSION 0.16.0)
-find_package(TelepathyGlib REQUIRED)
+find_package(TelepathyGlib ${TELEPATHY_GLIB_MIN_VERSION} REQUIRED)
+set_package_properties(TelepathyGlib PROPERTIES
+                       DESCRIPTION "Glib bindings for Telepathy"
+                       URL "http://telepathy.freedesktop.org"
+                       TYPE REQUIRED)
 
 # Activate debug symbols generation
 #set(CMAKE_CXX_FLAGS "-g -Wall")
@@ -201,9 +254,6 @@
 add_custom_target(uninstall
     "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 
-# Display the feature log
-macro_display_feature_log()
-
 add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/FIXME.out
                    COMMAND egrep
                    ARGS -A 5 '[F]IXME|[T]ODO|[X]XX' ${CMAKE_SOURCE_DIR}/TelepathyLoggerQt4/*.[ch]*
@@ -211,3 +261,5 @@
 add_custom_target(check-local DEPENDS ${CMAKE_BINARY_DIR}/FIXME.out)
 
 include(TelepathyDist)
+
+feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/CMakeLists.txt telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/CMakeLists.txt
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/CMakeLists.txt	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/CMakeLists.txt	2013-06-21 15:44:20.000000000 +0000
@@ -1,10 +1,11 @@
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/_gen")
 
-set(TelepathyLoggerQt4_CODEGEN_HEADERS 
+set(TelepathyLoggerQt4_CODEGEN_HEADERS
     call-event.h
     entity.h
     event.h
     log-manager.h
+    log-walker.h
     text-event.h
     types.h)
 
@@ -12,12 +13,14 @@
     -Itelepathy-logger/call-event.h
     -Itelepathy-logger/entity.h
     -Itelepathy-logger/log-manager.h
+    -Itelepathy-logger/log-walker.h
     -Itelepathy-logger/event.h
     -Itelepathy-logger/text-event.h
     -ITelepathyLoggerQt4/CallEvent
     -ITelepathyLoggerQt4/Entity
     -ITelepathyLoggerQt4/Event
     -ITelepathyLoggerQt4/LogManager
+    -ITelepathyLoggerQt4/LogWalker
     -ITelepathyLoggerQt4/TextEvent
     -ITelepathyLoggerQt4/Types
     -IQGlib/Quark)
@@ -40,12 +43,14 @@
     entity.cpp
     event.cpp
     log-manager.cpp
+    log-walker.cpp
     pending-dates.cpp
     pending-entities.cpp
     pending-events.cpp
     pending-clear.cpp
     pending-operation.cpp
     pending-search.cpp
+    pending-log-walker-operation.cpp
     search-hit.cpp
     text-event.cpp
     utils.cpp
@@ -60,6 +65,7 @@
     Global
     Init
     LogManager
+    LogWalker
     PendingDates
     PendingEntities
     PendingEvents
@@ -70,10 +76,11 @@
     Types
     call-event.h
     entity.h
-    event.h 
+    event.h
     global.h
     init.h
     log-manager.h
+    log-walker.h
     pending-dates.h
     pending-entities.h
     pending-events.h
@@ -91,7 +98,9 @@
     pending-events.h
     pending-clear.h
     pending-operation.h
-    pending-search.h)
+    pending-search.h
+    pending-log-walker-operation.h
+    )
 
 # Generated headers which will be installed and exported
 set(telepathy_logger_qt4_gen_HEADERS
@@ -180,9 +189,6 @@
     ${GOBJECT_LIBRARIES}
     -lgio-2.0
     ${QT_QTDBUS_LIBRARY}
-    ${DBUS_LIBRARIES}
-    ${LIBXML2_LIBRARIES}
-    ${DBUS_GLIB_LIBRARIES}
     ${TELEPATHY_GLIB_LIBRARIES}
     ${TELEPATHY_LOGGER_LIBRARIES}
     ${TELEPATHY_QT4_LIBRARIES}
@@ -224,12 +230,6 @@
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/TelepathyLoggerQt4.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig COMPONENT headers)
 
 # cmake file
-# Find out the correct installation directory
-if (USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR)
-   set(_TelepathyLoggerQt4Config_INSTALL_DIR ${LIB_INSTALL_DIR}/cmake/TelepathyLoggerQt4)
-else (USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR)
-   set(_TelepathyLoggerQt4Config_INSTALL_DIR ${LIB_INSTALL_DIR}/TelepathyLoggerQt4/cmake)
-endif (USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR)
 
 include(TpQtMacros)
 # CMake Version and config files
@@ -258,10 +258,10 @@
 
 
 install(EXPORT TelepathyLoggerQt4Targets
-        DESTINATION ${_TelepathyLoggerQt4Config_INSTALL_DIR}
+        DESTINATION ${LIB_INSTALL_DIR}/cmake/TelepathyLoggerQt4
         COMPONENT headers)
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/TelepathyLoggerQt4ConfigVersion.cmake
               ${CMAKE_CURRENT_BINARY_DIR}/TelepathyLoggerQt4Config.cmake
-        DESTINATION ${_TelepathyLoggerQt4Config_INSTALL_DIR}
+        DESTINATION ${LIB_INSTALL_DIR}/cmake/TelepathyLoggerQt4
         COMPONENT headers)
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/LogWalker telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/LogWalker
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/LogWalker	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/LogWalker	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,12 @@
+#ifndef _TelepathyLoggerQt4_LogWalker_HEADER_GUARD_
+#define _TelepathyLoggerQt4_LogWalker_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_LOGGER_QT4_HEADER
+#define IN_TELEPATHY_LOGGER_QT4_HEADER
+#endif
+
+#include <TelepathyLoggerQt4/log-walker.h>
+
+#undef IN_TELEPATHY_LOGGER_QT4_HEADER
+
+#endif
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/call-event.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/call-event.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/call-event.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/call-event.h	2013-06-21 15:44:20.000000000 +0000
@@ -29,17 +29,37 @@
 namespace Tpl
 {
 
-/*! \headerfile call-event.h <TelepathyLoggerQt4/CallEvent>
- * \brief Wrapper class for TplCallEvent
+/*!
+ * \headerfile call-event.h <TelepathyLoggerQt4/CallEvent>
+ * \brief Represents a call log event.
  */
 class TELEPATHY_LOGGER_QT4_EXPORT CallEvent : public Event
 {
-    QTELEPATHYLOGGERQT4_WRAPPER(CallEvent)
 public:
+
+    /*!
+     * \brief Returns the call duration
+     */
     QTime duration() const;
+
+    /*!
+     * \brief Returns the actor that caused the call to end
+     */
     EntityPtr endActor() const;
+
+    /*!
+     * \brief Returns the reason for which this call was ended.
+     */
     Tp::CallStateChangeReason endReason() const;
+
+    /*!
+     * \brief Returns a string representing a D-Bus error that gives more details about
+     *         the end reason
+     */
     QString detailedEndReason() const;
+
+private:
+    QTELEPATHYLOGGERQT4_WRAPPER(CallEvent)
 };
 
 } //namespace
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/entity.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/entity.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/entity.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/entity.h	2013-06-21 15:44:20.000000000 +0000
@@ -30,21 +30,61 @@
 namespace Tpl
 {
 
-/*! \headerfile entity.h <TelepathyLoggerQt4/Entity>
- * \brief Wrapper class for TplEntity
+/**
+ * \headerfile entity.h <TelepathyLoggerQt4/Entity>
+ * \brief An object representing a contact or room.
  */
 class TELEPATHY_LOGGER_QT4_EXPORT Entity : public QGlib::Object
 {
-    QTELEPATHYLOGGERQT4_WRAPPER(Entity)
 public:
-    static EntityPtr create(const char *id, EntityType type, const char *alias, const char *avatarToken);
+    /**
+     * \brief Constructs a new entity
+     *
+     * \param id
+     * \param type
+     * \param alias
+     * \param avatarToken
+     */
+    static EntityPtr create(const char *id, EntityType type, const char *alias,
+                            const char *avatarToken);
+
+    /**
+     * \brief Constructs a new entity from Tp::Contact
+     *
+     * \param contact
+     * \param type
+     */
     static EntityPtr create(const Tp::ContactPtr & contact, EntityType type);
+
+    /**
+     * \brief Constructs a new for a room
+     *
+     * \param room_id
+     */
     static EntityPtr create(const char *room_id);
 
+    /**
+     * \brief Returns entity's alias
+     */
     QString alias() const;
+
+    /**
+     * \brief Returns entity's unique identifier
+     */
     QString identifier() const;
+
+    /**
+     * \brief Returns whether the entity is a contact, a room or account owner
+     */
     EntityType entityType() const;
+
+    /**
+     * \brief Returns entity's avatar token
+     */
     QString avatarToken() const;
+
+private:
+    QTELEPATHYLOGGERQT4_WRAPPER(Entity)
 };
 
 } //namespace
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/event.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/event.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/event.cpp	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/event.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -65,3 +65,9 @@
 {
     return tpl_event_equal (object<TplEvent>(), rhs->object<TplEvent>());
 }
+
+bool Event::operator==(const EventPtr& rhs) const
+{
+    return equalTo(rhs);
+}
+
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/event.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/event.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/event.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/event.h	2013-06-21 15:44:20.000000000 +0000
@@ -30,19 +30,52 @@
 namespace Tpl
 {
 
-/*! \headerfile event.h <TelepathyLoggerQt4/Event>
- * \brief Wrapper class for TplEvent
+/*!
+ * \headerfile event.h <TelepathyLoggerQt4/Event>
+ * \brief The TPLogger log event represents a generic log event, which will be
+ * specialized by subclasses.
  */
 class TELEPATHY_LOGGER_QT4_EXPORT Event : public QGlib::Object
 {
-    QTELEPATHYLOGGERQT4_WRAPPER(Event)
 public:
+
+    /*!
+     * \brief Returns a timestamp when the event has been logged.
+     */
     QDateTime timestamp() const;
+
+    /*!
+     *\brief Returns account path of the account the event is associated to.
+     */
     QString accountPath() const;
+
+    /*!
+     * \brief Returns the account the event is associated to.
+     */
     Tp::AccountPtr account() const;
+
+    /*!
+     * \brief Returns the entity that originated the log event.
+     */
     EntityPtr sender() const;
+
+    /*!
+     * \brief Returns the entity thas was destination for the log event.
+     */
     EntityPtr receiver() const;
+
+    /*!
+     * \brief Equivalent to operator==().
+     */
     bool equalTo(const EventPtr & rhs) const;
+
+    /*!
+     * \brief Comparison operator.
+     */
+    bool operator==(const EventPtr & rhs ) const;
+
+private:
+    QTELEPATHYLOGGERQT4_WRAPPER(Event)
 };
 
 } //namespace
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/global.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/global.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/global.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/global.h	2013-06-21 15:44:20.000000000 +0000
@@ -61,6 +61,7 @@
 QTELEPATHYLOGGERQT4_WRAPPER_DECLARATION(Event)
 QTELEPATHYLOGGERQT4_WRAPPER_DECLARATION(TextEvent)
 QTELEPATHYLOGGERQT4_WRAPPER_DECLARATION(LogManager)
+QTELEPATHYLOGGERQT4_WRAPPER_DECLARATION(LogWalker)
 
 #undef QTELEPATHYLOGGERQT4_WRAPPER_DECLARATION
 #undef QTELEPATHYLOGGERQT4_WRAPPER_REFPOINTER_DECLARATION
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/init.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/init.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/init.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/init.h	2013-06-21 15:44:20.000000000 +0000
@@ -28,7 +28,8 @@
 namespace Tpl
 {
 
-/*! \headerfile init.h <TelepathyLoggerQt4/Init>
+/*!
+ * \headerfile init.h <TelepathyLoggerQt4/Init>
  * \brief Initialization of the telepathy logger qt4 bindings
  */
 
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-manager.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-manager.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-manager.cpp	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-manager.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -23,6 +23,7 @@
 #include <TelepathyQt/Account>
 #include <TelepathyQt/AccountManager>
 #include <TelepathyLoggerQt4/Entity>
+#include <TelepathyLoggerQt4/LogWalker>
 #include <TelepathyLoggerQt4/PendingDates>
 #include <TelepathyLoggerQt4/PendingEntities>
 #include <TelepathyLoggerQt4/PendingEvents>
@@ -123,3 +124,20 @@
 
     return operation;
 }
+
+LogWalkerPtr LogManager::queryWalkFilteredEvents(const Tp::AccountPtr& account,
+        const EntityPtr& entity, EventTypeMask typeMask, LogEventFilter filterFunction,
+        void* filterFunctionUserData)
+{
+    TpAccount *tpAccount = Utils::instance()->tpAccount(account);
+    if (!tpAccount) {
+        qWarning() << "Invalid account";
+        return LogWalkerPtr();
+    }
+
+    TplLogWalker *tpWalker = tpl_log_manager_walk_filtered_events(
+                                LogManagerPtr(this), tpAccount, entity,
+                                (gint) typeMask, (TplLogEventFilter) filterFunction,
+                                filterFunctionUserData);
+    return LogWalkerPtr::wrap(tpWalker, false);
+}
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-manager.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-manager.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-manager.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-manager.h	2013-06-21 15:44:20.000000000 +0000
@@ -3,6 +3,7 @@
  *
  * Copyright (C) 2011 Stefano Sanfilippo <stefano.k.sanfilippo@gmail.com>
  * Copyright (C) 2011 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2013 Dan Vrátil <dvratil@redhat.com>
  *
  * This library is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published
@@ -31,33 +32,154 @@
 namespace Tpl
 {
 
-/*! \headerfile log-manager.h <TelepathyLoggerQt4/LogManager>
- * \brief Wrapper class for TplLogManager
+/*!
+ * \headerfile log-manager.h <TelepathyLoggerQt4/LogManager>
+ * \brief The LogManager object allows user to fetch logs and make searches.
  */
 class TELEPATHY_LOGGER_QT4_EXPORT LogManager : public QGlib::Object
 {
-    QTELEPATHYLOGGERQT4_WRAPPER(LogManager)
 public:
+    /*!
+     * \brief Returns reference to a LogManager singleton
+     */
     static LogManagerPtr instance();
 
+    /*!
+     * \brief Returns Tp::AccountManager assigned to the LogManager.
+     */
     Tp::AccountManagerPtr accountManagerPtr() const;
+
+    /*!
+     * \brief Sets a new Tp::AccountManager to be used by the LogManager.
+     *
+     * The \p accountManager is expected to be in ready state.
+     *
+     * \param accountManager An Tp::AccountManager in the ready state.
+     */
     void setAccountManagerPtr(const Tp::AccountManagerPtr & accountManager);
 
+    /*!
+     * \brief Checks if logs exist for \p target.
+     *
+     * It applies for any registered readable log store.
+     *
+     * \param account An account to which the events should be associated
+     * \param target Target to query
+     * \param type Type of the events to query
+     * \returns true when logs exist for \p target, otherwise false.
+     */
     bool exists(const Tp::AccountPtr & account, const EntityPtr & target, EventTypeMask type) const;
 
+    /*!
+     * \brief Retrieves a list of dates corresponding to each day where
+     * at least one event exist for \p target.
+     *
+     * \param account An account associated with the events
+     * \param entity An entity to query
+     * \param typeMask Type of events to query
+     * \return Returns a PendingOperation that will emit finished() when
+     * events were retrieved or an error occurs.
+     */
     PendingDates *queryDates(const Tp::AccountPtr & account, const EntityPtr & entity,
         EventTypeMask typeMask);
+
+    /*!
+     * \brief Retrieves a list of events on given \p date for \p target.
+     *
+     * \param account An account associated with the events
+     * \param entity An entity to query
+     * \param typeMask Type of events to query
+     * \param date A date for which to retrieve events
+     * \return Returns a PendingOperation that will emit finished() when
+     * events were retrieved or an error occurs.
+     */
     PendingEvents *queryEvents(const Tp::AccountPtr & account, const EntityPtr & entity,
         EventTypeMask typeMask, const QDate & date);
+
+    /*!
+     * \brief Retrieves a list of events matching given filter.
+     *
+     * \param account An account associated with the events
+     * \param entity An entity to query
+     * \param typeMask Type of events to query
+     * \param numEvents Maximum amount of events to fetch
+     * \param filterFunction A filter function that will be called for every event to
+     * check whether it matches the filter or not.
+     * \param filterFunctionUserData An arbitrary user data to be passed to the \p filterFunction
+     * with every call.
+     * \return Returns a PendingOperation that will emit finished() when
+     * events were retrieved has been rewound or an error occurs.
+     */
     PendingEvents *queryFilteredEvents(const Tp::AccountPtr & account, const EntityPtr & entity,
         EventTypeMask typeMask, uint numEvents, LogEventFilter filterFunction,
-        void *filterFunctionUserData);
+        void *filterFunctionUserData = 0);
+
+    /**
+     * \brief Retrieves a list of entities associated with given \p account.
+     *
+     * \param account
+     * \return Returns a PendingOperation that will emit finished() when
+     * entities were retrieved or an error occurs.
+     */
     PendingEntities *queryEntities(const Tp::AccountPtr & account);
+
+    /**
+     * \brief Retrieves a list of events matching given full-text filter
+     *
+     * \param text A pattern to search
+     * \param typeMask Type of events to match
+     * \return Returns a PendingOperation that will emit finished() when
+     * entities were retrieved or an error occurs.
+     */
     PendingSearch *search(const QString &text, EventTypeMask typeMask);
 
+    /**
+     * \brief Irreversibly deletes all logs.
+     *
+     * \return Returns a PendingOperation that will emit finished() when
+     * all logs were deleted or an error occurs.
+     */
     PendingOperation *clearHistory();
+
+    /**
+     * \brief Irreversibly deletes all logs associated with given \p account
+     *
+     * \param account
+     * \return Returns a PendingOperation that will emit finished() when
+     * logs were deleted or an error occurs.
+     */
     PendingOperation *clearAccountHistory(const Tp::AccountPtr &account);
+
+    /**
+     * \brief Irreversibly delets all logs associated with given \p account and
+     * \p entity.
+     *
+     * \param account
+     * \param entity
+     * \return Returns a PendingOperation that will emit finished() when
+     * logs were deleted or an error occurs.
+     */
     PendingOperation *clearEntityHistory(const Tp::AccountPtr &account, const Tpl::EntityPtr &entity);
+
+    /**
+     * \brief Creates a LogWalker to traverse all the events exchanged with \p target
+     *
+     * \param account An account associated with the events
+     * \param entity An entity associated with the events
+     * \param typeMask Type of events to query
+     * \param filterFunction A filter function that will be called for every event to
+     * check whether it matches the filter or not.
+     * \param filterFunctionUserData An arbitrary user data to be passed to the
+     * \p filterFunction with every call.
+     * \return A new LogWalker.
+     * \since 0.8.0
+     */
+    Tpl::LogWalkerPtr queryWalkFilteredEvents(const Tp::AccountPtr &account,
+        const Tpl::EntityPtr &entity, EventTypeMask typeMask, LogEventFilter filterFunction,
+        void *filterFunctionUserData = 0);
+
+private:
+    QTELEPATHYLOGGERQT4_WRAPPER(LogManager)
 };
 
 } //namespace
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-walker.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-walker.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-walker.cpp	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-walker.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,48 @@
+/*
+ * This file is part of TelepathyLoggerQt4
+ *
+ * Copyright (C) 2013 Dan Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <TelepathyLoggerQt4/LogWalker>
+#include <TelepathyLoggerQt4/Types>
+#include <TelepathyLoggerQt4/PendingEvents>
+
+#include "pending-log-walker-operation.h"
+
+#include <telepathy-logger/log-walker.h>
+
+using namespace Tpl;
+
+bool LogWalker::isStart()
+{
+    return tpl_log_walker_is_start(LogWalkerPtr(this));
+}
+
+bool LogWalker::isEnd()
+{
+    return tpl_log_walker_is_end(LogWalkerPtr(this));
+}
+
+PendingEvents* LogWalker::queryEvents(uint numEvents)
+{
+    return new PendingEvents(LogWalkerPtr(this), numEvents);
+}
+
+PendingOperation* LogWalker::rewind(uint numEvents)
+{
+    return new PendingLogWalkerOperation(LogWalkerPtr(this), PendingLogWalkerOperation::Rewind, numEvents);
+}
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-walker.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-walker.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/log-walker.h	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/log-walker.h	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,98 @@
+/*
+ * This file is part of TelepathyLoggerQt4
+ *
+ * Copyright (C) 2013 Dan Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TelepathyLoggerQt4_log_walker_h_HEADER_GUARD_
+#define _TelepathyLoggerQt4_log_walker_h_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_LOGGER_QT4_HEADER
+#error IN_TELEPATHY_LOGGER_QT4_HEADER
+#endif
+
+#include <QGlib/Object>
+#include <TelepathyLoggerQt4/Types>
+
+namespace Tpl {
+
+class PendingOperation;
+class PendingEvents;
+
+/*!
+ * \headerfile log-manager.h <TelepathyLoggerQt4/LogWalker>
+ * \brief The LogWalker object allows the user to sequentially iterate over the logs.
+ *
+ * \since 0.8.0
+ */
+class TELEPATHY_LOGGER_QT4_EXPORT LogWalker : public QGlib::Object
+{
+  public:
+    /**
+     * \brief Whether the walker points to the most recent event in logs.
+     *
+     * Determines whether this walker is pointing at the most recent event in
+     * the logs. This is the case when it has not yet returned any
+     * events or has been rewound completely.
+     *
+     * \return Returns true if walker is pointing at the most recent event,
+     * otherwise false.
+     */
+    bool isStart();
+
+    /**
+     * \brief Whether the walker has run out of events.
+     *
+     *
+     * Determines whether this walker has run out of events. This is the case
+     * when it has returned all the events from the logs.
+     *
+     * \return Returns true if walker has run out of events, otherwise false.
+     */
+    bool isEnd();
+
+    /**
+     * \brief Retrieves \p numEvents of most recent events.
+     *
+     * Walks the logs to retrieve the next most recent \p numEvents events.
+     *
+     * \param numEvents Amount of events to retrieve
+     * \return Returns PendingOperation that will emit finished() when requested
+     * events are received or an error occurs.
+     */
+    PendingEvents* queryEvents(uint numEvents);
+
+    /**
+     * \brief Moves the walker back by the last \p numEvents events.
+     *
+     * Move the walker back by the last \p numEvents events that were
+     * received by getEvents().
+     *
+     * \param numEvents Amount of events to rewind by
+     * \return Returns a PendingOperation that will emit finished() when
+     * walker has been rewound of an error occurs.
+     */
+    PendingOperation* rewind(uint numEvents);
+
+  private:
+    QTELEPATHYLOGGERQT4_WRAPPER(LogWalker)
+};
+
+} //Tpl
+
+QTELEPATHYLOGGERQT4_REGISTER_TYPE(Tpl::LogWalker)
+
+#endif
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-clear.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-clear.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-clear.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-clear.h	2013-06-21 15:44:20.000000000 +0000
@@ -29,6 +29,9 @@
 
 class Logger;
 
+/**
+ * \internal
+ */
 class TELEPATHY_LOGGER_QT4_NO_EXPORT PendingClear : public Tpl::PendingOperation
 {
     Q_OBJECT
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-dates.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-dates.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-dates.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-dates.h	2013-06-21 15:44:20.000000000 +0000
@@ -31,16 +31,36 @@
 namespace Tpl
 {
 
+/**
+ * \headerfile pending-dates.h <TelepathyLoggerQt4/PendingDates>
+ * \brief An operation for retrieving logged dates.
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT PendingDates : public Tpl::PendingOperation
 {
     Q_OBJECT
     Q_DISABLE_COPY(PendingDates);
 
 public:
+    /**
+     * \brief Destructor.
+     */
     ~PendingDates();
 
+    /**
+     * \brief Returns list of all dates retrieved from the log store.
+     *
+     * It's an error to call this method before the finished() signal is emitted.
+     */
     QDateList dates() const;
+
+    /**
+     * \brief Returns account that has been queried
+     */
     const Tp::AccountPtr account() const;
+
+    /**
+     * \brief Returns entity that has been queried.
+     */
     const Tpl::EntityPtr entity() const;
 
 private Q_SLOTS:
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-entities.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-entities.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-entities.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-entities.h	2013-06-21 15:44:20.000000000 +0000
@@ -31,15 +31,31 @@
 namespace Tpl
 {
 
+/**
+ * \headerfile pending-entities.h <TelepathyLoggerQt4/PendingEntities>
+ * \brief An operation for retrieving entities for which logs exist.
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT PendingEntities: public Tpl::PendingOperation
 {
     Q_OBJECT
     Q_DISABLE_COPY(PendingEntities);
 
 public:
+    /**
+     * \brief Destructor.
+     */
     ~PendingEntities();
 
+    /**
+     * \brief Returns list of entities retrieved from logger store.
+     *
+     * It's an error to call this method before the finished() signal is emitted.
+     */
     EntityPtrList entities() const;
+
+    /**
+     * \brief Returns account that has been queried.
+     */
     Tp::AccountPtr account() const;
 
 private Q_SLOTS:
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-events.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-events.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-events.cpp	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-events.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -23,6 +23,7 @@
 #include <QtCore/QDebug>
 #include <TelepathyQt/Account>
 #include <TelepathyLoggerQt4/LogManager>
+#include <TelepathyLoggerQt4/LogWalker>
 #include <TelepathyLoggerQt4/CallEvent>
 #include <TelepathyLoggerQt4/Entity>
 #include <TelepathyLoggerQt4/TextEvent>
@@ -39,6 +40,7 @@
 struct TELEPATHY_LOGGER_QT4_NO_EXPORT PendingEvents::Private
 {
     LogManagerPtr manager;
+    LogWalkerPtr logWalker;
     Tp::AccountPtr account;
     TpAccount *tpAccount;
     EntityPtr entity;
@@ -53,8 +55,9 @@
     EventPtrList events;
 
     static void onAccountPrepared(void *logManager, void *result, PendingEvents *self);
-    static void callback(void *logManager, void *result, PendingEvents *self);
+    static void callback(void *caller, void *result, PendingEvents *self);
     static gboolean eventFilterMethod(TplEvent *event, gpointer *user_data);
+    static void storeAndFreeEvent(TplEvent *event, PendingEvents *self);
 };
 
 PendingEvents::PendingEvents(const LogManagerPtr & manager, const Tp::AccountPtr & account,
@@ -89,6 +92,18 @@
     mPriv->filterFunctionUserData = filterFunctionUserData;
 }
 
+PendingEvents::PendingEvents(const LogWalkerPtr& logWalker, uint numEvents)
+    : PendingOperation(),
+      mPriv(new Private())
+{
+    mPriv->logWalker = logWalker;
+    mPriv->numEvents = numEvents;
+    mPriv->typeMask = Tpl::EventTypeMaskAny;
+    mPriv->filtered = false;
+    mPriv->filterFunction = 0;
+    mPriv->filterFunctionUserData = 0;
+}
+
 PendingEvents::~PendingEvents()
 {
     delete mPriv;
@@ -96,14 +111,18 @@
 
 void PendingEvents::start()
 {
-    mPriv->tpAccount = Utils::instance()->tpAccount(mPriv->account);
-    if (!mPriv->tpAccount) {
-        setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid account");
-        return;
-    }
+    if (mPriv->account) {
+        mPriv->tpAccount = Utils::instance()->tpAccount(mPriv->account);
+        if (!mPriv->tpAccount) {
+            setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid account");
+            return;
+        }
 
-    GQuark features[] = { TP_ACCOUNT_FEATURE_CORE, 0 };
-    tp_proxy_prepare_async(mPriv->tpAccount, features, (GAsyncReadyCallback) Private::onAccountPrepared, this);
+        GQuark features[] = { TP_ACCOUNT_FEATURE_CORE, 0 };
+        tp_proxy_prepare_async(mPriv->tpAccount, features, (GAsyncReadyCallback) Private::onAccountPrepared, this);
+    } else if (mPriv->logWalker) {
+        tpl_log_walker_get_events_async(mPriv->logWalker, mPriv->numEvents, (GAsyncReadyCallback) Private::callback, this);
+    }
 }
 
 void PendingEvents::Private::onAccountPrepared(void *logManager, void *result, PendingEvents *self)
@@ -147,13 +166,8 @@
     return mPriv->events;
 }
 
-void PendingEvents::Private::callback(void *logManager, void *result, PendingEvents *self)
+void PendingEvents::Private::callback(void *caller, void *result, PendingEvents *self)
 {
-    if (!TPL_IS_LOG_MANAGER(logManager)) {
-        self->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid log manager in callback");
-        return;
-    }
-
     if (!G_IS_ASYNC_RESULT(result)) {
         self->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid async result in callback");
         return;
@@ -162,11 +176,17 @@
     GList *events = NULL;
     GError *error = NULL;
     gboolean success = FALSE;
-
-    if (self->mPriv->filtered) {
-        success = tpl_log_manager_get_filtered_events_finish(TPL_LOG_MANAGER(logManager), G_ASYNC_RESULT(result), &events, &error);
+    if (TPL_IS_LOG_MANAGER(caller)) {
+        if (self->mPriv->filtered) {
+            success = tpl_log_manager_get_filtered_events_finish(TPL_LOG_MANAGER(caller), G_ASYNC_RESULT(result), &events, &error);
+        } else {
+            success = tpl_log_manager_get_events_for_date_finish(TPL_LOG_MANAGER(caller), G_ASYNC_RESULT(result), &events, &error);
+        }
+    } else if (TPL_IS_LOG_WALKER(caller)) {
+        success = tpl_log_walker_get_events_finish(TPL_LOG_WALKER(caller), G_ASYNC_RESULT(result), &events, &error);
     } else {
-        success = tpl_log_manager_get_events_for_date_finish(TPL_LOG_MANAGER(logManager), G_ASYNC_RESULT(result), &events, &error);
+        self->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid callback caller");
+        return;
     }
 
     if (error) {
@@ -180,27 +200,28 @@
         return;
     }
 
-    GList *i;
-    for (i = events; i; i = i->next) {
-        TplEvent * item = (TplEvent *) i->data;
-        if (TPL_IS_TEXT_EVENT(item)) {
-            TextEventPtr eventPtr = TextEventPtr::wrap(TPL_TEXT_EVENT(item), true);
-            self->mPriv->events << eventPtr;
-        } else if (TPL_IS_CALL_EVENT(item)) {
-            CallEventPtr eventPtr = CallEventPtr::wrap(TPL_CALL_EVENT(item), true);
-            self->mPriv->events << eventPtr;
-        } else if (TPL_IS_EVENT(item)) {
-            EventPtr eventPtr = EventPtr::wrap(TPL_EVENT(item), true);
-            self->mPriv->events << eventPtr;
-        }
-    }
-
-    g_list_foreach(events, (GFunc) g_object_unref, NULL);
+    g_list_foreach(events, (GFunc) &storeAndFreeEvent, self);
     g_list_free(events);
 
     self->setFinished();
 }
 
+void PendingEvents::Private::storeAndFreeEvent(TplEvent *tplEvent, PendingEvents *self)
+{
+    if (TPL_IS_TEXT_EVENT(tplEvent)) {
+        TextEventPtr eventPtr = TextEventPtr::wrap(TPL_TEXT_EVENT(tplEvent), true);
+        self->mPriv->events << eventPtr;
+    } else if (TPL_IS_CALL_EVENT(tplEvent)) {
+        CallEventPtr eventPtr  = CallEventPtr::wrap(TPL_CALL_EVENT(tplEvent), true);
+        self->mPriv->events << eventPtr;
+    } else if (TPL_IS_EVENT(tplEvent)) {
+        EventPtr eventPtr = EventPtr::wrap(TPL_EVENT(tplEvent), true);
+        self->mPriv->events << eventPtr;
+    }
+
+    g_object_unref(tplEvent);
+}
+
 gboolean PendingEvents::Private::eventFilterMethod(TplEvent *event, gpointer *user_data)
 {
     PendingEvents *self = (PendingEvents *) user_data;
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-events.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-events.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-events.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-events.h	2013-06-21 15:44:20.000000000 +0000
@@ -31,14 +31,26 @@
 namespace Tpl
 {
 
+/**
+ * \headerfile pending-events.h <TelepathyLoggerQt4/PendingEvents>
+ * \brief An operation for retrieving events from the logger storage
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT PendingEvents : public Tpl::PendingOperation
 {
     Q_OBJECT
     Q_DISABLE_COPY(PendingEvents);
 
 public:
+    /**
+     * \brief Destructor.
+     */
     ~PendingEvents();
 
+    /**
+     * \brief Returns all events retrieved by the operation.
+     *
+     * It's an error calling this method before the finished() signal is emitted.
+     */
     EventPtrList events() const;
 
 private Q_SLOTS:
@@ -46,12 +58,14 @@
 
 private:
     friend class LogManager;
+    friend class LogWalker;
 
     PendingEvents(const LogManagerPtr & manager, const Tp::AccountPtr & account,
             const EntityPtr & entity, EventTypeMask typeMask, const QDate &date);
     PendingEvents(const LogManagerPtr & manager, const Tp::AccountPtr & account,
             const EntityPtr & entity, EventTypeMask typeMask, uint numEvents,
             LogEventFilter filterFunction, void *filterFunctionUserData);
+    PendingEvents(const LogWalkerPtr & logWalker, uint numEvents);
 
     struct Private;
     friend struct Private;
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-log-walker-operation.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-log-walker-operation.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-log-walker-operation.cpp	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-log-walker-operation.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,81 @@
+/*
+ * This file is part of TelepathyLoggerQt4
+ *
+ * Copyright (C) 2013 Dan Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "pending-log-walker-operation.h"
+
+#include <TelepathyLoggerQt4/LogWalker>
+#include <TelepathyLoggerQt4/_gen/pending-log-walker-operation.moc.hpp>
+#include <TelepathyQt/Constants>
+
+#include <telepathy-logger/log-walker.h>
+
+#include "utils.h"
+
+using namespace Tpl;
+
+struct TELEPATHY_LOGGER_QT4_NO_EXPORT PendingLogWalkerOperation::Private
+{
+    LogWalkerPtr logWalker;
+    OperationType operation;
+    int numEvents;
+
+    static void rewindFinished(TplLogWalker *tpLogWalker, void *result, PendingLogWalkerOperation *operation);
+};
+
+PendingLogWalkerOperation::PendingLogWalkerOperation(const LogWalkerPtr& logWalker,
+                                                     PendingLogWalkerOperation::OperationType operation,
+                                                     uint numEvents)
+    : PendingOperation(),
+      mPriv(new Private())
+{
+    mPriv->logWalker = logWalker;
+    mPriv->operation = operation;
+    mPriv->numEvents = numEvents;
+}
+
+PendingLogWalkerOperation::~PendingLogWalkerOperation()
+{
+    delete mPriv;
+}
+
+void PendingLogWalkerOperation::start()
+{
+    if (mPriv->operation == Rewind) {
+        tpl_log_walker_rewind_async(mPriv->logWalker, mPriv->numEvents,
+                                    (GAsyncReadyCallback) Private::rewindFinished,
+                                    this);
+    }
+}
+
+void PendingLogWalkerOperation::Private::rewindFinished(TplLogWalker *tpLogWalker,
+                                                        void* result,
+                                                        PendingLogWalkerOperation* operation)
+{
+    if (!TPL_IS_LOG_WALKER(tpLogWalker)) {
+        operation->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid log walker in callback");
+        return;
+    }
+
+    if (!G_IS_ASYNC_RESULT(result)) {
+        operation->setFinishedWithError(TP_QT_ERROR_INVALID_ARGUMENT, "Invalid async result in callback");
+        return;
+    }
+
+    operation->setFinished();
+}
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-log-walker-operation.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-log-walker-operation.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-log-walker-operation.h	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-log-walker-operation.h	2013-06-21 15:44:20.000000000 +0000
@@ -0,0 +1,59 @@
+/*
+ * This file is part of TelepathyLoggerQt4
+ *
+ * Copyright (C) 2013 Dan Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TelepathyLoggerQt4_pending_log_walker_operation_h_HEADER_GUARD_
+#define _TelepathyLoggerQt4_pending_log_walker_operation_h_HEADER_GUARD_
+
+#include <TelepathyLoggerQt4/PendingOperation>
+#include <TelepathyLoggerQt4/Types>
+
+namespace Tpl {
+
+/**
+ * \internal
+ * \brief Generic class for LogWalker operations
+ */
+class TELEPATHY_LOGGER_QT4_EXPORT PendingLogWalkerOperation : public Tpl::PendingOperation
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(PendingLogWalkerOperation)
+
+  public:
+    enum OperationType {
+        Rewind
+    };
+
+    ~PendingLogWalkerOperation();
+
+  private Q_SLOTS:
+    virtual void start();
+
+  private:
+    friend class LogWalker;
+
+    PendingLogWalkerOperation(const LogWalkerPtr &logWalker, OperationType operation, uint numEvents);
+
+    struct Private;
+    friend class Private;
+    Private *mPriv;
+};
+
+} // Tpl
+
+#endif
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-operation.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-operation.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-operation.cpp	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-operation.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -39,38 +39,7 @@
     bool finished;
 };
 
-/**
- * \class PendingOperation
- * \headerfile TelepathyQt/pending-operation.h <TelepathyQt/PendingOperation>
- *
- * \brief Abstract base class for pending asynchronous operations.
- *
- * This class represents an incomplete asynchronous operation, such as a
- * D-Bus method call. When the operation has finished, it emits
- * #finished. The slot or slots connected to the #finished() signal may obtain
- * additional information from the %PendingOperation.
- *
- * In simple cases, like a D-Bus method with no 'out' arguments or for which
- * all 'out' arguments are to be ignored (so the possible results are
- * success with no extra information, or failure with an error code), the
- * trivial subclass %PendingVoid can be used.
- *
- * For pending operations that produce a result, another subclass of
- * %PendingOperation can be used, with additional methods that provide that
- * result to the library user.
- *
- * After #finished() is emitted, the %PendingOperation is automatically
- * deleted using deleteLater(), so library users must not explicitly
- * delete this object.
- *
- * The design is loosely based on KDE's KJob.
- */
-
-/**
- * Protected constructor. Only subclasses of this class may be constructed.
- *
- * \param object The object on which this pending operation takes place
- */
+
 PendingOperation::PendingOperation()
     : QObject(),
       mPriv(new Private())
@@ -78,9 +47,6 @@
     QTimer::singleShot(0, this, SLOT(start()));
 }
 
-/**
- * Class destructor.
- */
 PendingOperation::~PendingOperation()
 {
     if (!mPriv->finished) {
@@ -99,10 +65,6 @@
     deleteLater();
 }
 
-/**
- * Record that this pending operation has finished successfully, and
- * emit the #finished() signal next time the event loop runs.
- */
 void PendingOperation::setFinished()
 {
     if (mPriv->finished) {
@@ -121,13 +83,6 @@
     QTimer::singleShot(0, this, SLOT(emitFinished()));
 }
 
-/**
- * Record that this pending operation has finished with an error, and
- * emit the #finished() signal next time the event loop runs.
- *
- * \param name A D-Bus error name, which must be non-empty
- * \param message A debugging message
- */
 void PendingOperation::setFinishedWithError(const QString &name,
         const QString &message)
 {
@@ -156,88 +111,32 @@
     QTimer::singleShot(0, this, SLOT(emitFinished()));
 }
 
-/**
- * Returns whether or not the request completed successfully. If the
- * request has not yet finished processing (isFinished() returns
- * <code>false</code>), this cannot yet be known, and <code>false</code>
- * will be returned.
- *
- * Equivalent to <code>(isFinished() && !isError())</code>.
- *
- * \return <code>true</code> iff the request has finished processing AND
- *         has completed successfully.
- */
+
 bool PendingOperation::isValid() const
 {
     return (mPriv->finished && mPriv->errorName.isEmpty());
 }
 
-/**
- * Returns whether or not the request has finished processing. #finished()
- * is emitted when this changes from <code>false</code> to
- * <code>true</code>.
- *
- * Equivalent to <code>(isValid() || isError())</code>.
- *
- * \sa finished()
- *
- * \return <code>true</code> if the request has finished
- */
 bool PendingOperation::isFinished() const
 {
     return mPriv->finished;
 }
 
-/**
- * Returns whether or not the request resulted in an error. If the
- * request has not yet finished processing (isFinished() returns
- * <code>false</code>), this cannot yet be known, and <code>false</code>
- * will be returned.
- *
- * Equivalent to <code>(isFinished() && !isValid())</code>.
- *
- * \return <code>true</code> iff the request has finished processing AND
- *         has resulted in an error.
- */
 bool PendingOperation::isError() const
 {
     return (mPriv->finished && !mPriv->errorName.isEmpty());
 }
 
-/**
- * If isError() would return true, returns the D-Bus error with which
- * the operation failed. If the operation succeeded or has not yet
- * finished, returns an empty string.
- *
- * \return a D-Bus error name or an empty string
- */
 QString PendingOperation::errorName() const
 {
     return mPriv->errorName;
 }
 
-/**
- * If isError() would return true, returns a debugging message associated
- * with the error, which may be an empty string. Otherwise, return an
- * empty string.
- *
- * \return a debugging message or an empty string
- */
 QString PendingOperation::errorMessage() const
 {
     return mPriv->errorMessage;
 }
 
-/**
- * \fn void PendingOperation::finished(Tp::PendingOperation* operation)
- *
- * Emitted when the pending operation finishes, i.e. when #isFinished()
- * changes from <code>false</code> to <code>true</code>.
- *
- * \param operation This operation object, from which further information
- *                  may be obtained
- */
-
 void PendingOperation::start()
 {
 }
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-operation.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-operation.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-operation.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-operation.h	2013-06-21 15:44:20.000000000 +0000
@@ -31,28 +31,139 @@
 namespace Tpl
 {
 
+/**
+ * \headerfile pending-operation.h <TelepathyLoggerQt4/PendingOperation>
+ * \brief Abstract base class for pending asynchronous operations.
+ *
+ * This class represents an incomplete asynchronous operation, such as a
+ * D-Bus method call. When the operation has finished, it emits
+ * #finished(). The slot or slots connected to the #finished() signal may obtain
+ * additional information from the PendingOperation.
+ *
+ * For pending operations that produce a result, another subclass of
+ * PendingOperation can be used, with additional methods that provide that
+ * result to the library user.
+ *
+ * After #finished() is emitted, the PendingOperation is automatically
+ * deleted using deleteLater(), so library users must not explicitly
+ * delete this object.
+ *
+ * The design is loosely based on KDE's KJob.
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT PendingOperation : public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(PendingOperation)
 
 public:
+
+    /**
+     * \brief Class destructor.
+     */
     virtual ~PendingOperation();
 
+    /**
+     * \brief Returns whether or not the request has finished processing.
+     *
+     * finished() is emitted when this changes from <code>false</code> to
+     * <code>true</code>.
+     *
+     * Equivalent to <code>(isValid() || isError())</code>.
+     *
+     * \sa finished()
+     *
+     * \return <code>true</code> if the request has finished
+     */
     bool isFinished() const;
+
+    /**
+     * \brief Returns whether or not the request completed successfully.
+     *
+     * If the request has not yet finished processing (isFinished() returns
+     * <code>false</code>), this cannot yet be known, and <code>false</code>
+     * will be returned.
+     *
+     * Equivalent to <code>(isFinished() && !#isError())</code>.
+     *
+     * \return <code>true</code> iff the request has finished processing AND
+     *         has completed successfully.
+     */
     bool isValid() const;
+
+    /**
+     * \brief Returns whether or not the request resulted in an error.
+     *
+     * If the request has not yet finished processing (isFinished() returns
+     * <code>false</code>), this cannot yet be known, and <code>false</code>
+     * will be returned.
+     *
+     * Equivalent to <code>(isFinished() && !#isValid())</code>.
+     *
+     * \return <code>true</code> iff the request has finished processing AND
+     *         has resulted in an error.
+     */
     bool isError() const;
+
+
+    /**
+     * \brief If isError() would return true, returns the D-Bus error with which
+     * the operation failed.
+     *
+     * If the operation succeeded or has not yet
+     * finished, returns an empty string.
+     *
+     * \return a D-Bus error name or an empty string
+     */
     QString errorName() const;
+
+    /**
+     * \brief If isError() would return true, returns a debugging message associated
+     * with the error.
+     *
+     * The message may be an empty string. Otherwise, return an
+     * empty string.
+     *
+     * \return a debugging message or an empty string
+     */
     QString errorMessage() const;
 
 Q_SIGNALS:
+    /**
+     * \brief Emitted when the pending operation finishes.
+     *
+     * Emitted when #isFinished() changes from <code>false</code> to <code>true</code>.
+     *
+     * \param operation This operation object, from which further information
+     *                  may be obtained
+     */
     void finished(Tpl::PendingOperation *operation);
 
 protected:
+    /**
+     * \brief Protected constructor.
+     *
+     * Only subclasses of this class may be constructed.
+     *
+     * \param object The object on which this pending operation takes place
+     */
     PendingOperation();
 
 protected Q_SLOTS:
+    /**
+     * \brief Record that this pending operation has finished successfully.
+     *
+     * Will emit the #finished() signal next time the event loop runs.
+     */
     void setFinished();
+
+    /**
+     * \brief Record that this pending operation has finished with an error.
+     *
+     * Will emit the #finished() signal next time the event loop runs.
+     *
+     * \param name A D-Bus error name, which must be non-empty
+     * \param message A debugging message
+     */
     void setFinishedWithError(const QString &name, const QString &message);
 
 private Q_SLOTS:
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-search.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-search.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/pending-search.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/pending-search.h	2013-06-21 15:44:20.000000000 +0000
@@ -30,14 +30,26 @@
 namespace Tpl
 {
 
+/**
+ * \headerfile pending-search.h <TelepathyLoggerQt4/PendingSearch>
+ * \brief An operation for retrieving search results.
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT PendingSearch : public Tpl::PendingOperation
 {
     Q_OBJECT
     Q_DISABLE_COPY(PendingSearch);
 
 public:
+    /**
+     * \brief Destructor.
+     */
     ~PendingSearch();
 
+    /**
+     * \brief Returns list of search hits.
+     *
+     * It's an error to call this method before the finished() signal is amitted.
+     */
     SearchHitList hits() const;
 
 private Q_SLOTS:
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/search-hit.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/search-hit.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/search-hit.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/search-hit.h	2013-06-21 15:44:20.000000000 +0000
@@ -34,16 +34,51 @@
 namespace Tpl
 {
 
+
+/**
+ * \headerfile search-hit.h <TelepathyLoggerQt4/SearchHit>
+ * \brief A single search match.
+ */
 class TELEPATHY_LOGGER_QT4_EXPORT SearchHit
 {
 public:
+    /**
+     * \brief Constructs a new search hit
+     * \param account
+     * \param target
+     * \param date
+     */
     SearchHit(const Tp::AccountPtr &account, const EntityPtr &target, const QDate &date);
+
+    /**
+     * \brief Copy constructor.
+     * \param other
+     */
     SearchHit(const SearchHit &other);
+
+    /**
+     * \brief Assignment operator.
+     */
     SearchHit & operator=(const SearchHit &other);
+
+    /**
+     * \brief Destructor.
+     */
     ~SearchHit();
 
+    /**
+     * \brief Returns an account that the matching event is associated with.
+     */
     Tp::AccountPtr account() const;
+
+    /**
+     * \brief Returns an entity that the matching event is associated with.
+     */
     EntityPtr target() const;
+
+    /**
+     * \brief Returns an entity that the matching event is associated with.
+     */
     QDate date() const;
 
 private:
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/text-event.cpp telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/text-event.cpp
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/text-event.cpp	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/text-event.cpp	2013-06-21 15:44:20.000000000 +0000
@@ -52,3 +52,22 @@
     return dateTime;
 }
 
+QString TextEvent::supersedesToken() const
+{
+    const gchar *s = tpl_text_event_get_supersedes_token(object<TplTextEvent>());
+    QString str = QString::fromUtf8(s);
+    return str;
+}
+
+
+QList< TextEventPtr > TextEvent::supersedes() const
+{
+    GList *tplEvents = tpl_text_event_get_supersedes(object<TplTextEvent>());
+    GList *iter;
+    QList<TextEventPtr> events;
+    for (iter = tplEvents; iter; iter = g_list_next(iter)) {
+        events << TextEventPtr::wrap((TplTextEvent*) iter->data, true);
+    }
+
+    return events;
+}
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/text-event.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/text-event.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/text-event.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/text-event.h	2013-06-21 15:44:20.000000000 +0000
@@ -30,17 +30,46 @@
 namespace Tpl
 {
 
-/*! \headerfile text-event.h <TelepathyLoggerQt4/TextEvent>
- * \brief Wrapper class for TplTextEvent
+/*!
+ * \headerfile text-event.h <TelepathyLoggerQt4/TextEvent>
+ * \brief A subclass of Event representing a text log event.
  */
 class TELEPATHY_LOGGER_QT4_EXPORT TextEvent : public Event
 {
-    QTELEPATHYLOGGERQT4_WRAPPER(TextEvent)
 public:
+
+    /*!
+     * \brief Returns the type of the message.
+     */
     Tp::ChannelTextMessageType messageType() const;
+
+    /*!
+     * \brief Returns content of the message.
+     */
     QString message() const;
+
+    /*!
+     * \brief Returns token of the message.
+     */
     QString messageToken() const;
+
+    /*!
+     * \brief Returns timestamp when the message was sent or delivered.
+     */
     QDateTime editTimestamp() const;
+
+    /*!
+     * \brief Returns token of a message this message supersedes.
+     */
+    QString supersedesToken() const;
+
+    /*!
+     * \brief Returns a list of messages this messages supersedes.
+     */
+    QList<TextEventPtr> supersedes() const;
+
+private:
+    QTELEPATHYLOGGERQT4_WRAPPER(TextEvent)
 };
 
 } //namespace
diff -Nru telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/types.h telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/types.h
--- telepathy-logger-qt-0.6.0/TelepathyLoggerQt4/types.h	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/TelepathyLoggerQt4/types.h	2013-06-21 15:44:20.000000000 +0000
@@ -34,26 +34,33 @@
 enum EntityType
 {
     //codegen: EntityTypeUnknown=ENTITY_UNKNOWN,EntityTypeContact=ENTITY_CONTACT,EntityTypeRoom=ENTITY_ROOM,EntityTypeSelf=ENTITY_SELF
-    EntityTypeUnknown,
-    EntityTypeContact,
-    EntityTypeRoom,
-    EntityTypeSelf
+    EntityTypeUnknown, /**< the current contact's type is unknown **/
+    EntityTypeContact, /**< the the contact's type represents a user (buddy), but not
+                         the account's owner for which EntityTypeSelf is used **/
+    EntityTypeRoom,    /**< a named room **/
+    EntityTypeSelf     /**< the contact's type represents the owner of the account
+                         whose channel has been logged, as opposed to 
+                         EntityTypeContact which represents any other user */
 };
 
 enum LogManagerError
 {
-    LogManagerErrorAddEvent
+    LogManagerErrorAddEvent /**  Error returned when adding logs fails **/
 };
 
+/**
+ * \brief Mask used to filter type of Tpl::Event returned.
+ */
 enum EventTypeMask
 {
     //codegen: EventTypeMaskText=EVENT_MASK_TEXT,EventTypeMaskCall=EVENT_MASK_CALL,EventTypeMaskAny=EVENT_MASK_ANY
-    EventTypeMaskText = 1 << 0,
-    EventTypeMaskCall = 1 << 1,
-    EventTypeMaskAny = 0xffff
+    EventTypeMaskText = 1 << 0, /**< Mask to Tpl::TextEvent **/
+    EventTypeMaskCall = 1 << 1, /**< Mask to Tpl::CallEvent **/
+    EventTypeMaskAny = 0xffff   /**< Special value to select all type of Tpl::Event **/
 };
 
 class Logger;
+class LogWalker;
 class PendingDates;
 class PendingEvents;
 class PendingEntities;
diff -Nru telepathy-logger-qt-0.6.0/cmake/modules/FindDBusGLib.cmake telepathy-logger-qt-0.99.0+git20130621+r247/cmake/modules/FindDBusGLib.cmake
--- telepathy-logger-qt-0.6.0/cmake/modules/FindDBusGLib.cmake	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/cmake/modules/FindDBusGLib.cmake	2013-06-21 15:44:20.000000000 +0000
@@ -17,11 +17,11 @@
 
 find_package(PkgConfig)
 if(PKG_CONFIG_FOUND)
-    if (DBusGLib_FIND_VERSION_EXACT)
-        pkg_check_modules(PC_DBUS_GLIB QUIET dbus-glib=${DBusGLib_FIND_VERSION})
-    else (DBusGLib_FIND_VERSION_EXACT)
-        pkg_check_modules(PC_DBUS_GLIB QUIET dbus-glib>=${DBusGLib_FIND_VERSION})
-    endif (DBusGLib_FIND_VERSION_EXACT)
+    if (DBusGLib_FIND_VERSION)
+        pkg_check_modules(PC_DBUS_GLIB QUIET dbus-glib-1>=${DBusGLib_FIND_VERSION})
+    else (DBusGLib_FIND_VERSION)
+        pkg_check_modules(PC_DBUS_GLIB QUIET dbus-glib-1)
+    endif (DBusGLib_FIND_VERSION)
 endif(PKG_CONFIG_FOUND)
 
 find_path(DBUS_GLIB_INCLUDE_DIR
@@ -44,5 +44,4 @@
 )
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(DBUS_GLIB DEFAULT_MSG
-                                  DBUS_GLIB_LIBRARIES DBUS_GLIB_INCLUDE_DIR)
+find_package_handle_standard_args(DBusGLib DEFAULT_MSG DBUS_GLIB_LIBRARIES DBUS_GLIB_INCLUDE_DIR)
diff -Nru telepathy-logger-qt-0.6.0/cmake/modules/FindQtGLib.cmake telepathy-logger-qt-0.99.0+git20130621+r247/cmake/modules/FindQtGLib.cmake
--- telepathy-logger-qt-0.6.0/cmake/modules/FindQtGLib.cmake	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/cmake/modules/FindQtGLib.cmake	2013-06-21 15:44:20.000000000 +0000
@@ -41,6 +41,6 @@
    )
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(QtGLib-2.0 DEFAULT_MSG QTGLIB_LIBRARIES QTGLIB_INCLUDE_DIR)
+find_package_handle_standard_args(QtGLib DEFAULT_MSG QTGLIB_LIBRARIES QTGLIB_INCLUDE_DIR)
 
 mark_as_advanced(QTGLIB_INCLUDE_DIR QTGLIB_LIBRARIES)
diff -Nru telepathy-logger-qt-0.6.0/codegen/CMakeLists.txt telepathy-logger-qt-0.99.0+git20130621+r247/codegen/CMakeLists.txt
--- telepathy-logger-qt-0.6.0/codegen/CMakeLists.txt	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/codegen/CMakeLists.txt	2013-06-21 15:44:20.000000000 +0000
@@ -1,10 +1,16 @@
 find_package(FLEX)
-macro_log_feature(FLEX_FOUND "Flex" "Required to build codegen, a helper code generator"
-                             "http://flex.sourceforge.net/" TRUE)
+set_package_properties(FLEX PROPERTIES
+                       DESCRIPTION "The Fast Lexical Analyzer"
+                       URL "http://flex.sourceforge.net"
+                       TYPE REQUIRED
+                       PURPOSE "Required to build codegen, a helper code generator")
 
 find_package(BISON)
-macro_log_feature(BISON_FOUND "Bison" "Required to build codegen, a helper code generator"
-                              "http://www.gnu.org/software/bison/" TRUE)
+set_package_properties(BISON PROPERTIES
+                       DESCRIPTION "GNU parser generator"
+                       URL "http://www.gnu.org/software/bison/"
+                       TYPE REQUIRED
+                       PURPOSE "Required to build codegen, a helper code generator")
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${QT_INCLUDE_DIR})
 
diff -Nru telepathy-logger-qt-0.6.0/debian/bzr-builder.manifest telepathy-logger-qt-0.99.0+git20130621+r247/debian/bzr-builder.manifest
--- telepathy-logger-qt-0.6.0/debian/bzr-builder.manifest	1970-01-01 00:00:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/bzr-builder.manifest	2013-06-21 15:44:21.000000000 +0000
@@ -0,0 +1,3 @@
+# bzr-builder format 0.3 deb-version 0.99.0+git20130621+r247-4
+lp:~telepathy-kde/telepathy-kde/telepathy-logger-qt revid:git-v1:fee77b39aef0f7ecac8ebf1d71918dd209a42ae5
+merge packaging lp:~telepathy-kde/telepathy-kde/telepathy-logger-qt-ubuntu revid:rohangarg@kubuntu.org-20130227141556-n3pqt41epcz5r8xt
diff -Nru telepathy-logger-qt-0.6.0/debian/changelog telepathy-logger-qt-0.99.0+git20130621+r247/debian/changelog
--- telepathy-logger-qt-0.6.0/debian/changelog	2013-04-03 10:14:03.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/changelog	2013-06-21 15:44:21.000000000 +0000
@@ -1,34 +1,8 @@
-telepathy-logger-qt (0.6.0-0ubuntu1) raring; urgency=low
+telepathy-logger-qt (0.99.0+git20130621+r247-4~saucy1) saucy; urgency=low
 
-  * New upstream release
-
- -- Rohan Garg <rohangarg@kubuntu.org>  Wed, 03 Apr 2013 11:14:00 +0100
-
-telepathy-logger-qt (0.5.80-0ubuntu1) raring; urgency=low
-
-  * New upstream release
-    - Install cmake files in the -dev package
-
- -- Rohan Garg <rohangarg@kubuntu.org>  Thu, 07 Mar 2013 12:24:23 +0000
-
-telepathy-logger-qt (0.5.3-0ubuntu1+ppa1) raring; urgency=low
-
-  * New upstream release
-    - Don't install cmake stuff, was accidentally released
-
- -- Rohan Garg <rohangarg@kubuntu.org>  Mon, 18 Feb 2013 16:30:44 +0530
-
-telepathy-logger-qt (0.5.2-0ubuntu3) raring; urgency=low
-
-  * Fix .install file to provide valid CMake development files. (LP: #1110208)
-
- -- Jacky Alciné <me@jalcine.me>  Wed, 30 Jan 2013 05:10:52 -0500
-
-telepathy-logger-qt (0.5.2-0ubuntu2) raring; urgency=low
-
-  * No-change rebuild for new telepathy-logger version
+  * Auto build.
 
- -- Jeremy Bicha <jbicha@ubuntu.com>  Thu, 03 Jan 2013 11:52:56 -0500
+ -- Michał Zając <michal.zajac+launchpad@gmail.com>  Fri, 21 Jun 2013 15:44:21 +0000
 
 telepathy-logger-qt (0.5.2-0ubuntu1) raring; urgency=low
 
diff -Nru telepathy-logger-qt-0.6.0/debian/libtelepathy-logger-qt4-dev.install telepathy-logger-qt-0.99.0+git20130621+r247/debian/libtelepathy-logger-qt4-dev.install
--- telepathy-logger-qt-0.6.0/debian/libtelepathy-logger-qt4-dev.install	2013-03-07 12:22:52.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/libtelepathy-logger-qt4-dev.install	2013-06-21 15:44:20.000000000 +0000
@@ -1,4 +1,4 @@
 usr/include/*
 usr/lib/*/libtelepathy-logger-qt4.so
 usr/lib/*/pkgconfig/*
-usr/lib/*/TelepathyLoggerQt4/cmake/*
+usr/lib/*/cmake/TelepathyLoggerQt4/*
diff -Nru telepathy-logger-qt-0.6.0/debian/patches/01_no_useless_linking.diff telepathy-logger-qt-0.99.0+git20130621+r247/debian/patches/01_no_useless_linking.diff
--- telepathy-logger-qt-0.6.0/debian/patches/01_no_useless_linking.diff	2013-01-30 14:45:23.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/patches/01_no_useless_linking.diff	1970-01-01 00:00:00.000000000 +0000
@@ -1,12 +0,0 @@
---- a/TelepathyLoggerQt4/CMakeLists.txt
-+++ b/TelepathyLoggerQt4/CMakeLists.txt
-@@ -177,9 +177,6 @@
-     ${GOBJECT_LIBRARIES}
-     -lgio-2.0
-     ${QT_QTDBUS_LIBRARY}
--    ${DBUS_LIBRARIES}
--    ${LIBXML2_LIBRARIES}
--    ${DBUS_GLIB_LIBRARIES}
-     ${TELEPATHY_GLIB_LIBRARIES}
-     ${TELEPATHY_LOGGER_LIBRARIES}
-     ${TELEPATHY_QT4_LIBRARIES}
diff -Nru telepathy-logger-qt-0.6.0/debian/patches/series telepathy-logger-qt-0.99.0+git20130621+r247/debian/patches/series
--- telepathy-logger-qt-0.6.0/debian/patches/series	2013-01-30 14:45:23.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/patches/series	1970-01-01 00:00:00.000000000 +0000
@@ -1 +0,0 @@
-01_no_useless_linking.diff
diff -Nru telepathy-logger-qt-0.6.0/debian/source/format telepathy-logger-qt-0.99.0+git20130621+r247/debian/source/format
--- telepathy-logger-qt-0.6.0/debian/source/format	2013-06-21 15:48:26.596466277 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/source/format	2013-06-21 15:48:26.716466841 +0000
@@ -1 +1 @@
-3.0 (quilt)
+3.0 (native)
diff -Nru telepathy-logger-qt-0.6.0/debian/watch telepathy-logger-qt-0.99.0+git20130621+r247/debian/watch
--- telepathy-logger-qt-0.6.0/debian/watch	2013-04-03 10:14:00.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/debian/watch	2013-06-21 15:44:20.000000000 +0000
@@ -1,3 +1,3 @@
 version=3
 
-ftp://ftp.kde.org/pub/kde/stable/kde-telepathy/([\d.]+)/src/telepathy-logger-qt-([\d.]+).tar.bz2
+ftp://ftp.kde.org/pub/kde/unstable/kde-telepathy/([\d.]+)/src/telepathy-logger-qt-([\d.]+).tar.bz2
diff -Nru telepathy-logger-qt-0.6.0/doxygen.cfg.in telepathy-logger-qt-0.99.0+git20130621+r247/doxygen.cfg.in
--- telepathy-logger-qt-0.6.0/doxygen.cfg.in	2013-04-01 22:32:51.000000000 +0000
+++ telepathy-logger-qt-0.99.0+git20130621+r247/doxygen.cfg.in	2013-06-21 15:44:20.000000000 +0000
@@ -755,13 +755,13 @@
 # each generated HTML page. If it is left blank doxygen will generate a 
 # standard header.
 
-HTML_HEADER            = @abs_top_srcdir@/doxygen-header.html
+HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for 
 # each generated HTML page. If it is left blank doxygen will generate a 
 # standard footer.
 
-HTML_FOOTER            = @abs_top_srcdir@/doxygen-footer.html
+HTML_FOOTER            =
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
 # style sheet that is used by each HTML page. It can be used to 
@@ -770,7 +770,7 @@
 # the style sheet file to the HTML output directory, so don't put your own 
 # stylesheet in the HTML output directory as well, or it will be erased!
 
-HTML_STYLESHEET        = @abs_top_srcdir@/doxygen.css
+HTML_STYLESHEET        =
 
 # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
 # files or namespaces will be aligned in HTML using tables. If set to 
@@ -1434,7 +1434,7 @@
 QHP_NAMESPACE          = "org.freedesktop.Telepathy.Logger.Qt4"
 QHP_VIRTUAL_FOLDER     = "${PROJECT_NAME}-${PACKAGE_VERSION}"
 QCH_FILE               = ${abs_top_builddir}/doc/help/telepathy-logger-qt4.qch
-QHG_LOCATION           = ${QHELPGENERATOR_EXECUTABLE}"
+QHG_LOCATION           = "${QHELPGENERATOR_EXECUTABLE}"
 
 ### TelepathyLoggerQt4 Settings
 ALIASES = \