Initial commit of QtAddonMimetype

33 files changed, 3655 insertions, 0 deletions

diff --git a/mimetypes.qdocconf b/mimetypes.qdocconf
new file mode 100644
index 0000000..37a0134
--- /dev/null
+++ b/mimetypes.qdocconf
@@ -0,0 +1,33 @@
+# QDoc is a tool that constantly evolves to suit our needs,
+# and there are some compatibility issues between old and new
+# practices. For that reason, any QDoc configuration file needs to
+# include compat.qdocconf.
+
+#include(compat.qdocconf)
+
+# The outputdir variable specifies the directory
+# where QDoc will put the generated documentation.
+
+outputdir   = html
+
+# The headerdirs variable specifies the directories
+# containing the header files associated
+# with the .cpp source files used in the documentation.
+
+headerdirs  = .
+
+# The sourcedirs variable specifies the
+# directories containing the .cpp or .qdoc
+# files used in the documentation.
+
+sourcedirs  = .
+
+# The exampledirs variable specifies the directories containing
+# the source code of the example files.
+
+exampledirs = .
+
+# The imagedirs variable specifies the
+# directories containing the images used in the documentation.
+
+imagedirs   = ./images
diff --git a/qdoc3.sh b/qdoc3.sh
new file mode 100644
index 0000000..d32b782
--- /dev/null
+++ b/qdoc3.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+rm -fr html
+qdoc3 -online mimetypes.qdocconf
diff --git a/qt-mimetypes.pro b/qt-mimetypes.pro
new file mode 100644
index 0000000..c54386a
--- /dev/null
+++ b/qt-mimetypes.pro
@@ -0,0 +1,21 @@
+TEMPLATE = subdirs
+
+module_src.subdir = $$IN_PWD/src
+module_src.target = module_src
+
+module_simpletest.file = simpletest/simpletest.pro
+module_simpletest.target = module_simpletest
+module_simpletest.depends = module_src
+
+module_unittests.file = unittests/unittests.pro
+module_unittests.target = module_unittests
+module_unittests.depends = module_src
+
+module_declarative_unittests.file = unittests/declarative/tst_declarative_mimetypes.pro
+module_declarative_unittests.target = module_declarative_unittests
+module_declarative_unittests.depends = module_src
+
+exists(src/src.pro): SUBDIRS += module_src
+exists(simpletest/simpletest.pro): SUBDIRS += module_simpletest
+exists(unittests/unittests.pro): SUBDIRS += module_unittests
+exists(unittests/declarative/tst_declarative_mimetypes.pro): SUBDIRS += module_declarative_unittests
diff --git a/simpletest/simpletest.pro b/simpletest/simpletest.pro
new file mode 100644
index 0000000..0cf9b75
--- /dev/null
+++ b/simpletest/simpletest.pro
@@ -0,0 +1,39 @@
+QT       += core
+QT       -= gui
+
+CONFIG   += console
+CONFIG   -= app_bundle
+TEMPLATE = app
+TARGET   = tst_simple_mimetypes
+
+# QtDeclarative/qdeclarativeprivate.h will not compile with -pedantic.
+#MAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi -pedantic -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+QMAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi           -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+
+# dependency management
+QMAKE_CXXFLAGS += -MMD
+include_dependencies.target = include_dependencies
+include_dependencies.commands = @if grep \"^include \\*.d\" Makefile >/dev/null 2>&1; then echo \"Dependency files are already included.\"; else echo \"include *.d\" >> Makefile; echo \"Please rerun make because dependency files will be included next time.\"; fi
+QMAKE_EXTRA_TARGETS += include_dependencies
+POST_TARGETDEPS += include_dependencies
+
+# runtime environment
+LIBS += -L ../lib -lqt-mimetypes
+
+API_DIR = ..
+
+INCLUDEPATH += $$API_DIR ../src/mimetypes
+
+
+SOURCES += tst_simple_mimetypes.cpp
+
+# No headers
+
+
+SOURCES += $$API_DIR/src/declarative/declarativemimetype.cpp \
+           $$API_DIR/src/declarative/declarativemimetyperegistry.cpp \
+           $$API_DIR/src/declarative/declarativeserviceaction.cpp
+
+HEADERS += $$API_DIR/src/declarative/declarativemimetype_p.h \
+           $$API_DIR/src/declarative/declarativemimetyperegistry_p.h \
+           $$API_DIR/src/declarative/declarativeserviceaction_p.h
diff --git a/simpletest/tst_simple_mimetypes.cpp b/simpletest/tst_simple_mimetypes.cpp
new file mode 100644
index 0000000..73e52bc
--- /dev/null
+++ b/simpletest/tst_simple_mimetypes.cpp
@@ -0,0 +1,18 @@
+#include "mimetyperegistry.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+
+// ------------------------------------------------------------------------------------------------
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication app (argc, argv);
+
+    // Instantiate two objects of QMimeTypeRegistry to make sure the class can be instantiated
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry1 (new QMimeTypeRegistry());
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry2 (new QMimeTypeRegistry());
+
+    qDebug() << "Hello world";
+    return 0;
+}
diff --git a/src/declarative/declarative.pro b/src/declarative/declarative.pro
new file mode 100644
index 0000000..cb87d76
--- /dev/null
+++ b/src/declarative/declarative.pro
@@ -0,0 +1,41 @@
+CONFIG   += qt plugin
+TEMPLATE = lib
+TARGET   = declarative_mimetypes
+DESTDIR  = ../../imports/com/nokia/MimeTypes
+
+# QtCore/qlist.h uses /usr/include/limits.h which uses does not compile with -pedantic.
+# QtDeclarative/qdeclarativeprivate.h will not compile with -pedantic.
+#MAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi -pedantic -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+QMAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi           -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+
+# dependency management
+QMAKE_CXXFLAGS += -MMD
+include_dependencies.target = include_dependencies
+include_dependencies.commands = @if grep \"^include \\*.d\" Makefile >/dev/null 2>&1; then echo \"Dependency files are already included.\"; else echo \"include *.d\" >> Makefile; echo \"Please rerun make because dependency files will be included next time.\"; fi
+QMAKE_EXTRA_TARGETS += include_dependencies
+POST_TARGETDEPS += include_dependencies
+
+
+API_DIR = ../..
+
+INCLUDEPATH += $$API_DIR/src/mimetypes
+
+
+SOURCES += $$API_DIR/src/declarative/declarative_mimetypes.cpp
+
+HEADERS += $$API_DIR/src/declarative/declarative_mimetypes.h
+
+
+SOURCES += $$API_DIR/src/declarative/declarativemimetype.cpp \
+           $$API_DIR/src/declarative/declarativemimetyperegistry.cpp \
+           $$API_DIR/src/declarative/declarativeserviceaction.cpp
+
+HEADERS += $$API_DIR/src/declarative/declarativemimetype_p.h \
+           $$API_DIR/src/declarative/declarativemimetyperegistry_p.h \
+           $$API_DIR/src/declarative/declarativeserviceaction_p.h
+
+
+qmldir.files += $$PWD/qmldir
+qmldir.path += ../../imports/com/nokia/MimeTypes
+
+INSTALLS += qmldir
diff --git a/src/declarative/declarative_mimetypes.cpp b/src/declarative/declarative_mimetypes.cpp
new file mode 100644
index 0000000..0f28a2f
--- /dev/null
+++ b/src/declarative/declarative_mimetypes.cpp
@@ -0,0 +1,18 @@
+#include "declarative_mimetypes.h"
+
+#include "declarativemimetype_p.h"
+#include "declarativemimetyperegistry_p.h"
+#include "declarativeserviceaction_p.h"
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeDeclarativeExtensionPlugin::registerTypes(const char* uri)
+{
+    qmlRegisterType<DeclarativeMimeType>(uri, 1, 0, "MimeType");
+    qmlRegisterType<DeclarativeMimeTypeRegistry>(uri, 1, 0, "MimeTypeRegistry");
+    qmlRegisterType<DeclarativeServiceAction>(uri, 1, 0, "ServiceAction");
+}
+
+// ------------------------------------------------------------------------------------------------
+
+Q_EXPORT_PLUGIN2(declarative_mimetypes, QT_PREPEND_NAMESPACE(QMimeTypeDeclarativeExtensionPlugin))
diff --git a/src/declarative/declarative_mimetypes.h b/src/declarative/declarative_mimetypes.h
new file mode 100644
index 0000000..232e2c3
--- /dev/null
+++ b/src/declarative/declarative_mimetypes.h
@@ -0,0 +1,16 @@
+#ifndef DECLARATIVE_MIME_TYPES_H_INCLUDED
+#define DECLARATIVE_MIME_TYPES_H_INCLUDED
+
+#include <QtDeclarative/qdeclarativeextensionplugin.h>
+
+// ------------------------------------------------------------------------------------------------
+
+class QMimeTypeDeclarativeExtensionPlugin : public QDeclarativeExtensionPlugin
+{
+    Q_OBJECT
+
+public:
+    virtual void registerTypes(const char* uri);
+};
+
+#endif
diff --git a/src/declarative/declarativemimetype.cpp b/src/declarative/declarativemimetype.cpp
new file mode 100644
index 0000000..b8c668a
--- /dev/null
+++ b/src/declarative/declarativemimetype.cpp
@@ -0,0 +1,135 @@
+#include "declarativemimetype_p.h"
+
+#include <QtCore/QDebug>
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeType::DeclarativeMimeType(QObject *theParent) :
+        QObject(theParent),
+        m_MimeType()
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeType::DeclarativeMimeType(const QMimeType &other, QObject *theParent) :
+        QObject(theParent),
+        m_MimeType(other)
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeType::~DeclarativeMimeType()
+{
+    //qDebug() << Q_FUNC_INFO << "name():" << name();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeType::assign(DeclarativeMimeType *other)
+{
+    if (other == 0) {
+        qWarning() << Q_FUNC_INFO << "other:" << other;
+        return;
+    }
+
+    m_MimeType = other->m_MimeType;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool DeclarativeMimeType::equals(DeclarativeMimeType *other) const
+{
+    if (other == 0) {
+        qWarning() << Q_FUNC_INFO << "other:" << other;
+        return false;
+    }
+
+    return m_MimeType == other->m_MimeType;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeType DeclarativeMimeType::mimeType() const
+{
+    return m_MimeType;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool DeclarativeMimeType::isValid() const
+{
+    return m_MimeType.isValid();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QMimeTypeName &DeclarativeMimeType::name() const
+{
+    return m_MimeType.name();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeType::setName(const QMimeTypeName &newName)
+{
+    m_MimeType = QMimeType(newName, m_MimeType.displayName(), m_MimeType.iconUrl(), m_MimeType.fileExtentions());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QString &DeclarativeMimeType::displayName() const
+{
+    return m_MimeType.displayName();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeType::setDisplayName(const QString &newDisplayName)
+{
+    m_MimeType = QMimeType(m_MimeType.name(), newDisplayName, m_MimeType.iconUrl(), m_MimeType.fileExtentions());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QString &DeclarativeMimeType::iconUrl() const
+{
+    return m_MimeType.iconUrl();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeType::setIconUrl(const QString &newIconUrl)
+{
+    m_MimeType = QMimeType(m_MimeType.name(), m_MimeType.displayName(), newIconUrl, m_MimeType.fileExtentions());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeType::fileExtentions() const
+{
+    QVariantList result;
+
+    foreach (const QString &fileExtention, m_MimeType.fileExtentions()) {
+        result << fileExtention;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeType::setFileExtentions(const QVariantList &newFileExtentions)
+{
+    QList<QString> result;
+
+    foreach (const QVariant &newFileExtention, newFileExtentions) {
+        if (newFileExtention.type() != QVariant::String) {
+            qWarning() << Q_FUNC_INFO << "newFileExtention" << newFileExtention << " is not a string!";
+            continue;
+        }
+
+        result << newFileExtention.toString();
+    }
+
+    m_MimeType = QMimeType(m_MimeType.name(), m_MimeType.displayName(), m_MimeType.iconUrl(), result);
+}
diff --git a/src/declarative/declarativemimetype_p.h b/src/declarative/declarativemimetype_p.h
new file mode 100644
index 0000000..e55ab86
--- /dev/null
+++ b/src/declarative/declarativemimetype_p.h
@@ -0,0 +1,72 @@
+#ifndef DECLARATIVE_MIME_TYPE_P_H_INCLUDED
+#define DECLARATIVE_MIME_TYPE_P_H_INCLUDED
+
+#include "mimetype.h"
+
+#include <QtDeclarative/qdeclarative.h>
+
+#include <QtCore/QObject>
+
+// ------------------------------------------------------------------------------------------------
+
+class DeclarativeMimeType : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString name
+               READ name
+               WRITE setName)
+
+    Q_PROPERTY(QString displayName
+               READ displayName
+               WRITE setDisplayName)
+
+    Q_PROPERTY(QString iconUrl
+               READ iconUrl
+               WRITE setIconUrl)
+
+    Q_PROPERTY(QVariantList fileExtentions
+               READ fileExtentions
+               WRITE setFileExtentions
+               STORED false)
+
+    Q_PROPERTY(bool isValid
+               READ isValid
+               STORED false)
+
+protected:
+    // We keep this destructor with its default value of 0 protected since only
+    // QDeclarativePrivate::QDeclarativeElement<T> needs it:
+    DeclarativeMimeType(QObject *theParent = 0);
+
+public:
+    // We don't allow theParent to have a default value of 0 because in all
+    // likelyhood we want to force the caller to specify its QObject so the
+    // object will get destroyed in the caller's destructor:
+    DeclarativeMimeType(const QMimeType &other, QObject *theParent);
+
+    ~DeclarativeMimeType();
+
+    Q_INVOKABLE void assign(DeclarativeMimeType *other);
+    Q_INVOKABLE bool equals(DeclarativeMimeType *other) const;
+
+    QMimeType mimeType() const;
+
+    bool isValid() const;
+
+    const QMimeTypeName &name() const;
+    void setName(const QMimeTypeName &newName);
+    const QString &displayName() const;
+    void setDisplayName(const QString &newDisplayName);
+    const QString &iconUrl() const;
+    void setIconUrl(const QString &newIconUrl);
+    QVariantList fileExtentions() const;
+    void setFileExtentions(const QVariantList &newFileExtentions);
+
+private:
+    QMimeType m_MimeType;
+};
+
+QML_DECLARE_TYPE(DeclarativeMimeType)
+
+#endif
diff --git a/src/declarative/declarativemimetyperegistry.cpp b/src/declarative/declarativemimetyperegistry.cpp
new file mode 100644
index 0000000..e889888
--- /dev/null
+++ b/src/declarative/declarativemimetyperegistry.cpp
@@ -0,0 +1,276 @@
+#include "declarativemimetyperegistry_p.h"
+
+#include "declarativemimetype_p.h"
+#include "declarativeserviceaction_p.h"
+
+#include <QtCore/QDebug>
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeTypeRegistry::DeclarativeMimeTypeRegistry(QObject *theParent) :
+        QObject(theParent),
+        m_MimeTypeRegistry()
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeTypeRegistry::~DeclarativeMimeTypeRegistry()
+{
+    //qDebug() << Q_FUNC_INFO;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeTypeRegistry &DeclarativeMimeTypeRegistry::mimeTypeRegistry()
+{
+    return m_MimeTypeRegistry;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::insertMimeType (
+                                      DeclarativeMimeType *mimeType
+                                  )
+{
+    if (mimeType == 0) {
+        qWarning() << Q_FUNC_INFO << "mimeType:" << mimeType;
+        return;
+    }
+
+    m_MimeTypeRegistry.insertMimeType(mimeType->mimeType());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeTypeRegistry::mimeTypes() const
+{
+    QVariantList result;
+
+    foreach (const QMimeTypeName &mimeTypeName, m_MimeTypeRegistry.mimeTypes()) {
+        result << mimeTypeName;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeMimeType *DeclarativeMimeTypeRegistry::findMimeType (
+                                                      const QMimeTypeName &mimeTypeName
+                                                  )
+{
+    return new DeclarativeMimeType (
+                   m_MimeTypeRegistry.findMimeType(mimeTypeName),
+                   this   // <- The new object will be released later
+                          //    when this registry is released.
+               );
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::removeMimeType (
+                                      const QMimeTypeName &mimeTypeName
+                                  )
+{
+    m_MimeTypeRegistry.removeMimeType(mimeTypeName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeTypeRegistry::fileExtentions() const
+{
+    QVariantList result;
+
+    foreach (const QString &fileExtention, m_MimeTypeRegistry.fileExtentions()) {
+        result << fileExtention;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QString DeclarativeMimeTypeRegistry::extractFileExtention (
+                                         const QString &fileName
+                                     ) const
+{
+    return m_MimeTypeRegistry.extractFileExtention(fileName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeTypeRegistry::findMimeTypes (
+                                              const QString &fileExtention
+                                          ) const
+{
+    QVariantList result;
+
+    foreach (const QMimeTypeName &mimeTypeName, m_MimeTypeRegistry.findMimeTypes(fileExtention)) {
+        result << mimeTypeName;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeTypeName DeclarativeMimeTypeRegistry::determineMimeType (
+                                               const QByteArray &data
+                                           ) const
+{
+    return m_MimeTypeRegistry.determineMimeType(data);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::insertServiceAction (
+                                      DeclarativeServiceAction *serviceAction
+                                  )
+{
+    if (serviceAction == 0) {
+        qWarning() << Q_FUNC_INFO << "serviceAction:" << serviceAction;
+        return;
+    }
+
+    m_MimeTypeRegistry.insertServiceAction(serviceAction->serviceAction());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeTypeRegistry::serviceActions() const
+{
+    QVariantList result;
+
+    foreach (const QServiceActionName &serviceActionName, m_MimeTypeRegistry.serviceActions()) {
+        result << serviceActionName;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeServiceAction *
+    DeclarativeMimeTypeRegistry::findServiceAction (
+                                     const QServiceActionName &serviceActionName
+                                 )
+{
+    return new DeclarativeServiceAction (
+                   m_MimeTypeRegistry.findServiceAction(serviceActionName),
+                   this   // <- The new object will be released later
+                          //    when this registry is released.
+               );
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::removeServiceAction (
+                                      const QServiceActionName &serviceActionName
+                                  )
+{
+    return m_MimeTypeRegistry.removeServiceAction(serviceActionName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool DeclarativeMimeTypeRegistry::userAlwaysSelectsApplication (
+                                      const QServiceActionName &serviceActionName,
+                                      const QMimeTypeName &mimeTypeName
+                                  ) const
+{
+    return m_MimeTypeRegistry.userAlwaysSelectsApplication(serviceActionName, mimeTypeName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::setUserAlwaysSelectsApplication (
+                                      const QServiceActionName &serviceActionName,
+                                      const QMimeTypeName &mimeTypeName,
+                                      const bool newSetting
+                                  )
+{
+    return m_MimeTypeRegistry.setUserAlwaysSelectsApplication(serviceActionName, mimeTypeName, newSetting);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::registerApplication (
+                                      const QApplicationId &applicationId,
+                                      const QServiceActionName &serviceActionName,
+                                      const QMimeTypeName &mimeTypeName
+                                  )
+{
+    return m_MimeTypeRegistry.registerApplication(applicationId, serviceActionName, mimeTypeName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::increaseApplicationPreference (
+                                      const QApplicationId &applicationId,
+                                      const QServiceActionName &serviceActionName,
+                                      const QMimeTypeName &mimeTypeName
+                                  )
+{
+    return m_MimeTypeRegistry.increaseApplicationPreference(applicationId, serviceActionName, mimeTypeName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::decreaseApplicationPreference (
+                                      const QApplicationId &applicationId,
+                                      const QServiceActionName &serviceActionName,
+                                      const QMimeTypeName &mimeTypeName
+                                  )
+{
+    return m_MimeTypeRegistry.decreaseApplicationPreference(applicationId, serviceActionName, mimeTypeName);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeMimeTypeRegistry::unregisterApplication (
+                                      const QApplicationId &applicationId
+                                  )
+{
+    return m_MimeTypeRegistry.unregisterApplication(applicationId);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+
+QVariantList DeclarativeMimeTypeRegistry::findApplications (
+                                              const QMimeTypeName &mimeTypeName
+                                          ) const
+{
+    QVariantList result;
+
+    typedef QPair<QApplicationId, QServiceActionName> ApplicationIdAndServiceActionName;
+    foreach (const ApplicationIdAndServiceActionName &applicationIdAndServiceActionName,
+            m_MimeTypeRegistry.findApplications(mimeTypeName)) {
+        QVariantList pair;
+        pair << applicationIdAndServiceActionName.first;
+        pair << applicationIdAndServiceActionName.second;
+        // The insert operation of one variant will only work as intended
+        // if it comes from a QVariant instead of a QVariantList:
+        const QVariant &pair2 (pair);
+        result << pair2;
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QVariantList DeclarativeMimeTypeRegistry::findApplications (
+                                              const QServiceActionName &serviceActionName,
+                                              const QMimeTypeName &mimeTypeName
+                                          ) const
+{
+    QVariantList result;
+
+    foreach (const QApplicationId &applicationId,
+            m_MimeTypeRegistry.findApplications(serviceActionName, mimeTypeName)) {
+        result << applicationId;
+    }
+
+    return result;
+}
diff --git a/src/declarative/declarativemimetyperegistry_p.h b/src/declarative/declarativemimetyperegistry_p.h
new file mode 100644
index 0000000..a2d821c
--- /dev/null
+++ b/src/declarative/declarativemimetyperegistry_p.h
@@ -0,0 +1,145 @@
+#ifndef DECLARATIVE_MIME_TYPE_REGISTRY_P_H_INCLUDED
+#define DECLARATIVE_MIME_TYPE_REGISTRY_P_H_INCLUDED
+
+#include "mimetyperegistry.h"
+
+#include <QtDeclarative/qdeclarative.h>
+
+#include <QtCore/QObject>
+
+class DeclarativeMimeType;
+class DeclarativeServiceAction;
+
+// ------------------------------------------------------------------------------------------------
+
+class DeclarativeMimeTypeRegistry : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QVariantList mimeTypes
+               READ mimeTypes
+               STORED false)
+
+    Q_PROPERTY(QVariantList fileExtentions
+               READ fileExtentions
+               STORED false)
+
+    Q_PROPERTY(QVariantList serviceActions
+               READ serviceActions
+               STORED false)
+
+protected:
+    // We keep this destructor with its default value of 0 protected since only
+    // QDeclarativePrivate::QDeclarativeElement<T> needs it:
+    DeclarativeMimeTypeRegistry(QObject *theParent = 0);
+
+public:
+    ~DeclarativeMimeTypeRegistry();
+
+    QMimeTypeRegistry &mimeTypeRegistry();
+
+    // --------------------------------------------------------------------------------------------
+
+    Q_INVOKABLE void insertMimeType (
+                         DeclarativeMimeType *mimeType
+                     );
+
+    QVariantList mimeTypes() const;
+
+    Q_INVOKABLE DeclarativeMimeType *findMimeType (
+                                         const QString &mimeTypeName
+                                     );
+
+    Q_INVOKABLE void removeMimeType (
+                         const QString &mimeTypeName
+                     );
+
+    // --------------------------------------------------------------------------------------------
+
+    QVariantList fileExtentions() const;
+
+    Q_INVOKABLE QString extractFileExtention (
+                            const QString &fileName
+                        ) const;
+
+    Q_INVOKABLE QVariantList findMimeTypes (
+                                 const QString &fileExtention
+                             ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+    QString determineMimeType (
+                const QByteArray &data
+            ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+    Q_INVOKABLE void insertServiceAction (
+                         DeclarativeServiceAction *serviceAction
+                     );
+
+    QVariantList serviceActions() const;
+
+    Q_INVOKABLE DeclarativeServiceAction *findServiceAction (
+                                              const QString &serviceActionName
+                                          );
+
+    Q_INVOKABLE void removeServiceAction (
+                         const QString &serviceActionName
+                     );
+
+    // --------------------------------------------------------------------------------------------
+
+    Q_INVOKABLE bool userAlwaysSelectsApplication (
+                         const QString &serviceActionName,
+                         const QString &mimeTypeName
+                     ) const;
+
+    Q_INVOKABLE void setUserAlwaysSelectsApplication (
+                         const QString &serviceActionName,
+                         const QString &mimeTypeName,
+                         const bool newSetting
+                     );
+
+    // --------------------------------------------------------------------------------------------
+
+    Q_INVOKABLE void registerApplication (
+                         const QString &applicationId,
+                         const QString &serviceActionName,
+                         const QString &mimeTypeName
+                     );
+
+    Q_INVOKABLE void increaseApplicationPreference (
+                         const QString &applicationId,
+                         const QString &serviceActionName,
+                         const QString &mimeTypeName
+                     );
+
+    Q_INVOKABLE void decreaseApplicationPreference (
+                         const QString &applicationId,
+                         const QString &serviceActionName,
+                         const QString &mimeTypeName
+                     );
+
+    Q_INVOKABLE void unregisterApplication (
+                         const QString &applicationId
+                     );
+
+    Q_INVOKABLE QVariantList findApplications (
+                                 const QString &mimeTypeName
+                             ) const;
+
+    Q_INVOKABLE QVariantList findApplications (
+                                 const QString &serviceActionName,
+                                 const QString &mimeTypeName
+                             ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+private:
+    QMimeTypeRegistry m_MimeTypeRegistry;
+};
+
+QML_DECLARE_TYPE(DeclarativeMimeTypeRegistry)
+
+#endif
diff --git a/src/declarative/declarativeserviceaction.cpp b/src/declarative/declarativeserviceaction.cpp
new file mode 100644
index 0000000..a070b42
--- /dev/null
+++ b/src/declarative/declarativeserviceaction.cpp
@@ -0,0 +1,104 @@
+#include "declarativeserviceaction_p.h"
+
+#include <QtCore/QDebug>
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeServiceAction::DeclarativeServiceAction(QObject *theParent) :
+        QObject(theParent),
+        m_ServiceAction()
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeServiceAction::DeclarativeServiceAction(const QServiceAction &other, QObject *theParent) :
+        QObject(theParent),
+        m_ServiceAction(other)
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+DeclarativeServiceAction::~DeclarativeServiceAction()
+{
+    //qDebug() << Q_FUNC_INFO << "name():" << name();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeServiceAction::assign(DeclarativeServiceAction *other)
+{
+    if (other == 0) {
+        qWarning() << Q_FUNC_INFO << "other:" << other;
+        return;
+    }
+
+    m_ServiceAction = other->m_ServiceAction;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool DeclarativeServiceAction::equals(DeclarativeServiceAction *other) const
+{
+    if (other == 0) {
+        qWarning() << Q_FUNC_INFO << "other:" << other;
+        return false;
+    }
+
+    return m_ServiceAction == other->m_ServiceAction;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QServiceAction DeclarativeServiceAction::serviceAction() const
+{
+    return m_ServiceAction;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool DeclarativeServiceAction::isValid() const
+{
+    return m_ServiceAction.isValid();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QServiceActionName &DeclarativeServiceAction::name() const
+{
+    return m_ServiceAction.name();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeServiceAction::setName(const QServiceActionName &newName)
+{
+    m_ServiceAction = QServiceAction(newName, m_ServiceAction.displayName(), m_ServiceAction.iconUrl());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QString DeclarativeServiceAction::displayName() const
+{
+    return m_ServiceAction.displayName();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeServiceAction::setDisplayName(const QString &newDisplayName)
+{
+    m_ServiceAction = QServiceAction(m_ServiceAction.name(), newDisplayName, m_ServiceAction.iconUrl());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QString DeclarativeServiceAction::iconUrl() const
+{
+    return m_ServiceAction.iconUrl();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void DeclarativeServiceAction::setIconUrl(const QString &newIconUrl)
+{
+    m_ServiceAction = QServiceAction(m_ServiceAction.name(), m_ServiceAction.displayName(), newIconUrl);
+}
diff --git a/src/declarative/declarativeserviceaction_p.h b/src/declarative/declarativeserviceaction_p.h
new file mode 100644
index 0000000..aa07078
--- /dev/null
+++ b/src/declarative/declarativeserviceaction_p.h
@@ -0,0 +1,65 @@
+#ifndef DECLARATIVE_SERVICE_ACTION_P_INCLUDED
+#define DECLARATIVE_SERVICE_ACTION_P_INCLUDED
+
+#include "serviceaction.h"
+
+#include <QtDeclarative/qdeclarative.h>
+
+#include <QtCore/QObject>
+
+// ------------------------------------------------------------------------------------------------
+
+class DeclarativeServiceAction : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString name
+               READ name
+               WRITE setName)
+
+    Q_PROPERTY(QString displayName
+               READ displayName
+               WRITE setDisplayName)
+
+    Q_PROPERTY(QString iconUrl
+               READ iconUrl
+               WRITE setIconUrl)
+
+    Q_PROPERTY(bool isValid
+               READ isValid
+               STORED false)
+
+protected:
+    // We keep this destructor with its default value of 0 protected since only
+    // QDeclarativePrivate::QDeclarativeElement<T> needs it:
+    DeclarativeServiceAction(QObject *theParent = 0);
+
+public:
+    // We don't allow theParent to have a default value of 0 because in all
+    // likelyhood we want to force the caller to specify its QObject so the
+    // object will get destroyed in the caller's destructor:
+    DeclarativeServiceAction(const QServiceAction &other, QObject *theParent);
+
+    ~DeclarativeServiceAction();
+
+    Q_INVOKABLE void assign(DeclarativeServiceAction *other);
+    Q_INVOKABLE bool equals(DeclarativeServiceAction *other) const;
+
+    QServiceAction serviceAction() const;
+
+    bool isValid() const;
+
+    const QServiceActionName &name() const;
+    void setName(const QServiceActionName &newName);
+    QString displayName() const;
+    void setDisplayName(const QString &newDisplayName);
+    QString iconUrl() const;
+    void setIconUrl(const QString &newIconUrl);
+
+private:
+    QServiceAction m_ServiceAction;
+};
+
+QML_DECLARE_TYPE(DeclarativeServiceAction)
+
+#endif
diff --git a/src/declarative/qmldir b/src/declarative/qmldir
new file mode 100644
index 0000000..a8d4763
--- /dev/null
+++ b/src/declarative/qmldir
@@ -0,0 +1 @@
+plugin declarative_mimetypes
diff --git a/src/mimetypes/applicationfwd.h b/src/mimetypes/applicationfwd.h
new file mode 100644
index 0000000..7df1e93
--- /dev/null
+++ b/src/mimetypes/applicationfwd.h
@@ -0,0 +1,11 @@
+#ifndef APPLICATION_FWD_H_INCLUDED
+#define APPLICATION_FWD_H_INCLUDED
+
+class QString;
+
+// ------------------------------------------------------------------------------------------------
+
+// A temporary solution in case the type changes until the final release:
+typedef QString QApplicationId;
+
+#endif
diff --git a/src/mimetypes/mimetype.cpp b/src/mimetypes/mimetype.cpp
new file mode 100644
index 0000000..c2ab82a
--- /dev/null
+++ b/src/mimetypes/mimetype.cpp
@@ -0,0 +1,168 @@
+#include "mimetype.h"
+
+#include "mimetype_p.h"
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \typedef QMimeTypeName
+    \brief ID of MIME types, e.g. "text/plain" or "text/html"
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \class QMimeType
+    \brief QMimeType describes the behaviour and information about a specific MIME type.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeType::QMimeType()
+    \brief Initializes the attributes with default values that indicate an invalid MIME type.
+ */
+QMimeType::QMimeType() :
+        d_ptr(new QMimeTypePrivate(QMimeTypeName(), QString(), QString(), QList<QString>()))
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeType::QMimeType(const QMimeTypeName &theName,
+                             const QString &theDisplayName,
+                             const QString &theIconUrl,
+                             const QList<QString> &theFileExtentions);
+    \brief Initializes the attributes with the specified values.
+    \a theName The ID of the action
+    \a theDisplayName The description of the action to be displayed on user interfaces
+    \a theIconUrl The file name of an icon image that represents the action
+    \a theFileExtentions The file extentions that are known to contain data of the MIME type
+ */
+QMimeType::QMimeType(const QMimeTypeName &theName,
+                     const QString &theDisplayName,
+                     const QString &theIconUrl,
+                     const QList<QString> &theFileExtentions) :
+        d_ptr(new QMimeTypePrivate(theName, theDisplayName, theIconUrl, theFileExtentions))
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeType::QMimeType(const QMimeType &other);
+    \brief Initializes the attributes with the data of another MIME type.
+    \a other The other MIME type the data of which is copied
+ */
+QMimeType::QMimeType(const QMimeType &other) :
+        d_ptr(new QMimeTypePrivate(*other.d_ptr))
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn const QMimeType &QMimeType::operator=(const QMimeType &other);
+    \brief Assigns the data of another MIME type.
+    \a other The other action the data of which is assigned
+ */
+QMimeType &QMimeType::operator=(const QMimeType &other)
+{
+    *d_ptr = *other.d_ptr;
+
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeType::~QMimeType();
+    \brief Frees the d_ptr.
+ */
+QMimeType::~QMimeType()
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QMimeType::operator==(const QMimeType &other) const;
+    \brief Tests for equality with another MIME type
+    \a other The other MIME type that is to be compared with
+    Returns if the other MIME type not equal.
+ */
+bool QMimeType::operator==(const QMimeType &other) const
+{
+    return *d_ptr == *other.d_ptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QMimeType::operator!=(const QMimeType &other) const;
+    \brief Tests for non-equality with another MIME type
+    \a other The other MIME type that is to be compared with
+    Returns if the other MIME type is not equal.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QMimeType::isValid() const;
+    \brief Checks if the object contains a valid MIME type.
+    Returns the result of the check.
+ */
+bool QMimeType::isValid() const
+{
+    return !d_ptr->m_Name.isEmpty() &&
+           !d_ptr->m_DisplayName.isEmpty() &&
+           !d_ptr->m_IconUrl.isEmpty() &&
+           !d_ptr->m_FileExtentions.isEmpty();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn const QMimeTypeName &QMimeType::name() const;
+    \brief Returns the ID of the MIME type.
+ */
+const QMimeTypeName &QMimeType::name() const
+{
+    return d_ptr->m_Name;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QString QMimeType::displayName() const;
+    \brief Returns a description of the MIME type to be displayed on user interfaces.
+
+    The returned text is return in English language. For other languages it is the caller's
+    responsibility to get the text translated.
+ */
+const QString &QMimeType::displayName() const
+{
+    return d_ptr->m_DisplayName;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QString QMimeType::iconUrl() const;
+    \brief Returns the file name of an icon image that represents the MIME type.
+
+    Returns an empty string if no icon file has been specified during the registration of the
+    MIME type.
+ */
+const QString &QMimeType::iconUrl() const
+{
+    return d_ptr->m_IconUrl;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QString> QMimeType::fileExtentions() const;
+    \brief Returns the file extentions that are known to contain data of the MIME type.
+ */
+const QList<QString> &QMimeType::fileExtentions() const
+{
+    return d_ptr->m_FileExtentions;
+}
diff --git a/src/mimetypes/mimetype.h b/src/mimetypes/mimetype.h
new file mode 100644
index 0000000..eaa183f
--- /dev/null
+++ b/src/mimetypes/mimetype.h
@@ -0,0 +1,50 @@
+#ifndef MIME_TYPE_H_INCLUDED
+#define MIME_TYPE_H_INCLUDED
+
+#include <QtCore/QScopedPointer>
+
+class QMimeTypePrivate;
+
+class QString;
+
+template<typename T>
+class QList;
+
+// ------------------------------------------------------------------------------------------------
+
+// A temporary solution in case the type changes until the final release:
+typedef QString QMimeTypeName;
+
+// ------------------------------------------------------------------------------------------------
+
+class QMimeType
+{
+public:
+    QMimeType();
+    QMimeType(const QMimeTypeName &theName,
+              const QString &theDisplayName,
+              const QString &theIconUrl,
+              const QList<QString> &theFileExtentions);
+    QMimeType(const QMimeType &other);
+    QMimeType &operator=(const QMimeType &other);
+    ~QMimeType();
+
+    bool operator==(const QMimeType &other) const;
+
+    inline bool operator!=(const QMimeType &other) const
+    {
+        return !operator==(other);
+    }
+
+    bool isValid() const;
+
+    const QMimeTypeName &name() const;
+    const QString &displayName() const;
+    const QString &iconUrl() const;
+    const QList<QString> &fileExtentions() const;
+
+private:
+    QScopedPointer<QMimeTypePrivate> d_ptr;
+};
+
+#endif
diff --git a/src/mimetypes/mimetype_p.h b/src/mimetypes/mimetype_p.h
new file mode 100644
index 0000000..a7315ca
--- /dev/null
+++ b/src/mimetypes/mimetype_p.h
@@ -0,0 +1,37 @@
+#ifndef MIME_TYPE_P_H_INCLUDED
+#define MIME_TYPE_P_H_INCLUDED
+
+#include "mimetype.h"
+
+#include <QtCore/QList>
+#include <QtCore/QString>
+
+// ------------------------------------------------------------------------------------------------
+
+struct QMimeTypePrivate
+{
+    QMimeTypePrivate(const QMimeTypeName &theName,
+                     const QString &theDisplayName,
+                     const QString &theIconUrl,
+                     const QList<QString> &theFileExtentions) :
+            m_Name(theName),
+            m_DisplayName(theDisplayName),
+            m_IconUrl(theIconUrl),
+            m_FileExtentions(theFileExtentions)
+    {}
+
+    bool operator==(const QMimeTypePrivate &other) const
+    {
+        return m_Name == other.m_Name &&
+               m_DisplayName == other.m_DisplayName &&
+               m_IconUrl == other.m_IconUrl &&
+               m_FileExtentions == other.m_FileExtentions;
+    }
+
+    QMimeTypeName m_Name;
+    QString m_DisplayName;
+    QString m_IconUrl;
+    QList<QString> m_FileExtentions;
+};
+
+#endif
diff --git a/src/mimetypes/mimetyperegistry.cpp b/src/mimetypes/mimetyperegistry.cpp
new file mode 100644
index 0000000..49f1d43
--- /dev/null
+++ b/src/mimetypes/mimetyperegistry.cpp
@@ -0,0 +1,546 @@
+#include "mimetyperegistry.h"
+
+#include <QtCore/QByteArray>
+
+// ------------------------------------------------------------------------------------------------
+
+// title -> part -> chapter
+
+/*!
+    \page design
+    \title MIME type API for Qt
+
+    This is a draft of the MIME type API for Qt
+
+    \part Default handlers vs. user selection
+
+    #US001
+
+    \table
+        \header
+            \o {3, 1} text, audio, image, video file
+        \row
+            \o open
+            \o file
+        \row
+            \o edit
+            \o file
+        \row
+            \o share
+            \o file
+            \o => Pick an application (Picasa, Flickr, Facebook, Google+, Google Buzz, Twitter, TwitPic, YouTube, ...)
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} URL handling (Change wording)
+        \row
+            \o open
+            \o http URL
+            \o => Bookmark application
+        \row
+            \o open
+            \o tel:phone_number URL
+            \o => Contacts application
+        \row
+            \o open
+            \o Skype ID URL
+            \o => Contacts application
+        \row
+            \o open
+            \o Facebook User URL
+            \o => Contacts application
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} URL modifying (Change wording)
+        \row
+            \o edit
+            \o http URL
+            \o => Bookmark application
+        \row
+            \o edit
+            \o tel:phone_number URL
+            \o => Contacts application
+        \row
+            \o edit
+            \o Skype ID URL
+            \o => Contacts application or Profile editing
+        \row
+            \o edit
+            \o Facebook User URL
+            \o => Contacts application or Profile editing
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} URL sharing
+        \row
+            \o share
+            \o Any URL
+            \o => Pick an application
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} Not really an action but important anyways (Maybe later)
+        \row
+            \o textedit
+            \o http URL
+            \o <- TODO: Plugin for validation!!!
+        \row
+            \o textedit
+            \o tel:phone_number URL
+            \o <- TODO: Plugin for validation!!!
+        \row
+            \o textedit
+            \o Skype ID URL
+            \o <- TODO: Plugin for validation!!!
+        \row
+            \o textedit
+            \o Facebook User URL
+            \o <- TODO: Plugin for validation!!!
+    \endtable
+
+    #US004
+
+    \table
+        \header
+            \o {3, 1} Not really an action but important anyways (Maybe later)
+        \row
+            \o call
+            \o http URL
+            \o => Browser application #US005
+        \row
+            \o call
+            \o tel:phone_number URL
+            \o => Phone application
+        \row
+            \o call
+            \o Skype ID URL
+            \o => Skype application
+        \row
+            \o call
+            \o contact UUID vcard
+            \o => Address book application
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} UUID
+        \row
+            \o open
+            \o file
+        \row
+            \o edit
+            \o file
+        \row
+            \o share
+            \o file
+            \o => Pick an application (Picasa, Flickr, Facebook, Google+, Google Buzz, Twitter, TwitPic, YouTube, ...)
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} Messaging
+        \row
+            \o message
+            \o mailto:email_address
+            \o => E-Mail application
+        \row
+            \o message
+            \o tel:phone_number URL
+            \o => SMS application
+        \row
+            \o message
+            \o Twitter User URL
+            \o => Twitter application
+        \row
+            \o message
+            \o Facebook User URL
+            \o => Facebook application
+        \row
+            \o message
+            \o contact UUID vcard
+            \o => Address book application
+    \endtable
+
+    \table
+        \header
+            \o {3, 1} Chatting
+        \row
+            \o chat
+            \o Google Mail user URL
+            \o => E-Mail application
+        \row
+            \o chat
+            \o Skype user URL
+            \o => Twitter application
+        \row
+            \o chat
+            \o Facebook User URL
+            \o => Facebook application
+        \row
+            \o chat
+            \o contact UUID vcard
+            \o => Address book application
+    \endtable
+
+    Good actions for files seem to be open, edit and share.
+
+    Good actions for User identities and addresses and numbers seem to be directory, call, message and chat?
+
+    A good idea is to define a default action "" that represents open and not have an "open" action at all.
+
+    We might have to consult UI guidelines.
+
+    \list
+        \o tel open => phone app => selection between call and message
+        \o skype open => skype app => selection between call, video call, chat
+        \o FB open => FB app => chat, message
+    \endlist
+
+    Open questions:
+
+    \list
+        \o ProcessManager handles URLs, already???
+        \o ProcessManager handles default action, already???
+    \endlist
+
+    Check with Martin Zielinski!!!
+
+    We need a setter method for the default handler!!!
+    We need to be able to reset default handling. In that case the user needs to pick an application.
+
+    URL need to be parsed to determine the service:
+
+    \list
+        \o http:// * => *
+        \o http://www.facebook.com/ * => Facebook
+        \o http://www.dropbox.com/ * => Dropbox
+        \o http://www.nytimes.com/ * => NYT
+        \o http://www.youtube.com/ * => YouTube
+        \o http://www.ovi.com/ * => Ovi
+    \endlist
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \typedef QApplicationId
+    \brief ID of applications that provide service actions on MIME types
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \class QMimeTypeRegistry
+    \brief QMimeTypeRegistry is the data store that manages mime types, service actions and file extentions.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeTypeRegistry::QMimeTypeRegistry();
+    \brief Puts the injected implementation object into place.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeTypeRegistry::~QMimeTypeRegistry()
+    \brief Destroys the implementation object.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::insertMimeType (
+                                    const QMimeType &mimeType
+                                );
+    \brief Registers a new MIME type.
+
+    \a mimeType The MIME type object that is being registered
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QMimeTypeName> QMimeTypeRegistry::mimeTypes() const;
+    \brief Returns the list of registered MIME types.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeType QMimeTypeRegistry::findMimeType (
+                                         const QMimeTypeName &mimeTypeName
+                                     ) const;
+    \brief Searches for the specified MIME type.
+
+    \a mimeTypeName The MIME type ID for which we need to perform the search
+
+    Returns a 0 pointer if the specified MIME Type ID is not known.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::removeMimeType (
+                                    const QMimeTypeName &mimeTypeName
+                                );
+    \brief Deregisters a new MIME type.
+
+    \a mimeTypeName The MIME type ID that is being deregistered
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QString> QMimeTypeRegistry::fileExtentions() const;
+    \brief Returns a list of file extentions of all registered MIME types.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QString QMimeTypeRegistry::extractFileExtention (
+                                       const QString &fileName
+                                   ) const;
+    \brief Extracts the file extention from the specified file name.
+
+    \a fileName A file name of which we need to determine the extention.
+
+    Will only extract as deep into the file name as there are file extentions known currently.
+    E.g. "a.b.c.tar.gz" will result in ".tar.gz".
+
+    Returns an empty string if no knwn file extentipn coulb be extracted from the file name.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QMimeTypeName> QMimeTypeRegistry::findMimeTypes (
+                                                    const QString &fileExtention
+                                                ) const;
+    \brief Determines which MIME types use the specified file extention.
+
+    \a fileExtention The file extention for which we need to perform the search.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QMimeTypeName QMimeTypeRegistry::determineMimeType (
+                                             const QByteArray &data
+                                         ) const;
+    \brief Determines the MIME type of the data in the specified byte array.
+
+    \a data A byte array that contains the data.
+
+    Will return a default constructed QMimeTypeName if the MIME type could not be determined.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::insertServiceAction (
+                                    const QServiceAction &serviceAction
+                                );
+    \brief Registers a new service action.
+
+    This registration happens during the installation of an application.
+
+    \a serviceAction The service action object that is being registered.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+
+/*!
+    \fn QList<QServiceActionName> QMimeTypeRegistry::serviceActions() const;
+    \brief Returns the list of registered service actions.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QServiceAction QMimeTypeRegistry::findServiceAction (
+                                              const QServiceActionName &serviceActionName
+                                          );
+    \brief Searches for the specified service action.
+
+    \a serviceActionName The service action ID for which we need to perform the search.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::removeServiceAction (
+                                    const QServiceActionName &serviceActionName
+                                );
+    \brief Deregisters a service action.
+
+    This deregistration happens during the deinstallation of an application.
+
+    \a serviceActionName The ID of the service action object is being deregistered.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QMimeTypeRegistry::userAlwaysSelectsApplication (
+                                    const QServiceActionName &serviceActionName,
+                                    const QMimeTypeName &mimeTypeName
+                                ) const;
+    \brief Returns if the user is always presented with a selection dialog for the action on the specified MIME type.
+
+    \a serviceActionName Service action that the query is being performed on
+
+    \a mimeTypeName MIME type that the quere is being performed on
+
+    Always making the user choose the application for an action on a MIME type is for example
+    used for the share action where the user picks out the share application e.g. the Twitter
+    application that an item is supposed to be shared with. Another case is with image viewers
+    for which the user did not want to specify a default.
+
+    Returns false if there is only one application installed that is able to perform the
+    service action on the specified MIME type.
+
+    See also #US001, #US002.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::setUserAlwaysSelectsApplication (
+                                    const QServiceActionName &serviceActionName,
+                                    const QMimeTypeName &mimeTypeName,
+                                    const bool newSetting
+                                );
+    \brief Specifies if the user is always presented with a selection dialog for the action on the specified MIME type.
+
+    \a serviceActionName Service action to which the setting is to be applied on.
+
+    \a mimeTypeName MIME type to which the setting is to be applied on.
+
+    \a newSetting The new setting
+
+    Always making the user choose the application for an action on a MIME type is for example
+    used for the share action where the user picks out the share application e.g. the Twitter
+    application that an item is supposed to be shared with. Another case is with image viewers
+    for which the user did not want to specify a default.
+
+    During the start of an application it may check if it is the default handler for all of its
+    MIME types. If it is currently not the default handler the application may start a dialog
+    to offer itself as the default handler for its MIME types. If the user declines that UI
+    needs a check box to select if the application should remember that decision.
+
+    See also #US001, #US002.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::registerApplication (
+                                    const QApplicationId &applicationId,
+                                    const QServiceActionName &serviceActionName,
+                                    const QMimeTypeName &mimeTypeName
+                                );
+    \brief Registers an application's ability for a service action on a specific MIME type.
+
+    This registration happens during the installation of an application.
+
+    See also #US001, #US002, #US007, #US008
+
+    Also creates entries the MIME type list, the file extension list, the service action list and the flag if the user always selects the application.
+
+    \a applicationId The application ID for which we are trying to register
+
+    \a serviceActionName The ID of the service action we are trying to register
+
+    \a mimeTypeName The ID of the MIME type associated with the service action we are trying to register
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::increaseApplicationPreference (
+                                    const QApplicationId &applicationId,
+                                    const QServiceActionName &serviceActionName,
+                                    const QMimeTypeName &mimeTypeName
+                                );
+    \brief Increases the application's preference to handle a service action on a specific MIME type.
+
+    \a applicationId The application ID for which we are trying to increase the preference
+
+    \a serviceActionName The ID of the service action we are trying to increase the preference
+
+    \a mimeTypeName The ID of the MIME type associated with the service action we are trying to increase the preference
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::decreaseApplicationPreference (
+                                    const QApplicationId &applicationId,
+                                    const QServiceActionName &serviceActionName,
+                                    const QMimeTypeName &mimeTypeName
+                                );
+    \brief Decreases the application's preference to handle a service action on a specific MIME type.
+
+    \a applicationId The application ID for which we are trying to decrease the preference
+
+    \a serviceActionName The ID of the service action we are trying to decrease the preference
+
+    \a mimeTypeName The ID of the MIME type associated with the service action we are trying to decrease the preference
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn void QMimeTypeRegistry::unregisterApplication (
+                                    const QApplicationId &applicationId
+                                );
+    \brief Unregisters all application's abilities for service actions on all MIME types.
+
+    \a applicationId The application ID for which we are trying to unregister
+
+    Also cleans up the MIME type list, the file extension list, the service action list and the flag if the user always selects the application.
+
+    See also #US007
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QPair<QApplicationId, QServiceActionName> > QMimeTypeRegistry::findApplications (
+                                                                                 const QMimeTypeName &mimeTypeName
+                                                                             ) const;
+    \brief Searches which applications can handle the specified MIME type and what actions they can perform on it.
+
+    \a mimeTypeName The MIME type ID for which we need to perform the search.
+
+    The order in which the applications are returned reflects the user's preference.
+
+    #US006, #US008, #US011, #US012
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QList<QApplicationId> QMimeTypeRegistry::findApplications (
+                                                     const QServiceActionName &serviceActionName,
+                                                     const QMimeTypeName &mimeTypeName
+                                                 ) const;
+    \brief Searches which applications can handle an acton on the specified MIME type.
+
+    \a serviceActionName The service action for which we need to perform the search.
+
+    \a mimeTypeName The MIME type ID for which we need to perform the search.
+
+    The order in which the applications are returned reflects the user's preference.
+
+    See also #US004, #US005, #US008, #US009, #US010
+ */
diff --git a/src/mimetypes/mimetyperegistry.h b/src/mimetypes/mimetyperegistry.h
new file mode 100644
index 0000000..9300d4a
--- /dev/null
+++ b/src/mimetypes/mimetyperegistry.h
@@ -0,0 +1,126 @@
+#ifndef MIMETYPES_H_INCLUDED
+#define MIMETYPES_H_INCLUDED
+
+#include "applicationfwd.h"
+#include "mimetype.h"
+#include "serviceaction.h"
+
+#include <QtCore/QList>
+#include <QtCore/QPair>
+
+class QMimeTypeRegistryPrivate;
+
+class QByteArray;
+
+// ------------------------------------------------------------------------------------------------
+
+class QMimeTypeRegistry
+{
+public:
+    QMimeTypeRegistry();
+
+    ~QMimeTypeRegistry();
+
+    // --------------------------------------------------------------------------------------------
+
+    void insertMimeType (
+             const QMimeType &mimeType
+         );
+
+    QList<QMimeTypeName> mimeTypes() const;
+
+    QMimeType findMimeType (
+                  const QMimeTypeName &mimeTypeName
+              ) const;
+
+    void removeMimeType (
+             const QMimeTypeName &mimeTypeName
+         );
+
+    // --------------------------------------------------------------------------------------------
+
+    QList<QString> fileExtentions() const;
+
+    QString extractFileExtention (
+                 const QString &fileName
+            ) const;
+
+    QList<QMimeTypeName> findMimeTypes (
+                             const QString &fileExtention
+                         ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+    QMimeTypeName determineMimeType (
+                      const QByteArray &data
+                  ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+    void insertServiceAction (
+             const QServiceAction &serviceAction
+         );
+
+    QList<QServiceActionName> serviceActions() const;
+
+    QServiceAction findServiceAction (
+                       const QServiceActionName &serviceActionName
+                   );
+
+    void removeServiceAction (
+             const QServiceActionName &serviceActionName
+         );
+
+    // --------------------------------------------------------------------------------------------
+
+    bool userAlwaysSelectsApplication (
+             const QServiceActionName &serviceActionName,
+             const QMimeTypeName &mimeTypeName
+         ) const;
+
+    void setUserAlwaysSelectsApplication (
+             const QServiceActionName &serviceActionName,
+             const QMimeTypeName &mimeTypeName,
+             const bool newSetting
+         );
+
+    // --------------------------------------------------------------------------------------------
+
+    void registerApplication (
+             const QApplicationId &applicationId,
+             const QServiceActionName &serviceActionName,
+             const QMimeTypeName &mimeTypeName
+         );
+
+    void increaseApplicationPreference (
+             const QApplicationId &applicationId,
+             const QServiceActionName &serviceActionName,
+             const QMimeTypeName &mimeTypeName
+         );
+
+    void decreaseApplicationPreference (
+             const QApplicationId &applicationId,
+             const QServiceActionName &serviceActionName,
+             const QMimeTypeName &mimeTypeName
+         );
+
+    void unregisterApplication (
+             const QApplicationId &applicationId
+         );
+
+    QList<QPair<QApplicationId, QServiceActionName> > findApplications (
+                                                          const QMimeTypeName &mimeTypeName
+                                                      ) const;
+
+    QList<QApplicationId> findApplications (
+                              const QServiceActionName &serviceActionName,
+                              const QMimeTypeName &mimeTypeName
+                          ) const;
+
+    // --------------------------------------------------------------------------------------------
+
+private:
+    QMimeTypeRegistryPrivate *d_ptr;
+};
+
+#endif
diff --git a/src/mimetypes/mimetyperegistry_empty.cpp b/src/mimetypes/mimetyperegistry_empty.cpp
new file mode 100644
index 0000000..1ed8902
--- /dev/null
+++ b/src/mimetypes/mimetyperegistry_empty.cpp
@@ -0,0 +1,253 @@
+#include "mimetyperegistry.h"
+
+#include <QtCore/QFuture>
+
+// ------------------------------------------------------------------------------------------------
+
+class QMimeTypeRegistryPrivate
+{};
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeTypeRegistry::QMimeTypeRegistry() :
+        d_ptr(new QMimeTypeRegistryPrivate())
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeTypeRegistry::~QMimeTypeRegistry()
+{
+    delete d_ptr; d_ptr = 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::insertMimeType (
+                            const QMimeType &mimeType
+                        )
+{
+    Q_UNUSED(mimeType)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QMimeTypeName> QMimeTypeRegistry::mimeTypes() const
+{
+    typedef QList<QMimeTypeName> Result;
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeType QMimeTypeRegistry::findMimeType (
+                                 const QMimeTypeName &searchQMimeTypeName
+                             ) const
+{
+    typedef QMimeType Result;
+
+    Q_UNUSED(searchQMimeTypeName)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::removeMimeType (
+                            const QMimeTypeName &mimeTypeName
+                        )
+{
+    Q_UNUSED(mimeTypeName)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QString> QMimeTypeRegistry::fileExtentions() const
+{
+    typedef QList<QString> Result;
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QString QMimeTypeRegistry::extractFileExtention (
+                               const QString &fileName
+                           ) const
+{
+    Q_UNUSED(fileName)
+
+    return QString();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QMimeTypeName> QMimeTypeRegistry::findMimeTypes (
+                                            const QString &searchFileExtention
+                                        ) const
+{
+    typedef QList<QMimeTypeName> Result;
+
+    Q_UNUSED(searchFileExtention)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QMimeTypeName QMimeTypeRegistry::determineMimeType (
+                                     const QByteArray &data
+                                 ) const
+{
+    typedef QMimeTypeName Result;
+
+    Q_UNUSED(data)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::insertServiceAction (
+                            const QServiceAction &serviceAction
+                        )
+{
+    Q_UNUSED(serviceAction)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QServiceActionName> QMimeTypeRegistry::serviceActions() const
+{
+    typedef QList<QServiceActionName> Result;
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QServiceAction QMimeTypeRegistry::findServiceAction (
+                                      const QServiceActionName &searchQServiceActionName
+                                  )
+{
+    typedef QServiceAction Result;
+
+    Q_UNUSED(searchQServiceActionName)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::removeServiceAction (
+                            const QServiceActionName &serviceActionName
+                        )
+{
+    Q_UNUSED(serviceActionName)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+bool QMimeTypeRegistry::userAlwaysSelectsApplication (
+                            const QServiceActionName &serviceActionName,
+                            const QMimeTypeName &mimeTypeName
+                        ) const
+{
+    typedef bool Result;
+
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::setUserAlwaysSelectsApplication (
+                            const QServiceActionName &serviceActionName,
+                            const QMimeTypeName &mimeTypeName,
+                            const bool newSetting
+                        )
+{
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+    Q_UNUSED(newSetting)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::registerApplication (
+                            const QApplicationId &applicationId,
+                            const QServiceActionName &serviceActionName,
+                            const QMimeTypeName &mimeTypeName
+                        )
+{
+    Q_UNUSED(applicationId)
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::increaseApplicationPreference (
+                            const QApplicationId &applicationId,
+                            const QServiceActionName &serviceActionName,
+                            const QMimeTypeName &mimeTypeName
+                        )
+{
+    Q_UNUSED(applicationId)
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::decreaseApplicationPreference (
+                            const QApplicationId &applicationId,
+                            const QServiceActionName &serviceActionName,
+                            const QMimeTypeName &mimeTypeName
+                        )
+{
+    Q_UNUSED(applicationId)
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void QMimeTypeRegistry::unregisterApplication (
+                            const QApplicationId &applicationId
+                        )
+{
+    Q_UNUSED(applicationId)
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QPair<QApplicationId, QServiceActionName> >
+    QMimeTypeRegistry::findApplications (
+                           const QMimeTypeName &mimeTypeName
+                       ) const
+{
+    typedef QList<QPair<QApplicationId, QServiceActionName> > Result;
+
+    Q_UNUSED(mimeTypeName)
+
+    return Result();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+QList<QApplicationId>
+    QMimeTypeRegistry::findApplications (
+                           const QServiceActionName &serviceActionName,
+                           const QMimeTypeName &mimeTypeName
+                       ) const
+{
+    typedef QList<QApplicationId> Result;
+
+    Q_UNUSED(serviceActionName)
+    Q_UNUSED(mimeTypeName)
+
+    return Result();
+}
diff --git a/src/mimetypes/mimetypes.pro b/src/mimetypes/mimetypes.pro
new file mode 100644
index 0000000..814fd0c
--- /dev/null
+++ b/src/mimetypes/mimetypes.pro
@@ -0,0 +1,33 @@
+CONFIG   += qt
+TEMPLATE = lib
+TARGET   = qt-mimetypes
+DESTDIR  = ../../lib
+
+# QtCore/qlist.h uses /usr/include/limits.h which uses does not compile with -pedantic.
+#MAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi -pedantic -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+QMAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi           -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+
+# dependency management
+QMAKE_CXXFLAGS += -MMD
+include_dependencies.target = include_dependencies
+include_dependencies.commands = @if grep \"^include \\*.d\" Makefile >/dev/null 2>&1; then echo \"Dependency files are already included.\"; else echo \"include *.d\" >> Makefile; echo \"Please rerun make because dependency files will be included next time.\"; fi
+QMAKE_EXTRA_TARGETS += include_dependencies
+POST_TARGETDEPS += include_dependencies
+
+
+API_DIR = ../..
+
+INCLUDEPATH += $$API_DIR
+
+
+SOURCES += $$API_DIR/src/mimetypes/mimetype.cpp \
+           $$API_DIR/src/mimetypes/mimetyperegistry.cpp \
+           mimetyperegistry_empty.cpp \
+           $$API_DIR/src/mimetypes/serviceaction.cpp
+
+HEADERS += $$API_DIR/src/mimetypes/applicationfwd.h \
+           $$API_DIR/src/mimetypes/mimetype.h \
+           $$API_DIR/src/mimetypes/mimetype_p.h \
+           $$API_DIR/src/mimetypes/mimetyperegistry.h \
+           $$API_DIR/src/mimetypes/serviceaction.h \
+           $$API_DIR/src/mimetypes/serviceaction_p.h
diff --git a/src/mimetypes/serviceaction.cpp b/src/mimetypes/serviceaction.cpp
new file mode 100644
index 0000000..821d965
--- /dev/null
+++ b/src/mimetypes/serviceaction.cpp
@@ -0,0 +1,156 @@
+#include "serviceaction.h"
+
+#include "serviceaction_p.h"
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \typedef QServiceActionName
+    \brief ID of service actions on MIME types, e.g. "open", "edit", "share", "call", "message"
+
+    A service action that is supposed to be applied on a specified MIME type, e.g. "view", "edit", "share-facebook". The default action ("") corrsponds to view and play.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \class QServiceAction
+    \brief QServiceAction describes the behaviour and information about a specific action on a MIME type.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QServiceAction::QServiceAction();
+    \brief Initializes the attributes with default values that indicate an invalid service action.
+ */
+QServiceAction::QServiceAction() :
+        d_ptr(new QServiceActionPrivate(QServiceActionName(), QString(), QString()))
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QServiceAction::QServiceAction(const QServiceActionName &theName,
+                                     const QString &theDisplayName,
+                                     const QString &theIconUrl);
+    \brief Initializes the attributes with the specified values
+    \a theName The ID of the action
+    \a theDisplayName The description of the action to be displayed on user interfaces
+    \a theIconUrl The file name of an icon image that represents the action
+ */
+QServiceAction::QServiceAction(const QServiceActionName &theName,
+                             const QString &theDisplayName,
+                             const QString &theIconUrl) :
+        d_ptr(new QServiceActionPrivate(theName, theDisplayName, theIconUrl))
+{
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QServiceAction::QServiceAction(const QServiceAction &other);
+    \brief Initializes the attributes with the data of another action.
+    \a other The other action the data of which is copied
+ */
+QServiceAction::QServiceAction(const QServiceAction &other) :
+        d_ptr(new QServiceActionPrivate(*other.d_ptr))
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn const QServiceAction &QServiceAction::operator=(const QServiceAction &other);
+    \brief Assigns the data of another action.
+    \a other The other action the data of which is assigned
+ */
+QServiceAction &QServiceAction::operator=(const QServiceAction &other)
+{
+    *d_ptr = *other.d_ptr;
+
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QServiceAction::~QServiceAction();
+    \brief Frees the d_ptr.
+ */
+QServiceAction::~QServiceAction()
+{}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QServiceAction::operator==(const QServiceAction &other) const;
+    \brief Tests for equality with another action
+    \a other The other action that is to be compared with
+    Returns if the other action is equal.
+ */
+bool QServiceAction::operator==(const QServiceAction &other) const
+{
+    return *d_ptr == *other.d_ptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QServiceAction::operator!=(const QServiceAction &other) const;
+    \brief Tests for non-equality with another action
+    \a other The other action that is to be compared with
+    Returns if the other action is not equal.
+ */
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn bool QServiceAction::isValid() const;
+    \brief Checks if the object contains a valid action.
+    Returns the result of the check.
+ */
+bool QServiceAction::isValid() const
+{
+    return !d_ptr->m_Name.isEmpty() &&
+           !d_ptr->m_Text.isEmpty() &&
+           !d_ptr->m_IconUrl.isEmpty();
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn const QServiceActionName &QServiceAction::name() const;
+    \brief Returns the ID of the action.
+ */
+const QServiceActionName &QServiceAction::name() const
+{
+    return d_ptr->m_Name;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QString QServiceAction::displayName() const
+    \brief Returns a description of the action to be displayed on user interfaces.
+
+    The returned text is return in English language. For other languages it is the caller's
+    responsibility to get the text translated.
+ */
+QString QServiceAction::displayName() const
+{
+    return d_ptr->m_Text;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/*!
+    \fn QString QServiceAction::iconUrl() const;
+    \brief Returns the file name of an icon image that represents the action.
+
+    Returns an empty string if no icon file has been specified during the registration of the
+    action.
+ */
+QString QServiceAction::iconUrl() const
+{
+    return d_ptr->m_IconUrl;
+}
diff --git a/src/mimetypes/serviceaction.h b/src/mimetypes/serviceaction.h
new file mode 100644
index 0000000..5fa2e3a
--- /dev/null
+++ b/src/mimetypes/serviceaction.h
@@ -0,0 +1,45 @@
+#ifndef SERVICE_ACTION_H_INCLUDED
+#define SERVICE_ACTION_H_INCLUDED
+
+#include <QtCore/QScopedPointer>
+
+class QServiceActionPrivate;
+
+class QString;
+
+// ------------------------------------------------------------------------------------------------
+
+// A temporary solution in case the type changes until the final release:
+typedef QString QServiceActionName;
+
+// ------------------------------------------------------------------------------------------------
+
+class QServiceAction
+{
+public:
+    QServiceAction();
+    QServiceAction(const QServiceActionName &theName,
+                   const QString &theDisplayName,
+                   const QString &theIconUrl);
+    QServiceAction(const QServiceAction &other);
+    QServiceAction &operator=(const QServiceAction &other);
+    ~QServiceAction();
+
+    bool operator==(const QServiceAction &other) const;
+
+    inline bool operator!=(const QServiceAction &other) const
+    {
+        return !operator==(other);
+    }
+
+    bool isValid() const;
+
+    const QServiceActionName &name() const;
+    QString displayName() const;
+    QString iconUrl() const;
+
+private:
+    QScopedPointer<QServiceActionPrivate> d_ptr;
+};
+
+#endif
diff --git a/src/mimetypes/serviceaction_p.h b/src/mimetypes/serviceaction_p.h
new file mode 100644
index 0000000..d5d0dba
--- /dev/null
+++ b/src/mimetypes/serviceaction_p.h
@@ -0,0 +1,32 @@
+#ifndef SERVICE_ACTION_P_H_INCLUDED
+#define SERVICE_ACTION_P_H_INCLUDED
+
+#include "serviceaction.h"
+
+#include <QtCore/QString>
+
+// ------------------------------------------------------------------------------------------------
+
+struct QServiceActionPrivate
+{
+    QServiceActionPrivate(const QServiceActionName &theName,
+                          const QString &theDisplayName,
+                          const QString &theIconUrl) :
+            m_Name(theName),
+            m_Text(theDisplayName),
+            m_IconUrl(theIconUrl)
+    {}
+
+    bool operator==(const QServiceActionPrivate &other) const
+    {
+        return m_Name == other.m_Name &&
+               m_Text == other.m_Text &&
+               m_IconUrl == other.m_IconUrl;
+    }
+
+    QServiceActionName m_Name;
+    QString m_Text;
+    QString m_IconUrl;
+};
+
+#endif
diff --git a/src/src.pro b/src/src.pro
new file mode 100644
index 0000000..753ecef
--- /dev/null
+++ b/src/src.pro
@@ -0,0 +1,3 @@
+TEMPLATE = subdirs
+CONFIG += ordered
+SUBDIRS += mimetypes declarative
diff --git a/unittests/declarative/tst_declarative_mimetypes.cpp b/unittests/declarative/tst_declarative_mimetypes.cpp
new file mode 100644
index 0000000..c8930a8
--- /dev/null
+++ b/unittests/declarative/tst_declarative_mimetypes.cpp
@@ -0,0 +1,3 @@
+#include <QtQuickTest/quicktest.h>
+
+QUICK_TEST_MAIN(mytest)
diff --git a/unittests/declarative/tst_declarative_mimetypes.pro b/unittests/declarative/tst_declarative_mimetypes.pro
new file mode 100644
index 0000000..45cbc0a
--- /dev/null
+++ b/unittests/declarative/tst_declarative_mimetypes.pro
@@ -0,0 +1,18 @@
+TEMPLATE=app
+TARGET=tst_declarative_mimetypes
+CONFIG += warn_on qmltestcase
+
+# runtime environment
+LIBS += -L ../../lib -lqt-mimetypes
+
+
+API_DIR = ../..
+
+INCLUDEPATH += $$API_DIR
+
+
+SOURCES += $$API_DIR/unittests/declarative/tst_declarative_mimetypes.cpp
+
+
+# this reads the QML files from the same directory as this pro file
+DEFINES += QUICK_TEST_SOURCE_DIR=\"\\\"$$PWD\\\"\"
diff --git a/unittests/declarative/tst_declarative_mimetypes.qml b/unittests/declarative/tst_declarative_mimetypes.qml
new file mode 100644
index 0000000..81d1654
--- /dev/null
+++ b/unittests/declarative/tst_declarative_mimetypes.qml
@@ -0,0 +1,464 @@
+import Qt 4.7
+import QtTest 1.0
+import com.nokia.MimeTypes 1.0
+
+TestCase {
+    name: "tst_declarative_mimetypes"
+
+    function pngMimeTypeName() {
+        return "image/png"
+    }
+
+    function pngMimeTypeDisplayName() {
+        return "PNG File";
+    }
+
+    function pngMimeTypeIconUrl() {
+        return "/usr/share/icons/oxygen/64x64/mimetypes/image-x-generic.png"
+    }
+
+    function firstPngMimeTypeFileExtention() {
+        return ".png"
+    }
+
+    MimeType {
+        id: instantiatedPngMimeType
+        name: pngMimeTypeName()
+        displayName: pngMimeTypeDisplayName()
+        iconUrl: pngMimeTypeIconUrl()
+        fileExtentions: [ firstPngMimeTypeFileExtention() ]
+    }
+
+    MimeType {
+        id: otherPngMimeType
+    }
+
+    MimeType {
+        id: defaultMimeType
+    }
+
+    function test_MimeType_isValid() {
+        compare(instantiatedPngMimeType.isValid, true)
+
+        otherPngMimeType.assign(instantiatedPngMimeType)
+
+        compare(otherPngMimeType.isValid, true)
+        compare(instantiatedPngMimeType.equals(otherPngMimeType), true)
+        compare(otherPngMimeType.equals(instantiatedPngMimeType), true)
+
+        compare(defaultMimeType.isValid, false)
+    }
+
+    function test_MimeType_name() {
+        otherPngMimeType.assign(instantiatedPngMimeType)
+        otherPngMimeType.name = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedPngMimeType.name, pngMimeTypeName())
+
+        compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
+    }
+
+    function test_MimeType_displayName() {
+        otherPngMimeType.assign(instantiatedPngMimeType)
+        otherPngMimeType.displayName = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedPngMimeType.displayName, pngMimeTypeDisplayName())
+
+        compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
+    }
+
+    function test_MimeType_iconUrl() {
+        otherPngMimeType.assign(instantiatedPngMimeType)
+        otherPngMimeType.iconUrl = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedPngMimeType.iconUrl, pngMimeTypeIconUrl())
+
+        compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
+    }
+
+    function test_MimeType_fileExtentions() {
+        otherPngMimeType.assign(instantiatedPngMimeType)
+        otherPngMimeType.fileExtentions = []
+        compare(otherPngMimeType.fileExtentions.length, 0)
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedPngMimeType.fileExtentions.length, 1)
+        compare(instantiatedPngMimeType.fileExtentions[0], ".png")
+
+        compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
+    }
+
+    function editServiceActionName() {
+        return "edit";
+    }
+
+    function editServiceActionDisplayName() {
+        return "Edit"
+    }
+
+    function editServiceActionIconUrl() {
+        return "/dev/null"
+    }
+
+    ServiceAction {
+        id: instantiatedEditServiceAction
+        name: editServiceActionName()
+        displayName: editServiceActionDisplayName()
+        iconUrl: editServiceActionIconUrl()
+    }
+
+    ServiceAction {
+        id: otherEditServiceAction
+    }
+
+    ServiceAction {
+        id: defaultServiceAction
+    }
+
+    function test_ServiceAction_isValid() {
+        compare(instantiatedEditServiceAction.isValid, true)
+
+        otherEditServiceAction.assign(instantiatedEditServiceAction)
+
+        compare(otherEditServiceAction.isValid, true)
+        compare(instantiatedEditServiceAction.equals(otherEditServiceAction), true)
+        compare(otherEditServiceAction.equals(instantiatedEditServiceAction), true)
+
+        compare(defaultServiceAction.isValid, false)
+    }
+
+    function test_ServiceAction_name() {
+        otherEditServiceAction.assign(instantiatedEditServiceAction)
+        otherEditServiceAction.name = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedEditServiceAction.name, editServiceActionName())
+
+        compare(instantiatedEditServiceAction.equals(otherEditServiceAction), false)
+    }
+
+    function test_ServiceAction_displayName() {
+        otherEditServiceAction.assign(instantiatedEditServiceAction)
+        otherEditServiceAction.displayName = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedEditServiceAction.displayName, editServiceActionDisplayName())
+
+        compare(instantiatedEditServiceAction.equals(otherEditServiceAction), false)
+    }
+
+    function test_ServiceAction_iconUrl() {
+        otherEditServiceAction.assign(instantiatedEditServiceAction)
+        otherEditServiceAction.iconUrl = ""
+
+        // Verify that the Id is part of the equality test:
+        compare(instantiatedEditServiceAction.iconUrl, editServiceActionIconUrl())
+
+        compare(instantiatedEditServiceAction.equals(otherEditServiceAction), false)
+    }
+
+    MimeTypeRegistry {
+        id: mimeTypeRegistry
+    }
+
+    function test_MimeTypeRegistry_mimeTypes() {
+        {
+            var resultOfMimeTypes = mimeTypeRegistry.mimeTypes
+
+            for (var mimeTypeNameIx = 0; mimeTypeNameIx < resultOfMimeTypes.length; ++mimeTypeNameIx) {
+                //print(mimeTypeNameIx + ": " + resultOfMimeTypes[mimeTypeNameIx])
+                mimeTypeRegistry.removeMimeType(resultOfMimeTypes[mimeTypeNameIx])
+            }
+
+            resultOfMimeTypes = mimeTypeRegistry.mimeTypes
+            compare(resultOfMimeTypes.length, 0)
+        }
+
+        {
+            // create
+            mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+            var resultOfMimeTypes = mimeTypeRegistry.mimeTypes
+
+            compare(resultOfMimeTypes.length, 1)
+            compare(resultOfMimeTypes[0], pngMimeTypeName())
+        }
+
+        {
+            // update
+            mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+            var resultOfMimeTypes = mimeTypeRegistry.mimeTypes
+
+            compare(resultOfMimeTypes.length, 1)
+            compare(resultOfMimeTypes[0], pngMimeTypeName())
+        }
+
+        {
+            mimeTypeRegistry.removeMimeType(pngMimeTypeName())
+
+            var resultOfMimeTypes = mimeTypeRegistry.mimeTypes
+
+            compare(resultOfMimeTypes.length, 0)
+        }
+    }
+
+    function test_MimeTypeRegistry_findMimeType() {
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        var resultOfFindMimeType = mimeTypeRegistry.findMimeType(pngMimeTypeName())
+
+        compare(resultOfFindMimeType.isValid, true)
+        compare(resultOfFindMimeType.equals(instantiatedPngMimeType), true)
+    }
+
+    function test_MimeTypeRegistry_fileExtentions() {
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        var resultOfFileExtentions = mimeTypeRegistry.fileExtentions
+
+        compare(resultOfFileExtentions.length, 1)
+        compare(resultOfFileExtentions[0], firstPngMimeTypeFileExtention())
+    }
+
+    function test_MimeTypeRegistry_extractFileExtention() {
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        var pngFileName = 'image' + firstPngMimeTypeFileExtention()
+
+        var resultOfExtractFileExtention = mimeTypeRegistry.extractFileExtention(pngFileName)
+
+        compare(resultOfExtractFileExtention, firstPngMimeTypeFileExtention())
+    }
+
+    function test_MimeTypeRegistry_findMimeTypes() {
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        var resultOfFindMimeTypes = mimeTypeRegistry.findMimeTypes(firstPngMimeTypeFileExtention())
+
+        compare(resultOfFindMimeTypes.length, 1)
+        compare(resultOfFindMimeTypes[0], pngMimeTypeName())
+    }
+
+    function test_MimeTypeRegistry_determineMimeType() {
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        // TODO Implement test_MimeTypeRegistry_determineMimeType()
+        compare('Not implemented!', '')
+    }
+
+    function test_MimeTypeRegistry_serviceActions() {
+        {
+            var resultOfServiceActions = mimeTypeRegistry.serviceActions;
+
+            for (var serviceActionNameIx = 0; serviceActionNameIx < resultOfServiceActions.length; ++serviceActionNameIx) {
+                //print(serviceActionNameIx + ": " + resultOfServiceActions[serviceActionNameIx])
+                mimeTypeRegistry.removeServiceAction(resultOfServiceActions[serviceActionNameIx])
+            }
+
+            resultOfServiceActions = mimeTypeRegistry.serviceActions
+            compare(resultOfServiceActions.length, 0)
+        }
+
+        {
+            // create
+            mimeTypeRegistry.insertServiceAction(instantiatedEditServiceAction)
+
+            var resultOfServiceActions = mimeTypeRegistry.serviceActions
+
+            compare(resultOfServiceActions.length, 1)
+            compare(resultOfServiceActions[0], editServiceActionName())
+        }
+
+        {
+            // update
+            mimeTypeRegistry.insertServiceAction(instantiatedEditServiceAction)
+
+            var resultOfServiceActions = mimeTypeRegistry.serviceActions
+
+            compare(resultOfServiceActions.length, 1)
+            compare(resultOfServiceActions[0], editServiceActionName())
+        }
+
+        {
+            mimeTypeRegistry.removeServiceAction(editServiceActionName())
+
+            var resultOfServiceActions = mimeTypeRegistry.serviceActions
+
+            compare(resultOfServiceActions.length, 0)
+        }
+    }
+
+    function test_MimeTypeRegistry_findServiceAction() {
+        mimeTypeRegistry.insertServiceAction(instantiatedEditServiceAction)
+
+        var resultOfFindServiceAction = mimeTypeRegistry.findServiceAction(editServiceActionName())
+
+        compare(resultOfFindServiceAction.isValid, true)
+        compare(resultOfFindServiceAction.equals(instantiatedEditServiceAction), true)
+    }
+
+    function test_MimeTypeRegistry_setUserAlwaysSelectsApplication() {
+        mimeTypeRegistry.insertServiceAction(instantiatedEditServiceAction)
+
+        mimeTypeRegistry.setUserAlwaysSelectsApplication (
+                             editServiceActionName(), pngMimeTypeName(), true
+                         )
+
+        compare(mimeTypeRegistry.userAlwaysSelectsApplication(editServiceActionName(), pngMimeTypeName()), true)
+
+        mimeTypeRegistry.setUserAlwaysSelectsApplication (
+                             editServiceActionName(), pngMimeTypeName(), false
+                         )
+
+        compare(!mimeTypeRegistry.userAlwaysSelectsApplication(editServiceActionName(), pngMimeTypeName()), true)
+    }
+
+    function shareOnPicasaWebAlbumsName() { return 'shareOnPicasaWebAlbums' }
+    function shareOnPicasaWebAlbumsDisplayName() { return 'Share on Picasa Web Albums' }
+    function shareOnPicasaWebAlbumsIconUrl() { return '/dev/null' }
+
+    ServiceAction {
+        id: shareOnPicasaWebAlbumsServiceAction
+        name: shareOnPicasaWebAlbumsName()
+        displayName: shareOnPicasaWebAlbumsDisplayName()
+        iconUrl: shareOnPicasaWebAlbumsIconUrl()
+    }
+
+    function test_MimeTypeRegistry_findApplications() {
+        mimeTypeRegistry.insertServiceAction(instantiatedEditServiceAction)
+        mimeTypeRegistry.insertServiceAction(shareOnPicasaWebAlbumsServiceAction)
+        mimeTypeRegistry.insertMimeType(instantiatedPngMimeType)
+
+        var gwenviewApplicationId = 'gwenview'
+        var showimgApplicationId = 'showimg'
+
+        {
+            var resultOfFindApplications = mimeTypeRegistry.findApplications(pngMimeTypeName())
+            for (var ix = 0; ix < resultOfFindApplications.length; ++ix) {
+                if (resultOfFindApplications[ix].length != 2) {
+                    print("Error: resultOfFindApplications[" + ix + "].length: " + resultOfFindApplications[ix].length)
+                    continue
+                }
+
+                //print("application: " + resultOfFindApplications[ix][0] + ", action: " + resultOfFindApplications[ix][1])
+                mimeTypeRegistry.unregisterApplication(resultOfFindApplications[ix][0])
+            }
+            resultOfFindApplications = mimeTypeRegistry.findApplications(pngMimeTypeName())
+            compare(resultOfFindApplications.length, 0)
+        }
+
+        mimeTypeRegistry.registerApplication(gwenviewApplicationId, editServiceActionName(), pngMimeTypeName())
+
+        var resultOfFindApplications1 = mimeTypeRegistry.findApplications(pngMimeTypeName())
+
+        compare(resultOfFindApplications1.length, 1)
+        compare(resultOfFindApplications1[0][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[0][1], editServiceActionName())
+
+        var resultOfFindApplications2 = mimeTypeRegistry.findApplications(editServiceActionName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+
+        // ----------------------------------------------------------------------------------------
+
+        mimeTypeRegistry.registerApplication(gwenviewApplicationId, shareOnPicasaWebAlbumsName(), pngMimeTypeName())
+
+        resultOfFindApplications1 = mimeTypeRegistry.findApplications(pngMimeTypeName())
+
+        compare(resultOfFindApplications1.length, 2)
+        compare(resultOfFindApplications1[0][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[0][1], editServiceActionName())
+        compare(resultOfFindApplications1[1][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[1][1], shareOnPicasaWebAlbumsName())
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(editServiceActionName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(shareOnPicasaWebAlbumsName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+
+        // ----------------------------------------------------------------------------------------
+
+        mimeTypeRegistry.registerApplication(showimgApplicationId, editServiceActionName(), pngMimeTypeName())
+
+        resultOfFindApplications1 = mimeTypeRegistry.findApplications(pngMimeTypeName())
+
+        compare(resultOfFindApplications1.length, 3)
+        compare(resultOfFindApplications1[0][0], showimgApplicationId)
+        compare(resultOfFindApplications1[0][1], editServiceActionName())   // edit is before share
+        compare(resultOfFindApplications1[1][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[1][1], shareOnPicasaWebAlbumsName())
+        compare(resultOfFindApplications1[2][0], gwenviewApplicationId)    // priority #2
+        compare(resultOfFindApplications1[2][1], editServiceActionName())
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(editServiceActionName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 2)
+        compare(resultOfFindApplications2[0], showimgApplicationId)
+        compare(resultOfFindApplications2[1], gwenviewApplicationId)
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(shareOnPicasaWebAlbumsName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+
+        // ----------------------------------------------------------------------------------------
+
+        mimeTypeRegistry.increaseApplicationPreference(gwenviewApplicationId, editServiceActionName(), pngMimeTypeName())
+
+        resultOfFindApplications1 = mimeTypeRegistry.findApplications(pngMimeTypeName())
+
+        compare(resultOfFindApplications1.length, 3)
+        compare(resultOfFindApplications1[0][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[0][1], editServiceActionName())
+        compare(resultOfFindApplications1[1][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[1][1], shareOnPicasaWebAlbumsName())
+        compare(resultOfFindApplications1[2][0], showimgApplicationId)
+        compare(resultOfFindApplications1[2][1], editServiceActionName())
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(editServiceActionName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 2)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+        compare(resultOfFindApplications2[1], showimgApplicationId)
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(shareOnPicasaWebAlbumsName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+
+        // ----------------------------------------------------------------------------------------
+
+        mimeTypeRegistry.decreaseApplicationPreference(gwenviewApplicationId, editServiceActionName(), pngMimeTypeName())
+
+        resultOfFindApplications1 = mimeTypeRegistry.findApplications(pngMimeTypeName())
+
+        compare(resultOfFindApplications1.length, 3)
+        compare(resultOfFindApplications1[0][0], showimgApplicationId)
+        compare(resultOfFindApplications1[0][1], editServiceActionName())   // edit is before share
+        compare(resultOfFindApplications1[1][0], gwenviewApplicationId)
+        compare(resultOfFindApplications1[1][1], shareOnPicasaWebAlbumsName())
+        compare(resultOfFindApplications1[2][0], gwenviewApplicationId)    // priority #2
+        compare(resultOfFindApplications1[2][1], editServiceActionName())
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(editServiceActionName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 2)
+        compare(resultOfFindApplications2[0], showimgApplicationId)
+        compare(resultOfFindApplications2[1], gwenviewApplicationId)
+
+        resultOfFindApplications2 = mimeTypeRegistry.findApplications(shareOnPicasaWebAlbumsName(), pngMimeTypeName())
+
+        compare(resultOfFindApplications2.length, 1)
+        compare(resultOfFindApplications2[0], gwenviewApplicationId)
+    }
+}
diff --git a/unittests/tst_mimetypes-empty.cpp b/unittests/tst_mimetypes-empty.cpp
new file mode 100644
index 0000000..a184fc4
--- /dev/null
+++ b/unittests/tst_mimetypes-empty.cpp
@@ -0,0 +1,655 @@
+#include "tst_mimetypes.h"
+
+#include "mimetyperegistry.h"
+
+#include <QtTest/QtTest>
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::initTestCase()
+{
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QMimeTypeName &pngMimeTypeName()
+{
+    static const QMimeTypeName result ("image/png");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QString &pngMimeTypeDisplayName()
+{
+    static const QString result ("PNG File");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QString &pngMimeTypeIconUrl()
+{
+    static const QString result ("/usr/share/icons/oxygen/64x64/mimetypes/image-x-generic.png");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static QList<QString> buildPngMimeTypeFileExtentions()
+{
+    QList<QString> result;
+    result << ".png";
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QList<QString> &pngMimeTypeFileExtentions()
+{
+    static const QList<QString> result (buildPngMimeTypeFileExtentions());
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeType_isValid()
+{
+    QMimeType instantiatedPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    QVERIFY(instantiatedPngMimeType.isValid());
+
+    QMimeType otherPngMimeType (instantiatedPngMimeType);
+
+    QVERIFY(otherPngMimeType.isValid());
+    QCOMPARE(instantiatedPngMimeType, otherPngMimeType);
+
+    QMimeType defaultMimeType;
+
+    QVERIFY(!defaultMimeType.isValid());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeType_name()
+{
+    QMimeType instantiatedPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    QMimeType otherPngMimeType (
+                  QMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    // Verify that the Id is part of the equality test:
+    QCOMPARE(instantiatedPngMimeType.name(), pngMimeTypeName());
+
+    QVERIFY(instantiatedPngMimeType != otherPngMimeType);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeType_displayName()
+{
+    QMimeType instantiatedPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    QMimeType otherPngMimeType (
+                  pngMimeTypeName(), QString(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    // Verify that the IconUrl is part of the equality test:
+    QCOMPARE(instantiatedPngMimeType.iconUrl(), pngMimeTypeIconUrl());
+
+    QVERIFY(instantiatedPngMimeType != otherPngMimeType);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeType_iconUrl()
+{
+    QMimeType instantiatedPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    QMimeType otherPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), QString(), pngMimeTypeFileExtentions()
+              );
+
+    // Verify that the IconUrl is part of the equality test:
+    QCOMPARE(instantiatedPngMimeType.iconUrl(), pngMimeTypeIconUrl());
+
+    QVERIFY(instantiatedPngMimeType != otherPngMimeType);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeType_fileExtentions()
+{
+    QMimeType instantiatedPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+              );
+
+    QMimeType otherPngMimeType (
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), QList<QString>()
+              );
+
+    // Verify that the FileExtentions are part of the equality test:
+    QCOMPARE(instantiatedPngMimeType.fileExtentions(), pngMimeTypeFileExtentions());
+
+    QVERIFY(instantiatedPngMimeType != otherPngMimeType);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QServiceActionName &editServiceActionName()
+{
+    static const QServiceActionName result ("edit");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QString &editServiceActionDisplayName()
+{
+    static const QString result ("Edit");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static const QString &editServiceActionIconUrl()
+{
+    static const QString result ("/dev/null");
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QServiceAction_isValid()
+{
+    QServiceAction instantiatedServiceAction (
+                       editServiceActionName(), editServiceActionDisplayName(), editServiceActionIconUrl()
+                   );
+
+    QVERIFY(instantiatedServiceAction.isValid());
+
+    QServiceAction otherPngServiceAction (instantiatedServiceAction);
+
+    QVERIFY(otherPngServiceAction.isValid());
+    QCOMPARE(instantiatedServiceAction, otherPngServiceAction);
+
+    QServiceAction defaultServiceAction;
+
+    QVERIFY(!defaultServiceAction.isValid());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QServiceAction_name()
+{
+    QServiceAction instantiatedServiceAction (
+                       editServiceActionName(), editServiceActionDisplayName(), editServiceActionIconUrl()
+                   );
+
+    QServiceAction otherServiceAction (
+                       QServiceActionName(), editServiceActionDisplayName(), editServiceActionIconUrl()
+                   );
+
+    // Verify that the Id is part of the equality test:
+    QCOMPARE(instantiatedServiceAction.name(), editServiceActionName());
+
+    QVERIFY(instantiatedServiceAction != otherServiceAction);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QServiceAction_displayName()
+{
+    QServiceAction instantiatedServiceAction (
+                       editServiceActionName(), editServiceActionDisplayName(), editServiceActionIconUrl()
+                   );
+
+    QServiceAction otherServiceAction (
+                       editServiceActionName(), QString(), editServiceActionIconUrl()
+                   );
+
+    // Verify that the DisplayName is part of the equality test:
+    QCOMPARE(instantiatedServiceAction.displayName(), editServiceActionDisplayName());
+
+    QVERIFY(instantiatedServiceAction != otherServiceAction);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QServiceAction_iconUrl()
+{
+    QServiceAction instantiatedServiceAction (
+                       editServiceActionName(), editServiceActionDisplayName(), editServiceActionIconUrl()
+                   );
+
+    QServiceAction otherServiceAction (
+                       editServiceActionName(), editServiceActionDisplayName(), QString()
+                   );
+
+    // Verify that the IconUrl is part of the equality test:
+    QCOMPARE(instantiatedServiceAction.iconUrl(), editServiceActionIconUrl());
+
+    QVERIFY(instantiatedServiceAction != otherServiceAction);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QMimeType &pngMimeType()
+{
+    static const QMimeType result (
+                               pngMimeTypeName(),
+                               pngMimeTypeDisplayName(),
+                               pngMimeTypeIconUrl(),
+                               pngMimeTypeFileExtentions()
+                           );
+    return result;
+}
+
+void tst_mimetypes::test_QMimeTypeRegistry_mimeTypes()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    {
+        QList<QMimeTypeName> resultOfMimeTypes (mimeTypeRegistry->mimeTypes());
+
+        foreach (const QMimeTypeName &mimeTypeName, resultOfMimeTypes) {
+            mimeTypeRegistry->removeMimeType(mimeTypeName);
+        }
+
+        resultOfMimeTypes = mimeTypeRegistry->mimeTypes();
+        QCOMPARE(resultOfMimeTypes.length(), 0);
+    }
+
+    {
+        // create
+        mimeTypeRegistry->insertMimeType(pngMimeType());
+
+        QList<QMimeTypeName> resultOfMimeTypes (mimeTypeRegistry->mimeTypes());
+
+        QCOMPARE(resultOfMimeTypes.length(), 1);
+        QCOMPARE(resultOfMimeTypes.front(), pngMimeTypeName());
+    }
+
+    {
+        // update
+        mimeTypeRegistry->insertMimeType(pngMimeType());
+
+        QList<QMimeTypeName> resultOfMimeTypes (mimeTypeRegistry->mimeTypes());
+
+        QCOMPARE(resultOfMimeTypes.length(), 1);
+        QCOMPARE(resultOfMimeTypes.front(), pngMimeTypeName());
+    }
+
+    {
+        mimeTypeRegistry->removeMimeType(pngMimeTypeName());
+
+        QList<QMimeTypeName> resultOfMimeTypes (mimeTypeRegistry->mimeTypes());
+
+        QCOMPARE(resultOfMimeTypes.length(), 0);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_findMimeType()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    QMimeType resultOfFindMimeType (
+                  mimeTypeRegistry->findMimeType(pngMimeTypeName())
+              );
+
+    QVERIFY(resultOfFindMimeType.isValid());
+    QCOMPARE(resultOfFindMimeType, pngMimeType());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_fileExtentions()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    const QList<QString> resultOfFileExtentions (mimeTypeRegistry->fileExtentions());
+
+    QCOMPARE(resultOfFileExtentions.length(), pngMimeTypeFileExtentions().length());
+    QCOMPARE(resultOfFileExtentions.front(), pngMimeTypeFileExtentions().front());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_extractFileExtention()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    QVERIFY(!pngMimeTypeFileExtentions().isEmpty());
+    const QString pngFileName ("image" + pngMimeTypeFileExtentions().front());
+
+    const QString resultOfExtractFileExtention (
+                      mimeTypeRegistry->extractFileExtention(pngFileName)
+                  );
+
+    QCOMPARE(resultOfExtractFileExtention, pngMimeTypeFileExtentions().front());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_findMimeTypes()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    QVERIFY(!pngMimeTypeFileExtentions().isEmpty());
+    QList<QMimeTypeName> resultOfFindMimeTypes (
+                             mimeTypeRegistry->findMimeTypes(pngMimeTypeFileExtentions().front())
+                         );
+
+    QCOMPARE(resultOfFindMimeTypes.length(), 1);
+    QCOMPARE(resultOfFindMimeTypes.front(), pngMimeTypeName());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_determineMimeType()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    /// @todo Implement test_QMimeTypeRegistry_determineMimeType()
+    QCOMPARE("Not implemented!", "");
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const QServiceAction &editServiceAction()
+{
+    static const QServiceAction result (
+                                    editServiceActionName(),
+                                    editServiceActionDisplayName(),
+                                    editServiceActionIconUrl()
+                                );
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_serviceActions()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    {
+        QList<QServiceActionName> resultOfServiceActions (mimeTypeRegistry->serviceActions());
+
+        foreach (const QServiceActionName &serviceActionName, resultOfServiceActions) {
+            mimeTypeRegistry->removeServiceAction(serviceActionName);
+        }
+
+        resultOfServiceActions = mimeTypeRegistry->serviceActions();
+        QCOMPARE(resultOfServiceActions.length(), 0);
+    }
+
+    {
+        // create
+        mimeTypeRegistry->insertServiceAction(editServiceAction());
+
+        QList<QServiceActionName> resultOfServiceActions (mimeTypeRegistry->serviceActions());
+
+        QCOMPARE(resultOfServiceActions.length(), 1);
+        QCOMPARE(resultOfServiceActions.front(), editServiceActionName());
+    }
+
+    {
+        // update
+        mimeTypeRegistry->insertServiceAction(editServiceAction());
+
+        QList<QServiceActionName> resultOfServiceActions (mimeTypeRegistry->serviceActions());
+
+        QCOMPARE(resultOfServiceActions.length(), 1);
+        QCOMPARE(resultOfServiceActions.front(), editServiceActionName());
+    }
+
+    {
+        mimeTypeRegistry->removeServiceAction(editServiceActionName());
+
+        QList<QServiceActionName> resultOfServiceActions (mimeTypeRegistry->serviceActions());
+
+        QCOMPARE(resultOfServiceActions.length(), 0);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_findServiceAction()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertServiceAction(editServiceAction());
+
+    QServiceAction resultOfFindServiceAction (
+                       mimeTypeRegistry->findServiceAction(editServiceActionName())
+                   );
+
+    QVERIFY(resultOfFindServiceAction.isValid());
+    QCOMPARE(resultOfFindServiceAction, editServiceAction());
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_setUserAlwaysSelectsApplication()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertServiceAction(editServiceAction());
+
+    mimeTypeRegistry->setUserAlwaysSelectsApplication (
+                          editServiceActionName(), pngMimeTypeName(), true
+                      );
+
+    QVERIFY (
+        mimeTypeRegistry->userAlwaysSelectsApplication(editServiceActionName(), pngMimeTypeName())
+    );
+
+    mimeTypeRegistry->setUserAlwaysSelectsApplication (
+                          editServiceActionName(), pngMimeTypeName(), false
+                      );
+
+    QVERIFY (
+        !mimeTypeRegistry->userAlwaysSelectsApplication(editServiceActionName(), pngMimeTypeName())
+    );
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void tst_mimetypes::test_QMimeTypeRegistry_findApplications()
+{
+    QScopedPointer<QMimeTypeRegistry> mimeTypeRegistry (new QMimeTypeRegistry());
+
+    mimeTypeRegistry->insertServiceAction(editServiceAction());
+
+    const QServiceActionName shareOnPicasaWebAlbumsName ("shareOnPicasaWebAlbums");
+    const QString shareOnPicasaWebAlbumsDisplayName ("Share on Picasa Web Albums");
+    const QString shareOnPicasaWebAlbumsIconUrl ("/dev/null");
+
+    mimeTypeRegistry->insertServiceAction (
+                          QServiceAction (
+                              shareOnPicasaWebAlbumsName,
+                              shareOnPicasaWebAlbumsDisplayName,
+                              shareOnPicasaWebAlbumsIconUrl
+                          )
+                      );
+
+    mimeTypeRegistry->insertMimeType(pngMimeType());
+
+    const QApplicationId gwenviewApplicationId ("gwenview");
+    const QApplicationId showimgApplicationId ("showimg");
+
+    // --------------------------------------------------------------------------------------------
+
+    {
+        QList<QPair<QApplicationId, QServiceActionName> >
+            resultOfFindApplications (mimeTypeRegistry->findApplications(pngMimeTypeName()));
+        typedef QPair<QApplicationId, QServiceActionName> Pair;
+        foreach (const Pair &pair, resultOfFindApplications) {
+            mimeTypeRegistry->unregisterApplication(pair.first);
+        }
+        resultOfFindApplications = mimeTypeRegistry->findApplications(pngMimeTypeName());
+        QCOMPARE(resultOfFindApplications.length(), 0);
+    }
+
+    mimeTypeRegistry->registerApplication (
+                          gwenviewApplicationId, editServiceActionName(), pngMimeTypeName()
+                      );
+
+    QList<QPair<QApplicationId, QServiceActionName> >
+        resultOfFindApplications1 (mimeTypeRegistry->findApplications(pngMimeTypeName()));
+
+    QCOMPARE(resultOfFindApplications1.length(), 1);
+    QCOMPARE(resultOfFindApplications1[0].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[0].second, editServiceActionName());
+
+    QList<QApplicationId>
+        resultOfFindApplications2 (
+            mimeTypeRegistry->findApplications(editServiceActionName(), pngMimeTypeName())
+        );
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+
+    // --------------------------------------------------------------------------------------------
+
+    mimeTypeRegistry->registerApplication (
+                          gwenviewApplicationId, shareOnPicasaWebAlbumsName, pngMimeTypeName()
+                      );
+
+    resultOfFindApplications1 = mimeTypeRegistry->findApplications(pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications1.length(), 2);
+    QCOMPARE(resultOfFindApplications1[0].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[0].second, editServiceActionName());
+    QCOMPARE(resultOfFindApplications1[1].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[1].second, shareOnPicasaWebAlbumsName);
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(editServiceActionName(), pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(shareOnPicasaWebAlbumsName, pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+
+    // --------------------------------------------------------------------------------------------
+
+    mimeTypeRegistry->registerApplication (
+                          showimgApplicationId, editServiceActionName(), pngMimeTypeName()
+                      );
+
+    resultOfFindApplications1 = mimeTypeRegistry->findApplications(pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications1.length(), 3);
+    QCOMPARE(resultOfFindApplications1[0].first, showimgApplicationId);
+    QCOMPARE(resultOfFindApplications1[0].second, editServiceActionName());   // edit is before share
+    QCOMPARE(resultOfFindApplications1[1].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[1].second, shareOnPicasaWebAlbumsName);
+    QCOMPARE(resultOfFindApplications1[2].first, gwenviewApplicationId);    // priority #2
+    QCOMPARE(resultOfFindApplications1[2].second, editServiceActionName());
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(editServiceActionName(), pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 2);
+    QCOMPARE(resultOfFindApplications2[0], showimgApplicationId);
+    QCOMPARE(resultOfFindApplications2[1], gwenviewApplicationId);
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(shareOnPicasaWebAlbumsName, pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+
+    // --------------------------------------------------------------------------------------------
+
+    mimeTypeRegistry->increaseApplicationPreference (
+                          gwenviewApplicationId, editServiceActionName(), pngMimeTypeName()
+                      );
+
+    resultOfFindApplications1 = mimeTypeRegistry->findApplications(pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications1.length(), 3);
+    QCOMPARE(resultOfFindApplications1[0].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[0].second, editServiceActionName());
+    QCOMPARE(resultOfFindApplications1[1].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[1].second, shareOnPicasaWebAlbumsName);
+    QCOMPARE(resultOfFindApplications1[2].first, showimgApplicationId);
+    QCOMPARE(resultOfFindApplications1[2].second, editServiceActionName());
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(editServiceActionName(), pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 2);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications2[1], showimgApplicationId);
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(shareOnPicasaWebAlbumsName, pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+
+    // --------------------------------------------------------------------------------------------
+
+    mimeTypeRegistry->decreaseApplicationPreference (
+                          gwenviewApplicationId, editServiceActionName(), pngMimeTypeName()
+                      );
+
+    resultOfFindApplications1 = mimeTypeRegistry->findApplications(pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications1.length(), 3);
+    QCOMPARE(resultOfFindApplications1[0].first, showimgApplicationId);
+    QCOMPARE(resultOfFindApplications1[0].second, editServiceActionName());   // edit is before share
+    QCOMPARE(resultOfFindApplications1[1].first, gwenviewApplicationId);
+    QCOMPARE(resultOfFindApplications1[1].second, shareOnPicasaWebAlbumsName);
+    QCOMPARE(resultOfFindApplications1[2].first, gwenviewApplicationId);    // priority #2
+    QCOMPARE(resultOfFindApplications1[2].second, editServiceActionName());
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(editServiceActionName(), pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 2);
+    QCOMPARE(resultOfFindApplications2[0], showimgApplicationId);
+    QCOMPARE(resultOfFindApplications2[1], gwenviewApplicationId);
+
+    resultOfFindApplications2 =
+        mimeTypeRegistry->findApplications(shareOnPicasaWebAlbumsName, pngMimeTypeName());
+
+    QCOMPARE(resultOfFindApplications2.length(), 1);
+    QCOMPARE(resultOfFindApplications2[0], gwenviewApplicationId);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication app(argc, argv);
+    tst_mimetypes tc;
+    return QTest::qExec(&tc, argc, argv);
+}
diff --git a/unittests/tst_mimetypes.h b/unittests/tst_mimetypes.h
new file mode 100644
index 0000000..695f10d
--- /dev/null
+++ b/unittests/tst_mimetypes.h
@@ -0,0 +1,36 @@
+#ifndef TST_MIMETYPES_H_INCLUDED
+#define TST_MIMETYPES_H_INCLUDED
+
+#include <QtCore/QObject>
+
+class tst_mimetypes : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase();
+
+    void test_QMimeType_isValid();
+    void test_QMimeType_name();
+    void test_QMimeType_displayName();
+    void test_QMimeType_iconUrl();
+    void test_QMimeType_fileExtentions();
+
+    void test_QServiceAction_isValid();
+    void test_QServiceAction_name();
+    void test_QServiceAction_displayName();
+    void test_QServiceAction_iconUrl();
+
+    void test_QMimeTypeRegistry_mimeTypes();
+    void test_QMimeTypeRegistry_findMimeType();
+    void test_QMimeTypeRegistry_fileExtentions();
+    void test_QMimeTypeRegistry_extractFileExtention();
+    void test_QMimeTypeRegistry_findMimeTypes();
+    void test_QMimeTypeRegistry_determineMimeType();
+    void test_QMimeTypeRegistry_serviceActions();
+    void test_QMimeTypeRegistry_findServiceAction();
+    void test_QMimeTypeRegistry_setUserAlwaysSelectsApplication();
+    void test_QMimeTypeRegistry_findApplications();
+};
+
+#endif
diff --git a/unittests/unittests.pro b/unittests/unittests.pro
new file mode 100644
index 0000000..88a7ac7
--- /dev/null
+++ b/unittests/unittests.pro
@@ -0,0 +1,31 @@
+CONFIG   += qtestlib
+TEMPLATE = app
+TARGET   = tst_mimetypes
+DEPENDPATH += .
+
+QMAKE_CXXFLAGS += -W -Wall -Wextra -Werror -ansi -pedantic -Wshadow -Wno-long-long -Wnon-virtual-dtor -Wc++0x-compat
+
+# dependency management
+QMAKE_CXXFLAGS += -MMD
+include_dependencies.target = include_dependencies
+include_dependencies.commands = @if grep \"^include \\*.d\" Makefile >/dev/null 2>&1; then echo \"Dependency files are already included.\"; else echo \"include *.d\" >> Makefile; echo \"Please rerun make because dependency files will be included next time.\"; fi
+QMAKE_EXTRA_TARGETS += include_dependencies
+POST_TARGETDEPS += include_dependencies
+
+# runtime environment
+LIBS += -L ../lib -lqt-mimetypes
+
+
+API_DIR = ..
+
+INCLUDEPATH += $$API_DIR/src/mimetypes $$API_DIR/unittests
+
+
+SOURCES += tst_mimetypes-empty.cpp
+
+HEADERS += $$API_DIR/unittests/tst_mimetypes.h
+
+
+QMAKE_EXTRA_TARGETS += check
+check.depends = $$TARGET
+check.commands = ./$$TARGET -xunitxml -o unitTestResults.xml