diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6e8e835a7..a5acc66fd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,167 +1,167 @@
 project(kdepimlibs)
 
 # where to look first for cmake modules. This line must be the first one or cmake will use the system's FindFoo.cmake
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
 
 ############### Build Options ###############
 
 option(KDEPIM_ONLY_KLEO "Only build the libraries needed by Kleopatra." FALSE)
 
 
 ############### The kdepimlibs version (used e.g. in KdepimLibsConfig.cmake) ###############
 set(KDEPIMLIBS_VERSION_MAJOR 4)
 set(KDEPIMLIBS_VERSION_MINOR 2)
-set(KDEPIMLIBS_VERSION_PATCH 90)
+set(KDEPIMLIBS_VERSION_PATCH 92)
 set(KDEPIMLIBS_VERSION ${KDEPIMLIBS_VERSION_MAJOR}.${KDEPIMLIBS_VERSION_MINOR}.${KDEPIMLIBS_VERSION_PATCH})
 
 ############### search packages used by KDE ###############
 
 find_package(KDE4 4.2.90 REQUIRED) # see SVN rev. 952875/954493
 include(KDE4Defaults)
 include(MacroLibrary)
 
 
 ############### Needed commands before building anything ###############
 
 add_definitions (${QT_DEFINITIONS} ${KDE4_DEFINITIONS})
 include_directories (${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${KDE4_INCLUDES})
 
 
 ############### Find the stuff we need ###############
 
 set(Boost_MINIMUM_VERSION "1.33.1")
 find_package(Boost)
 macro_log_feature(Boost_FOUND "boost" "Boost C++ Libraries" "http://www.boost.org" TRUE "" "Required by several critical KDEPIM apps.")
 
 #FindGpgme.cmake already handles the log message but we must ensure it is required.
 find_package(Gpgme REQUIRED)
 # configure macros
 if (GPGME_FOUND)
   include (gpgme++/ConfigureChecks.cmake)
 endif (GPGME_FOUND)
 
 if (NOT KDEPIM_ONLY_KLEO)
   #FindAkonadi.cmake is only there for compatibility reasons, but we don't want to use that.
   find_package(Akonadi 1.1.91 QUIET NO_MODULE)
   macro_log_feature(Akonadi_FOUND "Akonadi" "Akonadi server (from kdesupport)" "http://pim.kde.org/akonadi" TRUE "1.1.91" "Akonadi is required to build KdepimLibs.")
 
   find_package(Sasl2)
   macro_log_feature(SASL2_FOUND "cyrus-sasl" "Cyrus SASL API" "http://asg.web.cmu.edu/sasl/sasl-library.html" TRUE "" "Required to support authentication of logins in the IMAP and Sieve kioslaves.")
   include (ConfigureChecks.cmake)
 endif (NOT KDEPIM_ONLY_KLEO)
 
 
 ############### Now, we add the KDEPIMLibs components ###############
 # These targets will always be built
 add_subdirectory(cmake)
 add_subdirectory(gpgme++)
 add_subdirectory(qgpgme)
 
 if (NOT KDEPIM_ONLY_KLEO)
   add_subdirectory(akonadi)
   add_subdirectory(kabc)
   add_subdirectory(kblog)
   add_subdirectory(kcal)
   add_subdirectory(kholidays)
   add_subdirectory(kimap)
   add_subdirectory(kioslave)
   add_subdirectory(kldap)
   add_subdirectory(kmime)
   add_subdirectory(kpimidentities)
   add_subdirectory(kpimutils)
   add_subdirectory(kresources)
   add_subdirectory(ktnef)
   add_subdirectory(kxmlrpcclient)
   add_subdirectory(mailtransport)
   add_subdirectory(microblog)
   add_subdirectory(kpimtextedit)
   add_subdirectory(syndication)
   # Build the CamelCase headers
   add_subdirectory(includes)
 endif (NOT KDEPIM_ONLY_KLEO)
 
 
 # doc must be a subdir of kdepimlibs
 macro_optional_add_subdirectory(doc)
 
 # All done, let's display what we found...
 macro_display_feature_log()
 
 
 # now create the KdepimLibsConfig.cmake file, which will be loaded by
 # kdelibs/cmake/modules/FindKdepimLibs.cmake and which has to contain all information
 # about the installed kdepimlibs anybody would like to have. Alex
 
 # we need the absolute directories where stuff will be installed too
 # but since the variables which contain the destinations can be relative
 # or absolute paths, we need this macro to make them all absoulte, Alex
 macro(MAKE_INSTALL_PATH_ABSOLUTE out in)
    if (IS_ABSOLUTE "${in}")    # IS_ABSOLUTE is new since cmake 2.4.8
       set(${out} "${in}")
    else (IS_ABSOLUTE "${in}")
       set(${out} "\${KDEPIMLIBS_INSTALL_DIR}/${in}")
    endif (IS_ABSOLUTE "${in}")
 endmacro(MAKE_INSTALL_PATH_ABSOLUTE out in)
 
 # all the following variables are put into KdepimLibsConfig.cmake, so
 # they are usable by projects using kdepimlibs. Alex
 make_install_path_absolute(KDEPIMLIBS_DATA_DIR            ${DATA_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_DBUS_INTERFACES_DIR ${DBUS_INTERFACES_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_DBUS_SERVICES_DIR   ${DBUS_SERVICES_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_INCLUDE_DIR         ${INCLUDE_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_LIB_DIR             ${LIB_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_BIN_DIR             ${BIN_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_LIBEXEC_DIR         ${LIBEXEC_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_SBIN_DIR            ${SBIN_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_HTML_DIR            ${HTML_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_CONFIG_DIR          ${CONFIG_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_ICON_DIR            ${ICON_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_KCFG_DIR            ${KCFG_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_LOCALE_DIR          ${LOCALE_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_MIME_DIR            ${MIME_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_SOUND_DIR           ${SOUND_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_TEMPLATES_DIR       ${TEMPLATES_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_WALLPAPER_DIR       ${WALLPAPER_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_KCONF_UPDATE_DIR    ${KCONF_UPDATE_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_AUTOSTART_DIR       ${AUTOSTART_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_XDG_APPS_DIR        ${XDG_APPS_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_XDG_DIRECTORY_DIR   ${XDG_DIRECTORY_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_SYSCONF_DIR         ${SYSCONF_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_MAN_DIR             ${MAN_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_INFO_DIR            ${INFO_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_SERVICES_DIR        ${SERVICES_INSTALL_DIR})
 make_install_path_absolute(KDEPIMLIBS_SERVICETYPES_DIR    ${SERVICETYPES_INSTALL_DIR})
 
 # Used in configure_file() and install(EXPORT)
 set(KDEPIMLIBS_TARGET_PREFIX KDEPIMLibs__)
 
 # this file is installed and contains all necessary information about the installed kdepimlibs, it also loads the file with the exported targets
 configure_file(KdepimLibsConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/KdepimLibsConfig.cmake" @ONLY)
 
 # this file will be installed too and will be used by cmake when searching for the Config.cmake file to check the version of kdepimlibs, Alex
 macro_write_basic_cmake_version_file(${CMAKE_CURRENT_BINARY_DIR}/KdepimLibsConfigVersion.cmake
                                      ${KDEPIMLIBS_VERSION_MAJOR} ${KDEPIMLIBS_VERSION_MINOR} ${KDEPIMLIBS_VERSION_PATCH})
 
 set(_KdepimLibsConfig_INSTALL_DIR ${LIB_INSTALL_DIR}/KdepimLibs/cmake)
 # places where find_package() looks for FooConfig.cmake files:
 # CMake >= 2.6.0 looks in lib/Foo*/cmake/, CMake >= 2.6.3 also looks in
 # lib/cmake/Foo*/, which packagers prefer. So they can set the KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR
 # option to have kdepimlibs install its Config file there. Alex
 if(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR)
    set(_KdepimLibsConfig_INSTALL_DIR ${LIB_INSTALL_DIR}/cmake/KdepimLibs)
 endif(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR)
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KdepimLibsConfigVersion.cmake
               ${CMAKE_CURRENT_BINARY_DIR}/KdepimLibsConfig.cmake
         DESTINATION ${_KdepimLibsConfig_INSTALL_DIR} )
 
 # Install the file with the exported targets, use ${KDEPIMLIBS_TARGET_PREFIX} as prefix for the names of these targets, Alex
 install(EXPORT kdepimlibsLibraryTargets
         NAMESPACE ${KDEPIMLIBS_TARGET_PREFIX}
         DESTINATION ${_KdepimLibsConfig_INSTALL_DIR}
         FILE KDEPimLibsLibraryTargetsWithPrefix.cmake )
 
 # Install a KDEPimLibsDependencies.cmake so people using kdepimlibs 4.2 with kdelibs < 4.2 get a useful error message, Alex
 file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/KDEPimLibsDependencies.cmake "\n message(FATAL_ERROR \"For using this version of kdepimlibs (${KDEPIMLIBS_VERSION}) you need a newer version of kdelibs, please update.\")\n")
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KDEPimLibsDependencies.cmake
         DESTINATION ${DATA_INSTALL_DIR}/cmake/modules)
diff --git a/akonadi/kmime/messagemodel.cpp b/akonadi/kmime/messagemodel.cpp
index 32c8df4bb..e0387287c 100644
--- a/akonadi/kmime/messagemodel.cpp
+++ b/akonadi/kmime/messagemodel.cpp
@@ -1,164 +1,170 @@
 /*
     Copyright (c) 2006 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "messagemodel.h"
 #include "messageparts.h"
 
 #include <akonadi/itemfetchscope.h>
 #include <akonadi/monitor.h>
 #include <akonadi/session.h>
 
 #include <kmime/kmime_message.h>
 #include <boost/shared_ptr.hpp>
 typedef boost::shared_ptr<KMime::Message> MessagePtr;
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 #include <kio/job.h>
 
 #include <QtCore/QDebug>
 
 using namespace Akonadi;
 
 class Akonadi::MessageModel::Private
 {
   public:
 };
 
 MessageModel::MessageModel( QObject *parent ) :
     ItemModel( parent ),
     d( new Private() )
 {
   fetchScope().fetchPayloadPart( MessagePart::Envelope );
 }
 
 MessageModel::~MessageModel( )
 {
   delete d;
 }
 
 QStringList MessageModel::mimeTypes() const
 {
   return QStringList()
       << QLatin1String("text/uri-list")
       << QLatin1String("message/rfc822");
 }
 
 int MessageModel::rowCount( const QModelIndex & parent ) const
 {
-  if ( collection().isValid() && !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") ) )
+  if ( collection().isValid()
+          && !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") )
+          && collection().contentMimeTypes() != QStringList( QLatin1String("inode/directory") ) )
     return 1;
 
   return ItemModel::rowCount();
 }
 
 int MessageModel::columnCount( const QModelIndex & parent ) const
 {
-  if ( !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") ) )
+  if ( collection().isValid()
+          && !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") )
+          && collection().contentMimeTypes() != QStringList( QLatin1String("inode/directory") ) )
     return 1;
 
   if ( !parent.isValid() )
     return 5; // keep in sync with the column type enum
 
   return 0;
 }
 
 QVariant MessageModel::data( const QModelIndex & index, int role ) const
 {
   if ( !index.isValid() )
     return QVariant();
   if ( index.row() >= rowCount() )
     return QVariant();
 
   if ( !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") ) ) {
      if ( role == Qt::DisplayRole )
        return i18n( "This model can only handle email folders. The current collection holds mimetypes: %1",
                        collection().contentMimeTypes().join( QLatin1String(",") ) );
      else
        return QVariant();
   }
 
   Item item = itemForIndex( index );
   if ( !item.hasPayload<MessagePtr>() )
     return QVariant();
   MessagePtr msg = item.payload<MessagePtr>();
   if ( role == Qt::DisplayRole ) {
     switch ( index.column() ) {
       case Subject:
         return msg->subject()->asUnicodeString();
       case Sender:
         return msg->from()->asUnicodeString();
       case Receiver:
         return msg->to()->asUnicodeString();
       case Date:
         return KGlobal::locale()->formatDateTime( msg->date()->dateTime().toLocalZone(), KLocale::FancyLongDate );
       case Size:
         if ( item.size() == 0 )
           return i18nc( "No size available", "-" );
         else
           return KIO::convertSize( KIO::filesize_t( item.size() ) );
       default:
         return QVariant();
     }
   } else if ( role == Qt::EditRole ) {
     switch ( index.column() ) {
       case Subject:
         return msg->subject()->asUnicodeString();
       case Sender:
         return msg->from()->asUnicodeString();
       case Receiver:
         return msg->to()->asUnicodeString();
       case Date:
         return msg->date()->dateTime().dateTime();
       case Size:
         return item.size();
       default:
         return QVariant();
     }
   }
   return ItemModel::data( index, role );
 }
 
 QVariant MessageModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
-  if ( !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") ) ) {
+
+  if ( collection().isValid()
+          && !collection().contentMimeTypes().contains( QLatin1String("message/rfc822") )
+          && collection().contentMimeTypes() != QStringList( QLatin1String("inode/directory") ) )
     return QVariant();
-  }
 
   if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
     switch ( section ) {
       case Subject:
         return i18nc( "@title:column, message (e.g. email) subject", "Subject" );
       case Sender:
         return i18nc( "@title:column, sender of message (e.g. email)", "Sender" );
       case Receiver:
         return i18nc( "@title:column, receiver of message (e.g. email)", "Receiver" );
       case Date:
         return i18nc( "@title:column, message (e.g. email) timestamp", "Date" );
       case Size:
         return i18nc( "@title:column, message (e.g. email) size", "Size" );
       default:
         return QString();
     }
   }
   return ItemModel::headerData( section, orientation, role );
 }
 
 #include "messagemodel.moc"