diff --git a/CMakeLists.txt b/CMakeLists.txt
index d418656..7a4b1a8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,100 +1,102 @@
 project( klook )
 cmake_minimum_required( VERSION 3.5.1 FATAL_ERROR )
 set (QT_MIN_VERSION "5.9.0")
 set (KF5_MIN_VERSION "5.35.0") # TODO: find an appropriate version
 
 
 find_package(ECM ${KF5_MIN_VERSION} REQUIRED CONFIG)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations") # Yeah, everything is deprecated, we know
 
 include(FeatureSummary)
 include(ECMAddAppIcon)
 include(ECMInstallIcons)
 include(KDEInstallDirs)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
 
 kde_enable_exceptions() # We actually use/handle exceptions
 
 find_package( Qt5 ${QT_MIN_VERSION}  NO_MODULE REQUIRED Core Gui Quick Qml)
 
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     KDELibs4Support
     KIO
     Parts
     Declarative
     Plasma
+    DBusAddons
 )
 
 find_package(Phonon4Qt5 REQUIRED)
 
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
 
 add_subdirectory( icons )
 
 set(EXIV2_MIN_VERSION "0.19")
 find_package(Exiv2)
 
 set( QRC_RESOURCES src/resources.qrc )
 
 file( GLOB qml_files "${CMAKE_CURRENT_SOURCE_DIR}/src/qml/*.qml" )
 
 set( klook_SRCS src/main.cpp
                 src/declarativeviewer.cpp
                 src/video.cpp
                 src/text.cpp
                 src/file.cpp
                 src/listitem.cpp
                 src/previewgenerator.cpp
                 src/previewprovider.cpp
                 src/filemodel.cpp
                 src/klookapp.cpp
                 src/audio.cpp
                 src/mimeprovider.cpp
                 src/kpartsdeclarativeitem.cpp
                 src/kpartswidget.cpp
                 src/listitemcontent.cpp
                 src/exifimageprovider.cpp
                 src/rotatedimage.cpp
                 ${qml_files} )
 
 #set_source_files_properties(src/rotatedimage.cpp PROPERTIES COMPILE_FLAGS ${KDE4_ENABLE_EXCEPTIONS})
 
 file(GLOB ICON_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/icons/hi*-apps-klook.png" )
 ecm_add_app_icon(klook_SRCS ICONS ${ICON_SRCS})
 
 add_executable( klook ${klook_SRCS} ${QRC_SOURCES} )
 
 target_include_directories(klook SYSTEM PUBLIC ${PHONON_INCLUDE_DIR})
 
 target_link_libraries(klook KF5::KIOCore KF5::KIOFileWidgets KF5::KIOWidgets KF5::KIONTLM
                             ${EXIV2_LIBRARIES}
                             KF5::Plasma
                             ${PHONON_LIBRARY}
                             KF5::Parts
                             KF5::Declarative
                             KF5::KDELibs4Support
+                            KF5::DBusAddons
                             Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick
                      )
 
 
 install( TARGETS klook ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 install( FILES ${qml_files} DESTINATION ${DATA_INSTALL_DIR}/${PROJECT_NAME}/ )
 
 install( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/qml/images/
                  DESTINATION ${DATA_INSTALL_DIR}/${PROJECT_NAME}/images )
 
 #FIX AT SOME OTHER POINT IN TIME
 #Translations
 #if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/locale)
   #find_package( Msgfmt REQUIRED )
   #find_package( Gettext REQUIRED )
   #add_subdirectory( locale )
 #endif()
 
diff --git a/src/declarativeviewer.cpp b/src/declarativeviewer.cpp
index e0904c1..257ff4c 100644
--- a/src/declarativeviewer.cpp
+++ b/src/declarativeviewer.cpp
@@ -1,742 +1,743 @@
 /* KLook
  * Copyright (c) 2011-2012 ROSA  <support@rosalab.ru>
  * Authors: Julia Mineeva, Evgeniy Auzhin, Sergey Borovkov.
  * License: GPLv3
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as
  *   published by the Free Software Foundation; either version 3,
  *   or (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "declarativeviewer.h"
 
 #include "audio.h"
 #include "exifimageprovider.h"
 #include "file.h"
 #include "filemodel.h"
 #include "kpartsdeclarativeitem.h"
 #include "kpartswidget.h"
 #include "listitem.h"
 #include "mimeprovider.h"
 #include "previewgenerator.h"
 #include "previewprovider.h"
 #include "text.h"
 #include "video.h"
 
 #include <QtCore/QTimer>
 #include <QtDBus/QDBusInterface>
 #include <QtDBus/QDBusReply>
 #include <QtGui/QAbstractTextDocumentLayout>
 #include <QApplication>
+#include <QGuiApplication>
 #include <QDesktopWidget>
 #include <QtGui/QImageReader>
 #include <QtGui/QTextDocument>
 #include <QtQml/QQmlContext>
 
 #include <KDeclarative/KDeclarative>
 #include <KMimeTypeTrader>
 #include <KWindowSystem>
 
 static int header_height = 27;
 static int border_width = 2;
 static int height_offset = 27;
 static int arrowIconWidth = 29;
 static int arrowIconHeight = 16;
 
 static int min_width = 600;
 static int min_height = 427;
 
 DeclarativeViewer::DeclarativeViewer(QWindow* parent)
     : QQuickView(parent)
     , m_lastMousePosition(0, 0)
     , m_isSingleMode(true)
     , m_moving(false)
     , m_resize(false)
     , m_isEmbedded(false)
     , m_isGallery(false)
     , m_currentFile(0)
     , m_region(FRAME_REGION)
 {
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.initialize();
     kdeclarative.setupBindings();
 
     engine()->addImageProvider("preview", new PreviewProvider);
     engine()->addImageProvider("mime", new MimeProvider);
     engine()->addImageProvider("exif", new ExifImageProvider);
 
     setResizeMode(QQuickView::SizeRootObjectToView);
 
     //setMinimumSize(min_width, min_height); TODO: fixme
 
     m_fileModel = new FileModel(this);
     m_fileModel->setRoleNames(ListItem::roleNames());
 
     PreviewGenerator::instance()->setModel(m_fileModel);
 
     registerTypes();
 
     //setWindowFlags(Qt::WindowStaysOnTopHint | Qt::CustomizeWindowHint | Qt::FramelessWindowHint); FIXME
 
     //setAttribute(Qt::WA_TranslucentBackground); FIXME
     //setStyleSheet("background:transparent;"); FIXME
 
-    connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), SLOT(focusChanged(QWidget*, QWidget*)));
-    connect(engine(), SIGNAL(quit()), qApp, SLOT(quit()));
+    connect(qApp, &QApplication::focusChanged, this, &DeclarativeViewer::focusChanged);
+    connect(engine(), &QQmlEngine::quit, qApp, &QApplication::quit);
 }
 
 DeclarativeViewer::~DeclarativeViewer()
 {
     delete PreviewGenerator::instance();
 }
 
 void DeclarativeViewer::init(QStringList urls, bool embedded, const QRect& rc, int indexToShow)
 {
     if(!urls.size()) {
         qDebug() << "No files to display. Closing...";
         qApp->exit();
         return;
     }
 
     rootContext()->setContextProperty("indexToShow", indexToShow);
 
     initModel(urls);
 
     m_rcIcon = rc;
 
     setViewMode(urls.count() > 1 ? Multi : Single);
     rootContext()->setContextProperty("embedded", m_isEmbedded);
     setEmbedded(embedded);
 
     m_currentFile = m_fileModel->file(indexToShow);
 
     KWindowSystem::setState(winId(), NET::SkipTaskbar);
 
     if(!isVisible())
         QTimer::singleShot(200, this, SLOT(showWindow()));
 
     emit setStartWindow();
 }
 
 void DeclarativeViewer::registerTypes()
 {
     qmlRegisterType<Video>("Widgets", 1, 0, "Video");
     qmlRegisterType<Audio>("Widgets", 1, 0, "Audio");
     qmlRegisterType<MyText>("Widgets", 1, 0, "PlainText");
     qmlRegisterType<KPartsDeclarativeItem>("Widgets", 1, 0, "KPart");
 
     qmlRegisterUncreatableType<File>("Widgets", 1, 0, "File", "This type is registered only for its enums"); // to use File::FileType enum
     QQmlContext* context = engine()->rootContext();
     context->setContextProperty("fileModel", m_fileModel);
     context->setContextProperty("mainWidget",  this);
     context->setContextProperty("viewMode", "single");
     context->setContextProperty("embedded", m_isEmbedded);
     context->setContextProperty("embeddedLayout", "null");
     context->setContextProperty("previewGenerator", PreviewGenerator::instance());
     context->setContextProperty("arrowX", .0);
     context->setContextProperty("arrowY", .0);
 }
 
 void DeclarativeViewer::setFullScreen()
 {
     if (m_isGallery && windowState() != Qt::WindowFullScreen) {
         showFullScreen();
         emit setFullScreenState();
         return;
     }
 
     QSize preferredSize;
     File::FileType type = m_currentFile->type();
 
     if (type != File::Progress) {
         if (m_currentFile->url().isLocalFile()) {
             preferredSize = getPreferredSize(m_currentFile->url().toLocalFile(), type);
         }
         else if(m_currentFile->isLoaded()) {
             // file is remote but it is already downloaded
             preferredSize = getPreferredSize(m_currentFile->tempFilePath(), m_currentFile->type());
         }
     }
     else {
         preferredSize = QSize();
     }
 
     // this is necessary for following comparisons to geometry
     if(!preferredSize.isValid() || (preferredSize.width() < minimumSize().width())
             || preferredSize.height() < minimumSize().height()){
         preferredSize = minimumSize();
     }
 
     if (windowState() != Qt::WindowFullScreen) {
         showNormal();
         centerWidget(preferredSize);
         return;
     }
 
     if (geometry().size() == preferredSize) {
         showFullScreen();
         emit setFullScreenState();
     }
     else {
         centerWidget(preferredSize);
     }
 }
 
 QSize DeclarativeViewer::getPreferredSize(const QString &path, int type) const
 {
     //TODO: use virtual functions for this
     if (type == File::Video) {
         QHash<int, QSize>::const_iterator it = m_videoSizeHints.constFind(m_fileModel->rowFromFile(m_currentFile));
         if(it != m_videoSizeHints.constEnd()) {
             QDesktopWidget dw;
             QSize sz = calculateViewSize(it.value(), dw.screenGeometry(/*FIXME: was this*/));
 
             // + margins values in windowed mode
             sz.setWidth(sz.width() + (m_isEmbedded ? 0 : 6)) ;
             sz.setHeight(sz.height() + (m_isEmbedded ? 0 : height_offset +4));
             return sz;
         }
         return QSize();
     }
     else if (type == File::Image) {
         QImageReader imgReader(path);
         QDesktopWidget dw;
         QSize sz = calculateViewSize(imgReader.size(), dw.screenGeometry(/*FIXME: was this*/));
         sz.setWidth(sz.width() + (m_isEmbedded ? 0 : 6)) ;
         sz.setHeight(sz.height() + (m_isEmbedded ? 0 : height_offset +4));
         return sz;
     }
     else if (type == File::Audio ||
              type == File::Directory ||
              type == File::MimetypeFallback) {
         int width = min_width;
         if (type == File::Directory ||
                 type == File::MimetypeFallback)
             width += 100;
         return QSize (width, min_height);
     }
     else if (type == File::Txt) {
         return getTextWindowSize(path);
     }
     else if(type == File::OkularFile) {
         return getDocumentWindowSize();
     }
     return QSize();
 }
 
 void DeclarativeViewer::initModel(QStringList urls)
 {
     // leave only unique entries
     QSet<QString> set;
     for(int i = 0; i < urls.size(); i++) {
         if(set.contains(urls[i])) {
             urls.removeAt(i);
             i--;
         }
         else {
             set.insert(urls[i]);
         }
     }
 
     m_fileModel->reset();
 
     QList<ListItem *> items;
     foreach(const QString &str, urls) {
         File *file = new File(KUrl(str));
         items.append(new ListItem(file, m_fileModel));
     }
     m_fileModel->appendRows(items);
 }
 
 void DeclarativeViewer::centerWidget(const QSize& sz)
 {
     QDesktopWidget dw;
     QRect rectDesktop = dw.screenGeometry(/*FIXME: was this*/);
     QSize sz1 = sz;
 
     if (m_isEmbedded) {
         int iconOffset = 5;
         int desktopMargin = 70;
 
         QRect top(rectDesktop.x() + desktopMargin,
                   rectDesktop.y() + desktopMargin ,
                   rectDesktop.width() - 2 * desktopMargin ,
                   m_rcIcon.y() - desktopMargin - iconOffset);
 
         QRect left(rectDesktop.x() + desktopMargin,
                    rectDesktop.y() + desktopMargin,
                    m_rcIcon.x() - iconOffset - rectDesktop.x() - desktopMargin,
                    rectDesktop.height()- 2 * desktopMargin);
 
         QRect right(m_rcIcon.topRight().x(),
                     rectDesktop.y() + desktopMargin,
                     rectDesktop.width() - m_rcIcon.topRight().x() - desktopMargin - iconOffset,
                     rectDesktop.height() - 2 * desktopMargin);
 
         int topArea = top.width()*top.height();
         int leftArea = left.width()*left.height();
         int rightArea = right.width()*right.height();
 
         if ((topArea > leftArea) && (topArea > rightArea)) {
             sz1.setHeight(sz1.height() + arrowIconHeight);
             sz1 = inscribedRectToRect(sz1, top.size());
             int x = m_rcIcon.x() + m_rcIcon.width()/2 - sz1.width()/2;
             int y = m_rcIcon.y() - iconOffset - sz1.height();
             x = qMax(x , desktopMargin);
             x = qMin(x, top.topRight().x() - sz1.width());
             QRect rect(x,y,sz1.width()+2,sz1.height()+2); // +2 - border width in embedded mode
             rootContext()->setContextProperty("embeddedLayout", "top");
             //Set arrow icon coordinates
             m_rcArrow.setX(m_rcIcon.x() + m_rcIcon.width()/2 - arrowIconWidth/2 -rect.x());
             m_rcArrow.setY(rect.height() - arrowIconHeight);
             m_rcArrow.setWidth(arrowIconWidth);
             m_rcArrow.setHeight(arrowIconHeight);
             m_posArrow = BOTTOM;
             setGeometry(rect);
         }
         else if (leftArea > rightArea) {
             sz1.setWidth(sz1.width()+ arrowIconHeight);
             sz1 = inscribedRectToRect(sz1, left.size());
             int x = m_rcIcon.x() - sz1.width() - iconOffset;
             int y = m_rcIcon.y() + m_rcIcon.height()/2 - sz1.height()/2;
             y = qMax(y , desktopMargin);
             y = qMin(y, left.bottomLeft().y() -sz1.height());
             QRect rect(x,y,sz1.width()+2,sz1.height()+2);
             rootContext()->setContextProperty("embeddedLayout", "left");
             //Set arrow icon coordinates
             m_rcArrow.setX(rect.width() - arrowIconHeight);
             m_rcArrow.setY(m_rcIcon.y() + m_rcIcon.height()/2 - arrowIconWidth/2 - rect.y());
             m_rcArrow.setWidth(arrowIconHeight);
             m_rcArrow.setHeight(arrowIconWidth);
             m_posArrow = RIGHT;
             setGeometry(rect);
         }
         else {
             sz1.setWidth(sz1.width()+ arrowIconHeight);
             sz1 = inscribedRectToRect(sz1, right.size());
             int x = m_rcIcon.topRight().x() + iconOffset;
             int y = m_rcIcon.y() + m_rcIcon.height()/2 - sz1.height()/2;
             y = qMax(y , desktopMargin);
             y = qMin(y, right.bottomLeft().y() - sz1.height());
             QRect rect(x,y,sz1.width()+2,sz1.height()+2);
             rootContext()->setContextProperty("embeddedLayout", "right");
             //Set arrow icon coordinates
             m_rcArrow.setX(0);
             m_rcArrow.setY(m_rcIcon.y() + m_rcIcon.height()/2 - arrowIconWidth/2 - rect.y());
             m_rcArrow.setWidth(arrowIconHeight);
             m_rcArrow.setHeight(arrowIconWidth);
             m_posArrow = LEFT;
             setGeometry(rect);
         }
         rootContext()->setContextProperty("arrowX", m_rcArrow.x());
         rootContext()->setContextProperty("arrowY", m_rcArrow.y());
         emit setEmbeddedState();
     }
     else {
         int w = sz.width();
         int h = sz.height();
         QRect rect((rectDesktop.width() - w) / 2,
                     (rectDesktop.height() - h) / 2,
                     w , h);
         rect.moveTop(rect.y() - height_offset / 2);
         setGeometry(rect);
         //move(QApplication::desktop()->screen()->rect().center() - rect().center());
     }
 
     if (!isVisible()) {
         show();
     }
     //activateWindow(); FIXME
 }
 
 void DeclarativeViewer::updateCurrentFile(int index)
 {
     if(index == -1) {
         return;
     }
     m_currentFile = m_fileModel->file(index);
 }
 
 QString DeclarativeViewer::serviceForFile(int index) const
 {
     const File *file = m_fileModel->file(index);
     if (!file->mime().isEmpty()) {
         KService::Ptr ptr = KMimeTypeTrader::self()->preferredService(file->mime());
         KService *serv = ptr.data();
         if(ptr) { // NOTE: weird checking here
             return serv->name();
         }
     }
     return QString();
 }
 
 void DeclarativeViewer::resizeToPreferredSize(int index)
 {
     File *file = m_fileModel->file(index);
     const QString path = file->url().isLocalFile() ? file->url().toLocalFile() : file->tempFilePath();
     QSize preferredSize = getPreferredSize(path, file->type());
 
     // this is necessary for following comparisons to geometry
     if (!preferredSize.isValid() || (preferredSize.width() < minimumSize().width()) ||
             preferredSize.height() < minimumSize().height()) {
         preferredSize = minimumSize();
     }
 
     if (preferredSize != geometry().size()) {
         centerWidget(preferredSize);
     }
     else {
         if(!isVisible())
             show();
     }
 }
 
 void DeclarativeViewer::setVideoSizeHint(int width, int height, int index)
 {
     m_videoSizeHints.insert(index, QSize(width, height));
 }
 
 WidgetRegion DeclarativeViewer::calculateWindowRegion(const QPoint& mousePos)
 {
     return ARROW_NULL_REGION; // FIXME
 
 #if 0
     QPointF pos;
     pos = mousePos;
     if (m_isEmbedded) {
         QRegion region;
         QRect r = rect();
         if (m_posArrow == BOTTOM) {
             QRect r1(r.bottomLeft().x(), r.bottomLeft().y()-arrowIconHeight, r.width(),arrowIconHeight);
             region.setRects(&r1,1);
             region = region.subtracted(QRegion(m_rcArrow));
         }
         else if (m_posArrow == LEFT) {
             QRect r2(r.x(), r.y(), m_rcArrow.width(), r.height());
             region.setRects(&r2,1);
             region = region.subtracted(QRegion(m_rcArrow));
         }
         else if (m_posArrow == RIGHT) {
             QRect r3(r.topRight().x() - m_rcArrow.width(), r.y(), m_rcArrow.width(), r.height());
             region.setRects(&r3,1);
             region = region.subtracted(QRegion(m_rcArrow));
         }
         if (region.contains(pos.toPoint())) {
             return ARROW_NULL_REGION;
         }
         return FRAME_REGION;
     }
 
 
     QRectF r = rect();
     QRectF headerTitle;
     QRectF header1(6 + 42 * 2, border_width + 1, 60, header_height - border_width + 1);
     QRectF header2(r.width() - 42 * 2 - 12 - 6, border_width + 1, 12, header_height- border_width + 1);
     QRegion headerR;
 
     if (m_isSingleMode) {
         headerTitle.setRect(border_width + 1,
                              border_width + 1,
                              r.width() - border_width - 270,
                              header_height - border_width + 1);
         headerR = headerR.united(headerTitle.toRect());
         headerR = headerR.united(header2.toRect());
     }
     else {
         headerTitle.setRect(6 + 42 * 3 + 12,
                              border_width + 1,
                              r.width() - 414,
                              header_height - border_width + 1);
         headerR = headerR.united(headerTitle.toRect());
         headerR = headerR.united(header1.toRect());
         headerR = headerR.united(header2.toRect());
     }
 
     QRectF topBorder(0, 0, r.width(), border_width);
     QRectF leftBorder(0, 0, border_width, r.height());
     QRectF rightBorder(r.width()-border_width, 0, border_width, r.height());
     QRectF bottomBorder(0, r.height()-border_width, r.width(), border_width);
 
     if (headerR.contains(pos.toPoint())) {
         return HEADER_REGION;
     }
     else if (topBorder.contains(pos)) {
         if (leftBorder.contains(pos)) {
             return TOP_LEFT_CORNER_REGION;
         }
         else if (rightBorder.contains(pos)) {
             return TOP_RIGHT_CORNER_REGION;
         }
         else {
             return TOP_BORDER_REGION;
         }
     }
     else if (bottomBorder.contains(pos)) {
         if (leftBorder.contains(pos)) {
             return BOTTOM_LEFT_CORNER_REGION;
         }
         else if (rightBorder.contains(pos)) {
             return BOTTOM_RIGHT_CORNER_REGION;
         }
         else {
             return BOTTOM_BORDER_REGION;
         }
     }
     else if (leftBorder.contains(pos)) {
         return LEFT_BORDER_REGION;
     }
     else if (rightBorder.contains(pos)) {
         return RIGHT_BORDER_REGION;
     }
 
     return FRAME_REGION;
 #endif
 }
 
 void DeclarativeViewer::mousePressEvent(QMouseEvent* event)
 {
     if (!m_isEmbedded) {
         if (!isFullScreen()) {
             m_region = calculateWindowRegion(event->pos());
             if (event->button() == Qt::LeftButton) {
                 if (m_region == HEADER_REGION) {
                     m_moving = true;
                     m_lastMousePosition = event->globalPos();
                     setCursor(QCursor(Qt::SizeAllCursor));
                 }
                 else if (m_region != FRAME_REGION) {
                     m_resize = true;
                     m_lastMousePosition = event->globalPos();
                 }
             }
             event->accept();
         }
     }
     else {
         if (calculateWindowRegion(event->pos()) == ARROW_NULL_REGION) {
             close();
         }
     }
 
     QQuickView::mousePressEvent(event);
 }
 
 void DeclarativeViewer::mouseMoveEvent(QMouseEvent* event)
 {
     QQuickView::mouseMoveEvent(event);
     if (isFullScreen() || m_isEmbedded) {
         return;
     }
 
 #if 0
     if (event->buttons().testFlag(Qt::LeftButton) && m_moving) {
         if (viewport()->cursor().shape() != (Qt::SizeAllCursor))
             viewport()->setCursor(QCursor(Qt::SizeAllCursor));
         window()->move(window()->pos() + (event->globalPos() - m_lastMousePosition));
         m_lastMousePosition = event->globalPos();
     }
     else if (event->buttons().testFlag(Qt::LeftButton) && m_resize) {
         QPoint p = mapToGlobal(event->pos()) - geometry().topLeft();
         QPoint offset = event->globalPos() - m_lastMousePosition;
         switch (m_region) {
         case LEFT_BORDER_REGION:
             if (offset.x() * (-1) + width() > minimumWidth()) {
                 window()->move((window()->pos() + offset).x(), y());
                 resize(offset.x() * (-1) + width(), height());
                 m_lastMousePosition = event->globalPos();
             }
             break;
         case TOP_BORDER_REGION:
             if (offset.y()*(-1) + height() > minimumHeight()) {
                 window()->move(x(), (window()->pos() + offset).y());
                 resize(width(), offset.y() * (-1) + height());
                 m_lastMousePosition = event->globalPos();
             }
             break;
         case TOP_LEFT_CORNER_REGION:
             if (offset.x() * (-1) + width() > minimumWidth()) {
                 window()->move((window()->pos() + offset).x(), y());
                 resize(offset.x() * (-1) + width(), height());
                 m_lastMousePosition.setX(event->globalPos().x());
             }
             if (offset.y() * (-1) + height() > minimumHeight()) {
                 window()->move(x(), (window()->pos() + offset).y());
                 resize(width(), offset.y() * (-1) + height());
                 m_lastMousePosition.setY(event->globalPos().y());
             }
             break;
         case TOP_RIGHT_CORNER_REGION:
             resize(p.x(), height());
             if (offset.y() * (-1) + height() > minimumHeight()) {
                 window()->move(x(), (window()->pos() + offset).y());
                 resize(width(), offset.y() * (-1) + height());
                 m_lastMousePosition.setY(event->globalPos().y());
             }
             break;
         case BOTTOM_LEFT_CORNER_REGION:
             resize(width() , p.y());
             if (offset.x() * (-1) + width() > minimumWidth()) {
                 window()->move((window()->pos() + offset).x(), y());
                 resize(offset.x() * (-1) + width(), height());
                 m_lastMousePosition.setX(event->globalPos().x());
             }
             break;
         case RIGHT_BORDER_REGION:
             resize(p.x(), height());
             break;
         case BOTTOM_BORDER_REGION:
             resize(width() , p.y());
             break;
         default:
             resize(p.x(), p.y());
         }
     }
     else {
         m_region = calculateWindowRegion(event->pos());
         if ((m_region == TOP_BORDER_REGION) || (m_region == BOTTOM_BORDER_REGION)) {
             if (viewport()->cursor().shape() != (Qt::SizeVerCursor)) {
                 viewport()->setCursor(QCursor(Qt::SizeVerCursor));
             }
         }
         else if ((m_region == LEFT_BORDER_REGION) || (m_region == RIGHT_BORDER_REGION)) {
             if (viewport()->cursor().shape() != (Qt::SizeHorCursor)) {
                 viewport()->setCursor(QCursor(Qt::SizeHorCursor));
             }
         }
         else if ((m_region == TOP_LEFT_CORNER_REGION) || (m_region == BOTTOM_RIGHT_CORNER_REGION)) {
             if (viewport()->cursor().shape() != (Qt::SizeFDiagCursor)) {
                 viewport()->setCursor(QCursor(Qt::SizeFDiagCursor));
             }
         }
         else if ((m_region == TOP_RIGHT_CORNER_REGION) || (m_region == BOTTOM_LEFT_CORNER_REGION)) {
             if (viewport()->cursor().shape() != (Qt::SizeBDiagCursor)) {
                 viewport()->setCursor(QCursor(Qt::SizeBDiagCursor));
             }
         }
         else if (viewport()->cursor().shape() != (Qt::ArrowCursor)) {
             viewport()->setCursor(QCursor(Qt::ArrowCursor));
         }
     }
 #endif
 }
 
 void DeclarativeViewer::mouseReleaseEvent(QMouseEvent* event)
 {
 #if 0
     if (!isFullScreen()) {
         if (m_moving) {
             m_moving = false;
             viewport()->setCursor(QCursor(Qt::ArrowCursor));
         }
 
         if (m_resize) {
             m_resize = false;
             viewport()->setCursor(QCursor(Qt::ArrowCursor));
         }
         event->accept();
     }
 #endif
     QQuickView::mouseReleaseEvent(event);
 }
 
 void DeclarativeViewer::setViewMode(DeclarativeViewer::ViewMode mode)
 {
     m_isSingleMode = (mode == Single);
     rootContext()->setContextProperty("viewMode", ((mode == Single) ? "single" : "multi"));
 }
 
 void DeclarativeViewer::onSetGallery(bool isGallery)
 {
     m_isGallery = isGallery;
 }
 
 void DeclarativeViewer::showBusy()
 {
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
     centerWidget(QSize(min_width, min_height));
 }
 
 void DeclarativeViewer::showWindow()
 {
     QApplication::restoreOverrideCursor();
 }
 
 QSize DeclarativeViewer::getTextWindowSize(QString url) const
 {
     QFile f(url);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         return QSize();
     }
 
     QString text = f.readAll();
     QTextDocument* doc = new QTextDocument(text);
     QSize size =  doc->documentLayout()->documentSize().toSize();
     delete doc;
 
     size.setWidth(size.width() + 34);
     size.setHeight(size.height() + 10);
 
     QDesktopWidget dw;
     QSize desktopSize = dw.screenGeometry(/*FIXME: was this*/).size();
 
     if (size.width() > desktopSize.width() * 0.8) {
         size.setWidth(desktopSize.width() * 0.8);
     }
     if (size.height() > desktopSize.height() * 0.8) {
         size.setHeight(desktopSize.height() * 0.8);
     }
 
     size.setHeight(size.height() + (m_isEmbedded ? 0 : height_offset));
 
     size.setWidth(qMax(size.width(), minimumWidth()));
     size.setHeight(qMax(size.height(), minimumHeight()));
 
     return size;
 }
 
 void DeclarativeViewer::focusChanged(QWidget*, QWidget* now)
 {
     if (m_isEmbedded && !now) {
         close();
     }
 }
 
 void DeclarativeViewer::setEmbedded(bool state)
 {
     QSize minSize = state ? QSize(50, 50) : QSize(min_width, min_height);
     setMinimumSize(minSize);
     m_isEmbedded = state;
 }
 
 QSize calculateViewSize(const QSize& sz, const QRect &desktop)
 {
     QSize szItem = sz;
     int wDesktop = desktop.width() * 8 / 10;
     int hDesktop = desktop.height() * 8 / 10;
 
     szItem = inscribedRectToRect(sz, QSize(wDesktop, hDesktop));
     return szItem;
 }
 
 // function inscribing rect sz1 into rect sz2
 QSize inscribedRectToRect(const QSize& sz1, const QSize& sz2)
 {
     QSize sz = sz1;
     if ((sz.height() > sz2.height()) || (sz.width() > sz2.width())) {
         sz.scale(sz2, Qt::KeepAspectRatio);
     }
     return sz;
 }
 
diff --git a/src/klookapp.cpp b/src/klookapp.cpp
index 787dd64..ba27916 100644
--- a/src/klookapp.cpp
+++ b/src/klookapp.cpp
@@ -1,132 +1,126 @@
 /* KLook
  * Copyright (c) 2011-2012 ROSA  <support@rosalab.ru>
  * Authors: Julia Mineeva, Evgeniy Auzhin, Sergey Borovkov.
  * License: GPLv3
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as
  *   published by the Free Software Foundation; either version 3,
  *   or (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "klookapp.h"
 
+#include <QCommandLineParser>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QGraphicsObject>
 #include <QtQuick/QQuickItem>
+#include <QUrl>
 
 #include <KCmdLineArgs>
 #include <KIcon>
 #include <KStandardDirs>
 #include <KUrl>
 
 #include "declarativeviewer.h"
 #include "filemodel.h"
 
 
-KLookApp::KLookApp()
-    : KUniqueApplication()
+KLookApp::KLookApp(QCommandLineParser& parser, QObject* parent)
+    : QObject(parent)
     , m_viewer(0)
+    , parser(parser)
 {
 }
 
 KLookApp::~KLookApp()
 {
     delete m_viewer->m_fileModel;
 }
 
 bool KLookApp::isEmbeddedParam() const
 {
-    KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
-    return args->isSet("embedded");
+    return parser.isSet("embedded");
 }
 
 QRect KLookApp::rectParam() const
 {
-    KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
     QRect rc;
-    if (args->isSet("x") && args->isSet("y") &&
-         args->isSet("w") && args->isSet("h")) {
+    if (parser.isSet("x") && parser.isSet("y") &&
+         parser.isSet("w") && parser.isSet("h")) {
         int x, y, w, h;
-        x = args->getOption("x").toInt();
-        y = args->getOption("y").toInt();
-        w = args->getOption("w").toInt();
-        h = args->getOption("h").toInt();
+        x = parser.value("x").toInt();
+        y = parser.value("y").toInt();
+        w = parser.value("w").toInt();
+        h = parser.value("h").toInt();
         rc = QRect(x, y, w, h);
     }
     return rc;
 }
 
-QStringList KLookApp::urlsParam() const
+QStringList KLookApp::urlsParam(const QString& workingDirectory) const
 {
-    KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
     QStringList urls;
-    for (int i = 0; i < args->count(); i++) {
-        KUrl url(args->arg(i));
-        if(url.isRelative()) {
-            url.setUrl(args->cwd());
-            url.addPath(args->arg(i));
-        }
-        urls << url.url();
+    urls.reserve(parser.positionalArguments().size());
+    for (const auto& positionalArgument: parser.positionalArguments()) { //TODO: std::transform?
+        urls << QUrl::fromUserInput(positionalArgument, workingDirectory).url();
     }
     return urls;
 }
 
-int KLookApp::newInstance()
+int KLookApp::handleCmdLIne(const QString& workingDirectory)
 {
-    KCmdLineArgs::setCwd(QDir::currentPath().toUtf8());
-    KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
-
-    QStringList urls = urlsParam();
+    QStringList urls = urlsParam(workingDirectory);
     QRect rc = rectParam();
     bool embedded = isEmbeddedParam();
 
-    int index = args->getOption("i").toInt();
+    int index = parser.value("i").toInt();
     if (index >= urls.count()) {
         index = 0;
     }
     if(!m_viewer) {
         m_viewer = new DeclarativeViewer();
         QString qmlPath = KStandardDirs::locate("appdata", "main.qml");
         if (isLocal()) // this is hack for developers. should replace it with something better I guess
             qmlPath = "../src/qml/main.qml";
 
         if(!QFile::exists(qmlPath)) {
             qDebug() << "QML file not found";
-            exit();
+            //exit(); FIXME
         }
 
         m_viewer->setSource(QUrl::fromLocalFile(qmlPath));
 
         QObject* rootObject = dynamic_cast<QObject*>(m_viewer->rootObject());
 
         QObject::connect(m_viewer, SIGNAL(setFullScreenState()), rootObject, SLOT(setFullScreenState()));
         QObject::connect(m_viewer, SIGNAL(setEmbeddedState()), rootObject, SLOT(setEmbeddedState()));
         QObject::connect(m_viewer, SIGNAL(setStartWindow()), rootObject, SLOT(setStartWindow()));
         QObject::connect(rootObject, SIGNAL(setGalleryView(bool)), m_viewer, SLOT(onSetGallery(bool)));
     }
 
     m_viewer->init(urls, embedded, rc, index);
-    args->clear();
+
     m_viewer->show();
     return 0;
 }
 
 bool KLookApp::isLocal() const
 {
-    const QString appPath = applicationFilePath();
-    return !(appPath.startsWith(QLatin1String("/usr/bin")) || appPath.startsWith(QLatin1String("/usr/local/bin")));
+    return false; //FIXME
+    /*const QString appPath = applicationFilePath();
+    return !(appPath.startsWith(QLatin1String("/usr/bin")) || appPath.startsWith(QLatin1String("/usr/local/bin")));*/
 }
diff --git a/src/klookapp.h b/src/klookapp.h
index 521cbd7..2254932 100644
--- a/src/klookapp.h
+++ b/src/klookapp.h
@@ -1,48 +1,52 @@
 /* KLook
  * Copyright (c) 2011-2012 ROSA  <support@rosalab.ru>
  * Authors: Julia Mineeva, Evgeniy Auzhin, Sergey Borovkov.
  * License: GPLv3
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as
  *   published by the Free Software Foundation; either version 3,
  *   or (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #ifndef KLOOK_APP_H
 #define KLOOK_APP_H
 
-#include <KUniqueApplication>
+#include <QObject>
+#include <QString>
 
 class DeclarativeViewer;
+class QCommandLineParser;
 
-class KLookApp : public KUniqueApplication
+class KLookApp : public QObject
 {
     Q_OBJECT
 
 public:
-    KLookApp();
+    KLookApp(QCommandLineParser& parser, QObject* parent = nullptr);
     ~KLookApp();
-    virtual int newInstance();
+    int handleCmdLIne(const QString& workingDirectory);
 
 private:
     bool isLocal() const;
     bool isEmbeddedParam() const;
 
-    QStringList urlsParam() const;
+    QStringList urlsParam(const QString& workingDirectory) const;
     QRect rectParam() const;
 
     DeclarativeViewer* m_viewer;
+
+    QCommandLineParser& parser;
 };
 
 #endif // KLOOK_APP_H
diff --git a/src/main.cpp b/src/main.cpp
index 5042b49..a3ebbbc 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,72 +1,90 @@
 /* KLook
  * Copyright (c) 2011-2012 ROSA  <support@rosalab.ru>
  * Authors: Julia Mineeva, Evgeniy Auzhin, Sergey Borovkov.
  * License: GPLv3
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as
  *   published by the Free Software Foundation; either version 3,
  *   or (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include <stdio.h>
 
-#include <KDE/K4AboutData>
+#include <KDE/KAboutData>
 #include <KDE/KCmdLineArgs>
 #include <KLocale>
+#include <KDBusService>
+
+#include <QCommandLineParser>
+#include <QCommandLineOption>
+#include <QDir>
+#include <QApplication>
+#include <QString>
+#include <QStringList>
 
 #include "klookapp.h"
 
 static const char description[] = I18N_NOOP("KLook is a quick file content preview program");
 static const char version[] = "1.1";
 
 int main(int argc, char *argv[])
 {
-    K4AboutData about("klook", "klook", ki18n("KLook"),
-                      version, ki18n(description),  K4AboutData::License_GPL_V3,
-                      ki18n("(c) ROSA 2011-2012"));
+    QApplication app {argc, argv};
+    KAboutData aboutData("klook", i18n("KLook"),
+                      version, i18n(description),  KAboutLicense::GPL_V3,
+                      i18n("(c) ROSA 2011-2012"));
 
-    about.addAuthor(ki18n("Julia Mineeva"),
-                     ki18n("Developer"),
+    aboutData.addAuthor(i18n("Julia Mineeva"),
+                     i18n("Developer"),
                      "julia.mineeva@osinit.ru");
 
-    about.addAuthor(ki18n("Evgeniy Auzhin"),
-                     ki18n("Developer"),
+    aboutData.addAuthor(i18n("Evgeniy Auzhin"),
+                     i18n("Developer"),
                      "evgeniy.augin@osinit.ru");
 
-    about.addAuthor(ki18n("Sergey Borovkov"),
-                     ki18n("Developer"),
+    aboutData.addAuthor(i18n("Sergey Borovkov"),
+                     i18n("Developer"),
                      "sergey.borovkov@osinit.ru");
 
-    about.setProgramIconName("klook");
+    aboutData.setProgramIconName("klook");
+
+    QCommandLineParser parser;
+    KAboutData::setApplicationData(aboutData);
+    parser.addVersionOption();
+    parser.addHelpOption();
+    aboutData.setupCommandLine(&parser);
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("i"), i18n("File index "), QLatin1String("i"), QLatin1String("0")));
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("embedded"), i18n("Turn on embedded mode"), QLatin1String("0")));
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("x"), i18n("X position of the icon"), QLatin1String("x"), QLatin1String("0")));
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("y"), i18n("Y position of the icon"), QLatin1String("y"), QLatin1String("0")));
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("w"), i18n("Width of the icon"), QLatin1String("width"), QLatin1String("0")));
+    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("h"), i18n("Height of the icon"), QLatin1String("height"), QLatin1String("0")));
+    parser.addPositionalArgument(QLatin1String("file"), i18n("A required argument 'file'"), QLatin1String(0));
 
-    KCmdLineArgs::init(argc, argv, &about);
+    parser.process(app); // PORTING SCRIPT: move this to after any parser.addOption
+    aboutData.processCommandLine(&parser);
 
-    KCmdLineOptions options;
-    options.add("i <i>", ki18n("File index "), "0");
-    options.add("embedded", ki18n("Turn on embedded mode"), "0");
-    options.add("x <x>", ki18n("X position of the icon"), "0");
-    options.add("y <y>", ki18n("Y position of the icon"), "0");
-    options.add("w <width>", ki18n("Width of the icon"), "0");
-    options.add("h <height>", ki18n("Height of the icon"), "0");
-    options.add("+file", ki18n("A required argument 'file'"), 0);
+    KLookApp a {parser};
+    KDBusService service(KDBusService::Unique);
 
-    KCmdLineArgs::addCmdLineOptions(options);
-    if (!KUniqueApplication::start()) {
-        fprintf(stderr, "KLook is already running!\n");
-        return 0;
-    }
+    QObject::connect(&service, &KDBusService::activateRequested, &a, [&parser, &a](const QStringList& arguments, const QString& workingDirectory){
+        if (!arguments.isEmpty()) {
+            parser.parse(arguments);
+        }
+        a.handleCmdLIne(workingDirectory);
+    });
+    a.handleCmdLIne(QDir::currentPath());
 
-    KLookApp a;
-    return a.exec();
+    return app.exec();
 }