diff --git a/CMakeLists.txt b/CMakeLists.txt
index a16f6c8..ab037c4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,75 +1,100 @@
 project( klook )
-cmake_minimum_required( VERSION 2.6 )
+cmake_minimum_required( VERSION 3.10 FATAL_ERROR )
+set (QT_MIN_VERSION "5.9.0")
+set (KF5_MIN_VERSION "5.35.0") # TODO: find an appropriate version
 
-find_package( KDE4 REQUIRED )
-include( KDE4Defaults )
 
-find_package(KDeclarative)
+find_package(ECM ${KF5_MIN_VERSION} REQUIRED CONFIG)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
-find_package( Qt4 REQUIRED QtCore QtGui QtDeclarative )
-include( ${QT_USE_FILE} )
-qt4_automoc( ${qtproject_SRCS} )
-add_definitions( ${QT_DEFINITIONS})
+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
+)
+
+find_package(Phonon4Qt5 REQUIRED)
+
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
 
-include_directories( ${KDE4_INCLUDES} ${QT_QDECLARATIVE_INCLUDE_DIR} ${KDECLARATIVE_INCLUDE_DIRS} )
 add_subdirectory( icons )
 
 set(EXIV2_MIN_VERSION "0.19")
 find_package(Exiv2)
-macro_log_feature(EXIV2_FOUND "Exiv2" "Provides image metadata support" "http://www.exiv2.org" TRUE ${EXIV2_MIN_VERSION} "")
 
-set( RESOURCES src/resources.qrc )
-QT4_ADD_RESOURCES( QRC_SOURCES ${RESOURCES} )
+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})
+#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} )
 
-kde4_add_app_icon( klook_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/icons/hi*-apps-klook.png" )
-kde4_add_executable( klook ${klook_SRCS} ${QRC_SOURCES} )
+target_include_directories(klook SYSTEM PUBLIC ${PHONON_INCLUDE_DIR})
 
-target_link_libraries( klook ${KDE4_KIO_LIBS}
-                           ${EXIV2_LIBRARIES}
-                           ${KDE4_PHONON_LIBS}
-                           ${KDE4_PLASMA_LIBS}
-                           ${KDE4_KFILE_LIBS}
-                           kparts
-                           ${KDECLARATIVE_LIBRARIES}
-                           ${QT_LIBRARIES}
-                           ${QT_QDECLARATIVE_LIBRARIES}
-                      )
+target_link_libraries(klook KF5::KIOCore KF5::KIOFileWidgets KF5::KIOWidgets KF5::KIONTLM
+                            ${EXIV2_LIBRARIES}
+                            KF5::Plasma
+                            ${PHONON_LIBRARY}
+                            KF5::Parts
+                            KF5::Declarative
+                            KF5::KDELibs4Support
+                            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()
+#if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/locale)
+  #find_package( Msgfmt REQUIRED )
+  #find_package( Gettext REQUIRED )
+  #add_subdirectory( locale )
+#endif()
 
diff --git a/icons/CMakeLists.txt b/icons/CMakeLists.txt
index 714baa0..48e0cce 100644
--- a/icons/CMakeLists.txt
+++ b/icons/CMakeLists.txt
@@ -1,2 +1,3 @@
-kde4_install_icons( ${ICON_INSTALL_DIR} )
-kde4_update_iconcache()
+# FIXME
+# akde4_install_icons( ${ICON_INSTALL_DIR} )
+# kde4_update_iconcache()
diff --git a/src/audio.cpp b/src/audio.cpp
index 5eb975d..35e4c94 100644
--- a/src/audio.cpp
+++ b/src/audio.cpp
@@ -1,239 +1,239 @@
 /* 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 "audio.h"
 
 #include <KEncodingProber>
 #include <QtCore/QFileInfo>
 #include <QtCore/QString>
 #include <QtCore/QTextCodec>
 
-#include <Phonon/AudioOutput>
-#include <Phonon/MediaObject>
-#include <Phonon/VideoWidget>
+#include <KDE/Phonon/AudioOutput>
+#include <KDE/Phonon/MediaObject>
+#include <KDE/Phonon/VideoWidget>
 
-Audio::Audio(QDeclarativeItem* parent)
-    : QDeclarativeItem(parent)
+Audio::Audio(QQuickItem* parent)
+    : QQuickItem(parent)
     , m_isPreview(false)
     , m_isReady(false)
 {
     m_mediaObject = Phonon::createPlayer(Phonon::MusicCategory);
     m_mediaObject->setTickInterval(1000);
 
     QObject::connect(m_mediaObject, SIGNAL(tick(qint64)), SLOT(onTicked(qint64)));
     QObject::connect(m_mediaObject, SIGNAL(totalTimeChanged(qint64)), SLOT(onTotalTimeChanged(qint64)));
     QObject::connect(m_mediaObject, SIGNAL(finished()), SLOT(onFinished()));
     QObject::connect(m_mediaObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)),
                      SLOT(stateChanged(Phonon::State, Phonon::State)));
 }
 
 Audio::~Audio()
 {
     delete m_mediaObject;
 }
 
 void Audio::setPause()
 {
     if (!isVisible()) {
         pause();
     }
     else {
         play();
     }
 }
 
 bool Audio::isReady()
 {
     return m_isReady;
 }
 
 void Audio::setReady(bool b)
 {
     m_isReady = b;
     emit ready();
 }
 
 void Audio::onFinished()
 {
     emit playFinished();
     setPosition(0);
 }
 
 QString Audio::source() const
 {
     return m_mediaObject->currentSource().url().toString();
 }
 
 void Audio::setSource(const KUrl& source)
 {
     m_mediaObject->setCurrentSource(source);
     emit sourceChanged();
 }
 
 qlonglong Audio::position() const
 {
     return m_mediaObject->currentTime();
 }
 
 void Audio::setPosition(qlonglong pos)
 {
     m_mediaObject->seek(pos);
     emit positionChanged();
 }
 
 qlonglong Audio::totalTime() const
 {
     return m_mediaObject->totalTime();
 }
 
 QTime Audio::duration()
 {
     QTime t;
     t = t.addMSecs(m_mediaObject->totalTime());
     return t;
 }
 
 void Audio::onTotalTimeChanged(qint64 t)
 {
     Q_UNUSED(t)
     emit totalTimeChanged();
 }
 
 void Audio::onTicked(qint64 t)
 {
     emit ticked(QVariant(t));
 }
 
 bool Audio::playing() const
 {
     return (m_mediaObject->state() == Phonon::PlayingState);
 }
 
 bool Audio::paused() const
 {
     return (m_mediaObject->state() == Phonon::PausedState);
 }
 
 void Audio::play()
 {
     m_mediaObject->play();
 }
 
 void Audio::pause()
 {
     m_mediaObject->pause();
 }
 
 void Audio::play_or_pause()
 {
     if (playing()) {
         pause();
     }
     else {
         play();
     }
 }
 
 bool Audio::isPreview() const
 {
     return m_isPreview;
 }
 
 void Audio::setPreview(bool preview)
 {
     m_isPreview = preview;
 }
 
 void Audio::stateChanged(Phonon::State newState, Phonon::State oldState)
 {
     Q_UNUSED(newState)
     if ((oldState == Phonon::LoadingState) || (oldState == Phonon::StoppedState)) {
         setReady(true);
     }
 }
 
 QString Audio::artist()
 {
     QString artists;
     QStringList listArtists = m_mediaObject->metaData("ARTIST");
     if (!listArtists.empty()) {
         artists = guessEncoding(listArtists.join(", ").toAscii());
     }
     return artists;
 }
 
 QString Audio::album()
 {
     QString albums;
     QStringList listAlbums = m_mediaObject->metaData("ALBUM");
     if (!listAlbums.empty()) {
         albums = guessEncoding(listAlbums.join(", ").toAscii());
     }
     return albums;
 }
 
 QString Audio::title()
 {
     QString titles;
     QStringList listTitles = m_mediaObject->metaData("TITLE");
 
     titles = guessEncoding(listTitles.join(", ").toAscii());
     if (titles.isEmpty()) {
         QFileInfo fi(m_mediaObject->currentSource().url().path());
         titles = fi.fileName();
     }
 
     return titles;
 }
 
 QString Audio::guessEncoding(const QByteArray &data)
 {
     KEncodingProber prober(KEncodingProber::Universal);
     prober.feed(data);
     QString str = prober.confidence() > 0.7
             ? QTextCodec::codecForName(prober.encoding())->toUnicode(data)
             : QString::fromUtf8(data);
 
     return str;
 }
 
 QString Audio::composer()
 {
     QString composers;
     QStringList listcomposers = m_mediaObject->metaData("COMPOSER");
     if (!listcomposers.empty()) {
         composers = guessEncoding(listcomposers.join(", ").toAscii());
     }
 
     return composers.toUtf8();
 }
 
 QString Audio::genre()
 {
     QString genres;
     QStringList listgenres = m_mediaObject->metaData("GENRE");
     if (!listgenres.empty()) {
         genres = guessEncoding(listgenres.join(", ").toAscii());
     }
 
     return genres;
 }
 
diff --git a/src/audio.h b/src/audio.h
index 39a525b..1c6c605 100644
--- a/src/audio.h
+++ b/src/audio.h
@@ -1,120 +1,120 @@
 /* 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 AUDIO_H
 #define AUDIO_H
 
 #include <QtCore/QTime>
-#include <QtDeclarative/QDeclarativeItem>
-#include <Phonon/MediaObject>
-#include <Phonon/AudioOutput>
+#include <QtQuick/QQuickItem>
+#include <KDE/Phonon/MediaObject>
+#include <KDE/Phonon/AudioOutput>
 
 #include <KUrl>
 
 class QHBoxLayout;
 
-class Audio : public QDeclarativeItem
+class Audio : public QQuickItem
 {
     Q_OBJECT
     Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)
     Q_PROPERTY(bool playing READ playing)
     Q_PROPERTY(bool paused READ paused)
     Q_PROPERTY(qlonglong totalTime READ totalTime NOTIFY totalTimeChanged)
     Q_PROPERTY(QTime duration READ duration)
     Q_PROPERTY(qlonglong position READ position WRITE setPosition NOTIFY positionChanged)
     Q_PROPERTY(bool preview READ isPreview WRITE setPreview)
     Q_PROPERTY(bool ready READ isReady WRITE setReady NOTIFY ready)
 
     Q_PROPERTY(QString artist READ artist NOTIFY artistChanged)
     Q_PROPERTY(QString album READ album NOTIFY albumChanged)
     Q_PROPERTY(QString title READ title NOTIFY titleChanged)
     Q_PROPERTY(QString composer READ composer  NOTIFY composerChanged)
     Q_PROPERTY(QString genre READ genre  NOTIFY genreChanged)
 
 public:
-    Audio(QDeclarativeItem* parent = 0);
+    Audio(QQuickItem* parent = 0);
     ~Audio();
 
 public slots:
     QString source() const;
     void setSource(const KUrl &source);
 
     bool playing() const;
     bool paused() const;
     void setPause();
 
     bool isReady();
     void setReady(bool b);
 
     qlonglong totalTime() const;
     QTime duration();
 
     qlonglong position() const;
     void setPosition(qlonglong pos);
 
     QString artist();
     QString album();
     QString title();
     QString composer();
     QString genre();
 
     void play_or_pause();
     void play();
     void pause();
 
     void onTotalTimeChanged(qint64);
     void onTicked(qint64);
 
     void onFinished();
 
     void stateChanged(Phonon::State oldState, Phonon::State newState);
 
     bool isPreview() const;
     void setPreview(bool preview);
 
 protected:
 
 Q_SIGNALS:
     void clicked(bool);
     void sourceChanged();
     void totalTimeChanged();
     void positionChanged();
     void ticked(QVariant tick);
     void playFinished();
     void ready();
 
     void artistChanged();
     void albumChanged();
     void titleChanged();
     void composerChanged();
     void genreChanged();
 
 private:
     QString guessEncoding(const QByteArray &data);
 
     Phonon::MediaObject* m_mediaObject;
 
     bool m_isPreview;
     bool m_isReady;
 };
 
 #endif // AUDIO_H
diff --git a/src/declarativeviewer.cpp b/src/declarativeviewer.cpp
index ec91bd6..e0904c1 100644
--- a/src/declarativeviewer.cpp
+++ b/src/declarativeviewer.cpp
@@ -1,751 +1,742 @@
 /* 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 <QtDeclarative/QDeclarativeContext>
-#include <QtDeclarative/QDeclarativeEngine>
 #include <QtGui/QAbstractTextDocumentLayout>
-#include <QtGui/QApplication>
-#include <QtGui/QDesktopWidget>
+#include <QApplication>
+#include <QDesktopWidget>
 #include <QtGui/QImageReader>
 #include <QtGui/QTextDocument>
+#include <QtQml/QQmlContext>
 
-#include <kdeclarative.h>
+#include <KDeclarative/KDeclarative>
 #include <KMimeTypeTrader>
 #include <KWindowSystem>
-#include <plasma/windoweffects.h>
 
 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(QWidget* parent)
-    : QDeclarativeView(parent)
+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 kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.initialize();
     kdeclarative.setupBindings();
 
-    setOptimizationFlags(QGraphicsView::DontSavePainterState);
-    setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
-
-    setMouseTracking(true);
-
     engine()->addImageProvider("preview", new PreviewProvider);
     engine()->addImageProvider("mime", new MimeProvider);
     engine()->addImageProvider("exif", new ExifImageProvider);
 
-    setResizeMode(QDeclarativeView::SizeRootObjectToView);
+    setResizeMode(QQuickView::SizeRootObjectToView);
 
-    setMinimumSize(min_width, min_height);
+    //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);
+    //setWindowFlags(Qt::WindowStaysOnTopHint | Qt::CustomizeWindowHint | Qt::FramelessWindowHint); FIXME
 
-    setAttribute(Qt::WA_TranslucentBackground);
-    setStyleSheet("background:transparent;");
+    //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()));
 }
 
 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::resizeEvent(QResizeEvent *event)
-{
-    if (KWindowSystem::compositingActive()) {
-        //QRegion mask(QRect(QPoint(), size()));
-        //Plasma::WindowEffects::enableBlurBehind(winId(), true, mask);
-        //Plasma::WindowEffects::overrideShadow(winId(), true);
-    }
-
-    QDeclarativeView::resizeEvent(event);
-}
-
 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
-    rootContext()->setContextProperty("fileModel", m_fileModel);
-    rootContext()->setContextProperty("mainWidget",  this);
-    rootContext()->setContextProperty("viewMode", "single");
-    rootContext()->setContextProperty("embedded", m_isEmbedded);
-    rootContext()->setContextProperty("embeddedLayout", "null");
-    rootContext()->setContextProperty("previewGenerator", PreviewGenerator::instance());
-    rootContext()->setContextProperty("arrowX", .0);
-    rootContext()->setContextProperty("arrowY", .0);
+    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 && !isFullScreen()) {
+    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 (isFullScreen()) {
+    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(this));
+            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(this));
+        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(this);
+    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();
+    //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.isNull()) {
+        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();
         }
     }
 
-    QDeclarativeView::mousePressEvent(event);
+    QQuickView::mousePressEvent(event);
 }
 
 void DeclarativeViewer::mouseMoveEvent(QMouseEvent* event)
 {
-    QDeclarativeView::mouseMoveEvent(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();
     }
-    QDeclarativeView::mouseReleaseEvent(event);
+#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(this).size();
+    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/declarativeviewer.h b/src/declarativeviewer.h
index 42b2b56..00dbc5b 100644
--- a/src/declarativeviewer.h
+++ b/src/declarativeviewer.h
@@ -1,156 +1,156 @@
 /* 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 DECLARATIVEVIEWER_H
 #define DECLARATIVEVIEWER_H
 
-#include <QtDeclarative/QDeclarativeView>
+#include <QtQuick/QQuickView>
 
 class QRect;
 class PreviewGenerator;
 class File;
 class FileModel;
 class QPoint;
+class QWindow;
 
 enum WidgetRegion
 {
     FRAME_REGION,
     HEADER_REGION,
     RIGHT_BORDER_REGION,
     LEFT_BORDER_REGION,
     TOP_BORDER_REGION,
     BOTTOM_BORDER_REGION,
     TOP_LEFT_CORNER_REGION,
     TOP_RIGHT_CORNER_REGION,
     BOTTOM_LEFT_CORNER_REGION,
     BOTTOM_RIGHT_CORNER_REGION,
     ARROW_NULL_REGION
 };
 
 typedef enum ArrowPosition
 {
     TOP,
     BOTTOM,
     LEFT,
     RIGHT
 
 } ArrowPosition;
 
-class DeclarativeViewer : public QDeclarativeView
+class DeclarativeViewer : public QQuickView
 {
     Q_OBJECT
 public:
-    explicit DeclarativeViewer(QWidget *parent = 0);
+    explicit DeclarativeViewer(QWindow *parent = 0);
     virtual ~DeclarativeViewer();
 
     void init(QStringList urls, bool embedded = false, const QRect& rc = QRect(0, 0, 0, 0), int indexToShow = 0);
     Q_INVOKABLE void resizeToPreferredSize(int index);
 
     /**
      *
      * @brief Hack to pass video's size hint from QML to C++ side.
      *        To ensure that that size hint is used for right video
      *        index is passed along.
      * @param width
      * @param height
      * @param index
      */
     Q_INVOKABLE void setVideoSizeHint(int width, int height, int index);
     Q_INVOKABLE void setFullScreen();
 
     Q_INVOKABLE QString serviceForFile(int index) const;
 
     Q_INVOKABLE void updateCurrentFile(int index);
 
-protected:
-    void resizeEvent(QResizeEvent *event);
-
 signals:
     void sizeChanged();
 
     /**
      * @brief Informs QML to set fullscreen state
      */
     void setFullScreenState();
     void setEmbeddedState();
     void setStartWindow();
 
 public slots:
     void onSetGallery(bool);
 
     // called after startup when we can't determine ensured file size quickly
     void showBusy();
 
     // Called when file size can't be determined reasonably fast - we will have to show window
     // anyway
     void showWindow();
 
 private slots:
     void focusChanged(QWidget*, QWidget*);
 
 protected:
     void mousePressEvent(QMouseEvent* event);
     void mouseMoveEvent(QMouseEvent* event);
     void mouseReleaseEvent(QMouseEvent* event);
 
 private:
     friend class KLookApp;
     enum ViewMode
     {
         Single,
         Multi
     };
 
     QSize getPreferredSize(const QString &path, int type) const;
     WidgetRegion calculateWindowRegion(const QPoint& mousePos);
     void setEmbedded(bool);
 
+    bool isFullScreen(){return windowState() == Qt::WindowFullScreen;}
+
     void initModel(QStringList urls);
     void setViewMode(ViewMode mode);
     void registerTypes();
     QSize getTextWindowSize(QString url) const;
     void createVideoObject(QUrl url);
 
     void centerWidget(const QSize& sz);
 
     QPoint          m_lastMousePosition;
     bool            m_isSingleMode;
     bool            m_moving;
     bool            m_resize;
     bool            m_isEmbedded;
     bool            m_isGallery;
     QRect           m_rcIcon;
     QRect           m_rcArrow;
 
     File*     m_currentFile;
 
     WidgetRegion    m_region;
 
     FileModel*          m_fileModel;
     ArrowPosition       m_posArrow;
 
     QHash<int, QSize> m_videoSizeHints;
 };
 
 QSize calculateViewSize(const QSize& sz, const QRect &desktop);
 QSize inscribedRectToRect(const QSize& sz1, const QSize& sz2);
 
 #endif // DECLARATIVEVIEWER_H
diff --git a/src/exifimageprovider.cpp b/src/exifimageprovider.cpp
index ce146c7..da02a9f 100644
--- a/src/exifimageprovider.cpp
+++ b/src/exifimageprovider.cpp
@@ -1,46 +1,46 @@
 /* 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 <QtGui/QImage>
 
 #include "exifimageprovider.h"
 #include "rotatedimage.h"
 
 ExifImageProvider::ExifImageProvider()
-    : QDeclarativeImageProvider(Image)
+    : QQuickImageProvider(Image)
 {
 }
 
 QImage ExifImageProvider::requestImage(const QString& id, QSize* size, const QSize &requestedSize)
 {
     RotatedImage rt(id);
     QImage image(id);
     image = image.transformed(rt.rotationMatrix());
 
     if (requestedSize.isValid() && (requestedSize.width() < image.width()
                                     || requestedSize.height() < image.height())) {
         image = image.scaled(requestedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     *size = image.size();
 
     return image;
 }
diff --git a/src/exifimageprovider.h b/src/exifimageprovider.h
index 1ec8953..20d636a 100644
--- a/src/exifimageprovider.h
+++ b/src/exifimageprovider.h
@@ -1,36 +1,36 @@
 /* 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 EXIFIMAGEPROVIDER_H
 #define EXIFIMAGEPROVIDER_H
 
-#include <QtDeclarative/QDeclarativeImageProvider>
+#include <QtQuick/QQuickImageProvider>
 
-class ExifImageProvider : public QDeclarativeImageProvider
+class ExifImageProvider : public QQuickImageProvider
 {
 public:
     explicit ExifImageProvider();
     virtual QImage requestImage(const QString &id, QSize *size, const QSize& requestedSize);
 };
 
 #endif // EXIFIMAGEPROVIDER_H
 
 
diff --git a/src/file.cpp b/src/file.cpp
index 4034cdf..85eaf0a 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -1,323 +1,323 @@
 /* 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 "file.h"
 
 #include <QtCore/QFileInfo>
 #include <QtCore/QTemporaryFile>
 #include <QtGui/QImageReader>
 
 #include <KIO/Job>
 #include <KIO/JobClasses>
 #include <KIO/NetAccess>
 #include <KLocalizedString>
 #include <KMimeType>
 #include <kuiserverjobtracker.h>
-#include <Phonon/BackendCapabilities>
+#include <KDE/Phonon/BackendCapabilities>
 
 File::File(QObject* parent)
     : QObject(parent)
     , m_job(0)
     , m_type(Progress)
     , m_tempFile(0)
     , m_isLoaded(0)
 {
 }
 
 File::File(KUrl url, QObject* parent)
     : QObject(parent)
     , m_url(url)
     , m_job(0)
     , m_type(File::Progress)
     , m_tempFile(0)
     , m_isLoaded(0)
     , m_mimeJobStarted(false)
     , m_downloadInProgress(false)
     , m_isCurrent(false)
 {
     m_isLoaded = m_url.isLocalFile();
 }
 
 File::~File()
 {
     stopDownload();
 }
 
 KUrl File::url() const
 {
     return m_url;
 }
 
 void File::setUrl(QUrl url)
 {
     m_url = url;
     m_isLoaded = url.isLocalFile();
 }
 
 File::FileType File::type() const
 {
     return m_type;
 }
 
 void File::setType(FileType type)
 {
     m_type = type;
 }
 
 QString File::mime() const
 {
     return m_mime;
 }
 
 void File::setMime(const QString &mime)
 {
     m_mime = mime;
 }
 
 void File::load()
 {
     if(type() == Progress) {
         if(!m_mimeJobStarted)
             loadType();
     }
     else if(needDownload() && m_isCurrent) {
         download();
     }
 }
 
 void File::download()
 {
     if(m_downloadInProgress) {
         qDebug() << "Trying to download file for the second time...";
         return;
     }
 
     if(!m_tempFile) {
         m_tempFile = new QTemporaryFile(this);
     }
     if (m_tempFile->open()) {
         m_downloadInProgress = true;
         m_job = KIO::file_copy(m_url, KUrl(m_tempFile->fileName()), -1, KIO::Overwrite | KIO::HideProgressInfo);
         m_job->setAutoDelete(false);
         connect(m_job, SIGNAL(result(KJob *)), SLOT(slotDownloadResult(KJob *)));
         KIO::getJobTracker()->registerJob(m_job);
     }
     emit dataChanged();
 }
 
 bool File::needDownload()
 {
     const FileType t = type();
 
     if(url().isLocalFile())
         return false;
 
     if(t == File::Image || t == File::Txt
             || t == File::Audio || t == File::Video) {
         return true;
     }
 
     return false;
 }
 
 bool File::isLoaded() const
 {
     return m_isLoaded;
 }
 
 bool File::downloadInProgress() const
 {
     return m_downloadInProgress;
 }
 
 void File::stopDownload()
 {
     if(m_job) {
         m_downloadInProgress = false;
         m_isLoaded = false;
         m_job->kill();
         KIO::getJobTracker()->unregisterJob(m_job);
         delete m_job;
         m_job = 0;
         delete m_tempFile;
         m_tempFile = 0;
     }
 }
 
 QString File::tempFilePath() const
 {
     return m_tempFile ? m_tempFile->fileName() : QString();
 }
 
 QString File::error() const
 {
     return m_error;
 }
 
 void File::slotDownloadResult(KJob *job)
 {
     m_downloadInProgress = false;
     if (job->error()) {
         setType(Error);
         m_error = job->errorString();
         m_isLoaded = true;
     }
     else {
         m_isLoaded = true;
     }
 
     KIO::getJobTracker()->unregisterJob(job);
     job->deleteLater();
     m_job = 0;
 
     emit dataChanged();
 }
 
 void File::resultMimetypeJob(KJob *job)
 {
     if (!job->error()) {
         setMime(dynamic_cast<KIO::MimetypeJob *>(job)->mimetype());
         FileType t = getFileType(mime(), url().fileName());
         setType(t);
 
         // now that we know file type we can download file if necessary
         if(needDownload()) {
             if(m_isCurrent) {
                 download();
             }
         }
         else {
             m_isLoaded = true;
         }
     }
     else {
         setType(File::Error);
         m_isLoaded = true;
         m_error = job->errorString();
     }
 
     emit dataChanged();
 }
 
 void File::loadType()
 {
     if(!m_mimeJobStarted) {
         KIO::MimetypeJob *job = KIO::mimetype(url(), KIO::HideProgressInfo);
         connect(job, SIGNAL(result(KJob *)), SLOT(resultMimetypeJob(KJob*)));
         m_mimeJobStarted = true;
     }
 }
 
 File::FileType getFileType(const QString& mime, const QString& name)
 {
     static QList<QByteArray> supportedImageFormats = QImageReader::supportedImageFormats();
 
     // this method is a complete mess right now
     // information about supported types should not be hardcoded
     int delimiter = mime.indexOf('/');
 
     File::FileType type = File::MimetypeFallback;
 
     if (delimiter != -1) {
         QString left = mime.left(delimiter);
 
         if (left == QLatin1String("image")) {
             QString right = mime.mid(delimiter + 1);
             if (supportedImageFormats.contains(right.toLatin1()) || right == QLatin1String("x-xpixmap")
                     || right == QLatin1String("x-xpixmap") || right == QLatin1String("x-portable-bitmap")
                     || right == QLatin1String("x-portable-pixmap") || right == QLatin1String("x-portable-graymap")
                     || right == "x-xbitmap")
                 type = File::Image;
             else if (supportedImageFormats.contains("svg")
                      && (right == QLatin1String("svg+xml") || right == QLatin1String("svg+xml-compressed")))
                 type = File::Image;
         }
         else if (left == QLatin1String("video")) {
             QString right = mime.mid(delimiter + 1);
             // make a double check - for some reason isMimeTypeAvailable
             // does not always correct - but documentation lists it as a
             // preferred method to check it mimetype can bdecoded
             if (Phonon::BackendCapabilities::isMimeTypeAvailable(mime)
                     || Phonon::BackendCapabilities::availableMimeTypes().contains(mime)) {
                 type = File::Video;
             }
 
             if (type == File::MimetypeFallback) {
                 if (right == QLatin1String("3gpp")
                         || right == QLatin1String("mp4")
                         || right == QLatin1String("x-theora+ogg")) {
                     type = File::Video;
                 }
             }
         }
         else if (left == QLatin1String("audio")) {
             QString right = mime.mid(delimiter + 1);
 
             if (Phonon::BackendCapabilities::isMimeTypeAvailable(mime)) {
                 type = File::Audio;
             }
 
             if (type == File::MimetypeFallback) {
                 if (right == QLatin1String("ogg")
                         || right == QLatin1String("mpeg")
                         || right == QLatin1String("x-speex+ogg")
                         || right == QLatin1String("x-vorbis+ogg")
                         || right == QLatin1String("x-flac+ogg")) {
                     type = File::Audio;
                 }
             }
         }
         else if (left == QLatin1String("text")
                  || mime == QLatin1String("application/x-zerosize")
                  || mime == QLatin1String("application/x-shellscript")) {
             type = File::Txt;
         }
         else if(mime.mid(delimiter + 1) == QLatin1String("directory")) {
             type = File::Directory;
         }
     }
 
     if(mime == QLatin1String("application/pdf")
             || mime == QLatin1String("application/vnd.oasis.opendocument.text")
             || mime == QLatin1String("application/x-vnd.oasis.opendocument.text")
             || mime == QLatin1String("application/x-chm")
             || mime == QLatin1String("application/x-fictionbook+xml")
             || mime == QLatin1String("application/xhtml+xml")) {
         type = File::OkularFile;
     }
 
     if (type == File::MimetypeFallback) {
         if (mime == QLatin1String("application/x-matroska")
                 || mime == QLatin1String("application/vnd.rn-realmedia")) {
             type = File::Video;
         }
         else if (mime == QLatin1String("bmp")) {
             type = File::Image;
         }
         else if (mime == QLatin1String("application/octet-stream")) {
             QFileInfo fi(name);
             if (fi.suffix() == QLatin1String("mp3")
                     || fi.suffix() == QLatin1String("ogg"))
                 type = File::Audio;
         }
     }
     return type;
 }
diff --git a/src/filemodel.h b/src/filemodel.h
index f8d0f97..1ccb2db 100644
--- a/src/filemodel.h
+++ b/src/filemodel.h
@@ -1,78 +1,77 @@
 /* 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 FILEMODEL_H
 #define FILEMODEL_H
 
 #include <QtCore/QAbstractListModel>
 #include <QtCore/QList>
 #include <QtCore/QUrl>
 
 class File;
 class ListItem;
 class DirectoryItem;
 class QTimer;
 
 class FileModel : public QAbstractListModel
 {
   Q_OBJECT
 
 public:
     explicit FileModel(QObject* parent = 0);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const;
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
     bool setData (const QModelIndex & index, const QVariant & value, int role = Qt::EditRole);
 
-    const QHash<int, QByteArray> & roleNames () const;
     void appendRow(ListItem* item);
     void appendRows(QList<ListItem *> items);
     void refreshRow(int row);
     QModelIndex indexFromRowNumber(int row);
     void reset();
 
     void setRoleNames(const QHash<int,QByteArray> &roleNames) { QAbstractItemModel::setRoleNames(roleNames); }
 
     int rowFromFile(const File *file) const;
 
     void previewReady(const QString &path);
 
     Q_INVOKABLE void load(int row);
     Q_INVOKABLE File *file(int index) const;
     Q_INVOKABLE int count() const;
     Q_INVOKABLE QUrl url(int index) const;
     Q_INVOKABLE QString fileName(int index) const;
 
 private slots:
     void handleItemChange();
 
 signals:
     void gotPreview(QString path);
 
 private:
     QModelIndex indexFromItem(ListItem *item);
     ListItem* m_prototype;
     QList<ListItem*> m_list;
     File *m_currentLoadingFile;
 };
 
 #endif // FILEMODEL_H
diff --git a/src/klookapp.cpp b/src/klookapp.cpp
index 968a66e..fe24f4a 100644
--- a/src/klookapp.cpp
+++ b/src/klookapp.cpp
@@ -1,130 +1,131 @@
 /* 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 <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QGraphicsObject>
+#include <QtQuick/QQuickItem>
 
 #include <KCmdLineArgs>
 #include <KIcon>
 #include <KStandardDirs>
 #include <KUrl>
 
 #include "declarativeviewer.h"
 #include "filemodel.h"
 
 
 KLookApp::KLookApp()
     : KUniqueApplication()
     , m_viewer(0)
 {
 }
 
 KLookApp::~KLookApp()
 {
     delete m_viewer->m_fileModel;
 }
 
 bool KLookApp::isEmbeddedParam() const
 {
     KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
     return args->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")) {
         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();
         rc = QRect(x, y, w, h);
     }
     return rc;
 }
 
 QStringList KLookApp::urlsParam() 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();
     }
     return urls;
 }
 
 int KLookApp::newInstance()
 {
     KCmdLineArgs::setCwd(QDir::currentPath().toUtf8());
     KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
 
     QStringList urls = urlsParam();
     QRect rc = rectParam();
     bool embedded = isEmbeddedParam();
 
     int index = args->getOption("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();
         }
 
         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();
     return 0;
 }
 
 bool KLookApp::isLocal() const
 {
     const QString appPath = applicationFilePath();
     return !(appPath.startsWith(QLatin1String("/usr/bin")) || appPath.startsWith(QLatin1String("/usr/local/bin")));
 }
diff --git a/src/kpartsdeclarativeitem.h b/src/kpartsdeclarativeitem.h
index fd8519f..6f4e169 100644
--- a/src/kpartsdeclarativeitem.h
+++ b/src/kpartsdeclarativeitem.h
@@ -1,26 +1,26 @@
 #ifndef KPARTSDECLARATIVEITEM_H
 #define KPARTSDECLARATIVEITEM_H
 
-#include <QtGui/QGraphicsProxyWidget>
+#include <QGraphicsProxyWidget>
 
 class KPartsWidget;
 
 class KPartsDeclarativeItem : public QGraphicsProxyWidget
 {
     Q_OBJECT
 
     Q_PROPERTY(QString url READ url WRITE setUrl NOTIFY urlChanged)
 public:
     explicit KPartsDeclarativeItem(QGraphicsItem * parent = 0, Qt::WindowFlags wFlags = 0);
 
     Q_INVOKABLE QString url() const;
     Q_INVOKABLE void setUrl(QString url);
 
 signals:
     void urlChanged();
 
 private:
     KPartsWidget *m_partWidget;
 };
 
 #endif // KPARTSDECLARATIVEITEM_H
diff --git a/src/kpartswidget.cpp b/src/kpartswidget.cpp
index 5fccf8f..dd31cd3 100644
--- a/src/kpartswidget.cpp
+++ b/src/kpartswidget.cpp
@@ -1,76 +1,77 @@
 /* KLook
  * Copyright (c) 2012 ROSA  <support@rosalab.ru>
  * Authors: 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 "kpartswidget.h"
 
-#include <QtGui/QDesktopWidget>
+#include <QtWidgets/QDesktopWidget>
 
 #include <KToolBar>
+#include <KDE/KGlobal>
 
 KPartsWidget::KPartsWidget(QWidget *parent)
     : KParts::MainWindow(parent, static_cast<Qt::WindowFlags>(KDE_DEFAULT_WINDOWFLAGS))
 {
     m_service = KService::serviceByDesktopPath("okular_part.desktop");
 
     // because we don't have KMainWindow in KLook
     // but use it for Okular integration klook tries
     // to exit when okular's window is deleted
     KGlobal::setAllowQuit(false);
 
     if(m_service) {
         m_part = m_service->createInstance<KParts::ReadOnlyPart>(0, QVariantList() << "Print/Preview");
         if(m_part) {
             setCentralWidget(m_part->widget());
             // we don't need toolabrs being shown
             foreach(KToolBar *toolbar, toolBars())
                 toolbar->hide();
         }
     }
 }
 
 void KPartsWidget::setUrl(const QString &url)
 {
     if(m_part) {
         m_part->openUrl(url);
     }
 }
 
 QStringList KPartsWidget::supportedMimeTypes() const
 {
     return QStringList();
 }
 
 QSize getDocumentWindowSize()
 {
     QDesktopWidget dw;
     QSize size;
 
     if (dw.height() < dw.width()) {
         size.setHeight(dw.height() * 0.8);
         size.setWidth(size.height () / 1.4142 + 40  * 1.4142);
     }
     else {
         size.setWidth(dw.width() * 0.8);
         size.setHeight(size.width() * 1.4142);
         size.setWidth(size.width() + 40); // caption
     }
     return size;
 }
diff --git a/src/kpartswidget.h b/src/kpartswidget.h
index 721f50a..031c045 100644
--- a/src/kpartswidget.h
+++ b/src/kpartswidget.h
@@ -1,28 +1,29 @@
 #ifndef KPARTSWIDGET_H
 #define KPARTSWIDGET_H
 
-#include <kparts/mainwindow.h>
+#include <KParts/MainWindow>
+#include <KParts/ReadOnlyPart>
 
 #include <QtCore/QPointer>
 
 #include <KService>
 
 class KPartsWidget : public KParts::MainWindow
 {
     Q_OBJECT
 public:
     KPartsWidget(QWidget *parent = 0);
 
     QString url() const { return m_part->url().url(); }
     void setUrl(const QString &url);
 
     QStringList supportedMimeTypes() const;
 
 private:
     QPointer<KParts::ReadOnlyPart> m_part;
     KService::Ptr m_service;
 };
 
 QSize getDocumentWindowSize();
 
 #endif // KPARTSWIDGET_H
diff --git a/src/listitemcontent.cpp b/src/listitemcontent.cpp
index 5e8beee..95e13f1 100644
--- a/src/listitemcontent.cpp
+++ b/src/listitemcontent.cpp
@@ -1,115 +1,116 @@
 /* KLook
  * Copyright (c) 2012 ROSA  <support@rosalab.ru>
  * Authors: 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 "listitemcontent.h"
 #include "listitem.h"
 #include "file.h"
 
 #include <kio/directorysizejob.h>
 #include <KIO/StatJob>
 #include <KLocale>
+#include <KDE/KGlobal>
 
 ListItemContent::ListItemContent(File *file, QObject *parent)
     : QObject(parent)
     , m_file(file)
 {
 }
 
 File *ListItemContent::file() const
 {
     return m_file;
 }
 
 ListItemFallbackContent::ListItemFallbackContent(File *file, QObject *parent)
     : ListItemContent(file, parent), m_size(0), m_statComplete(false)
 {
     KIO::StatJob *job = KIO::stat(file->url(),	KIO::StatJob::DestinationSide, 3, KIO::HideProgressInfo);
     connect(job, SIGNAL(result(KJob*)), SLOT(handleStatJob(KJob*)));
 }
 
 QVariant ListItemFallbackContent::data(int role) const
 {
     if (role == ListItem::LastModifiedRole) {
         QString modificationDate = m_modificationTime.date().isNull()
                 ? i18nc("Unknown modification date", "Unknown")
                 : KGlobal::locale()->formatDate(m_modificationTime.date());
         return modificationDate;
     }
     else if (role == ListItem::ContentSizeRole) {
         return KGlobal::locale()->formatByteSize(m_size);
     }
     else if(role == ListItem::StatCompleteRole) {
         return m_statComplete;
     }
 
     return QVariant();
 }
 
 void ListItemFallbackContent::handleStatJob(KJob *job)
 {
     if(job && !job->error()) {
         const KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
         m_size = entry.numberValue(KIO::UDSEntry::UDS_SIZE);
         time_t mtime = entry.numberValue(KIO::UDSEntry::UDS_MODIFICATION_TIME, -1);
         if (mtime != -1) {
             m_modificationTime = QDateTime::fromTime_t(mtime);
         }
         m_statComplete = true;
         emit dataChanged();
     }
 }
 
 ListItemDirectoryContent::ListItemDirectoryContent(File *file, QObject *parent)
     : ListItemFallbackContent(file, parent)
     , m_isScanned(false)
     , m_totalFiles(0)
     , m_totalSize(0)
 {
     KIO::DirectorySizeJob *job = KIO::directorySize(file->url());
     connect(job, SIGNAL(result(KJob *)), SLOT(handleDirSizeJob(KJob *)));
 }
 
 QVariant ListItemDirectoryContent::data(int role) const
 {
     switch (role) {
     case ListItem::DirSizeCompleteRole:
         return m_isScanned;
 
     case ListItem::ContentSizeRole:
         return KGlobal::locale()->formatByteSize(m_totalSize);
 
     case ListItem::CountRole:
         return QString::number(m_totalFiles);
     }
 
     return ListItemFallbackContent::data(role);
 }
 
 void ListItemDirectoryContent::handleDirSizeJob(KJob *job)
 {
     KIO::DirectorySizeJob *dirSizeJob = dynamic_cast<KIO::DirectorySizeJob *>(job);
     if(dirSizeJob && !dirSizeJob->error()) {
         m_totalFiles = dirSizeJob->totalFiles();
         m_totalSize = dirSizeJob->totalSize();
         m_isScanned = true;
         emit dataChanged();
     }
 }
diff --git a/src/main.cpp b/src/main.cpp
index d2cc4ca..5042b49 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,72 +1,72 @@
 /* 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 <KAboutData>
-#include <KCmdLineArgs>
+#include <KDE/K4AboutData>
+#include <KDE/KCmdLineArgs>
 #include <KLocale>
 
 #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[])
 {
-    KAboutData about("klook", "klook", ki18n("KLook"),
-                      version, ki18n(description), KAboutData::License_GPL_V3,
+    K4AboutData about("klook", "klook", ki18n("KLook"),
+                      version, ki18n(description),  K4AboutData::License_GPL_V3,
                       ki18n("(c) ROSA 2011-2012"));
 
     about.addAuthor(ki18n("Julia Mineeva"),
                      ki18n("Developer"),
                      "julia.mineeva@osinit.ru");
 
     about.addAuthor(ki18n("Evgeniy Auzhin"),
                      ki18n("Developer"),
                      "evgeniy.augin@osinit.ru");
 
     about.addAuthor(ki18n("Sergey Borovkov"),
                      ki18n("Developer"),
                      "sergey.borovkov@osinit.ru");
 
     about.setProgramIconName("klook");
 
     KCmdLineArgs::init(argc, argv, &about);
 
     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);
 
     KCmdLineArgs::addCmdLineOptions(options);
     if (!KUniqueApplication::start()) {
         fprintf(stderr, "KLook is already running!\n");
         return 0;
     }
 
     KLookApp a;
     return a.exec();
 }
diff --git a/src/mimeprovider.cpp b/src/mimeprovider.cpp
index 7b9bc8b..876d1a0 100644
--- a/src/mimeprovider.cpp
+++ b/src/mimeprovider.cpp
@@ -1,40 +1,40 @@
 /* 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 "mimeprovider.h"
 
 #include <KIcon>
 #include <KMimeType>
 
 MimeProvider::MimeProvider()
-    : QDeclarativeImageProvider(Pixmap)
+    : QQuickImageProvider(Pixmap)
 {
 }
 
 QPixmap MimeProvider::requestPixmap(const QString& id, QSize* size, const QSize &requestedSize)
 {
     KIcon icon(KMimeType::iconNameForUrl(id));
 
     QPixmap pixmap = icon.isNull() ? QPixmap(":images/pla-empty-box.png") : icon.pixmap(requestedSize);
     *size = pixmap.size();
 
     return pixmap;
 }
diff --git a/src/mimeprovider.h b/src/mimeprovider.h
index 5e6440d..07dcf47 100644
--- a/src/mimeprovider.h
+++ b/src/mimeprovider.h
@@ -1,35 +1,35 @@
 /* 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 MIMEPROVIDER_H
 #define MIMEPROVIDER_H
 
 
-#include <QtDeclarative/QDeclarativeImageProvider>
+#include <QtQuick/QQuickImageProvider>
 
-class MimeProvider : public QDeclarativeImageProvider
+class MimeProvider : public QQuickImageProvider
 {
 public:
     MimeProvider();
     QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize);
 };
 
 #endif // MIMEPROVIDER_H
diff --git a/src/previewgenerator.cpp b/src/previewgenerator.cpp
index 541e10f..85d6fcf 100644
--- a/src/previewgenerator.cpp
+++ b/src/previewgenerator.cpp
@@ -1,112 +1,114 @@
  /* 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 "previewgenerator.h"
 #include "filemodel.h"
 
 #include <QtCore/QStringList>
 #include <QtGui/QPainter>
 
 #include <KIO/PreviewJob>
 #include <KFile>
 #include <KIcon>
+#include <KUrl>
+#include <kmimetype.h>
 
 PreviewGenerator::PreviewGenerator()
     : m_plugins(KIO::PreviewJob::availablePlugins())
     , m_model(0)
 {
     videoPixmap.load(":/images/play-empty.png");
     m_plugins.removeAll("directorythumbnail");
 }
 
 void PreviewGenerator::setModel(FileModel *model)
 {
     m_model = model;
 }
 
 void PreviewGenerator::notifyModelAboutPreview(const QString &url)
 {
     if (m_model) {
         m_model->previewReady(url);
     }
 }
 
 void PreviewGenerator::previewJobResult(const KFileItem &item, const QPixmap &pixmap)
 {
     QPixmap pict = pixmap;
     if (item.mimetype().startsWith(QLatin1String("video/"))) {
         QPainter p(&pict);
         QPixmap scaledPixmap = videoPixmap.scaled(pict.width() / 2, pict.height() / 2,  Qt::KeepAspectRatio, Qt::SmoothTransformation);
         p.drawPixmap(pict.width() / 2 - scaledPixmap.width() / 2, pict.height() / 2 - scaledPixmap.height() / 2 ,  scaledPixmap);
     }
 
     m_previews.insert(item.url().url(), pict);
     notifyModelAboutPreview(item.url().url());
 }
 
 void PreviewGenerator::previewJobFailed(const KFileItem &item)
 {
     KIcon icon(KMimeType::iconNameForUrl(item.url()));
     QPixmap pixmap = icon.isNull() ? QPixmap(":images/pla-empty-box.png") : icon.pixmap(500);
 
     m_previews.insert(item.url().url(), pixmap);
     notifyModelAboutPreview(item.url().url());
 }
 
 QPixmap PreviewGenerator::takePreviewPixmap(QString filePath)
 {
     QHash<QString, QPixmap>::iterator it = m_previews.find(KUrl(filePath).url());
     if (it != m_previews.end()) {
         QPixmap pixmap = it.value();
         m_previews.erase(it);
         return pixmap;
     }
 
     return QPixmap();
 }
 
 void PreviewGenerator::request(const QString &path, const QSize &size)
 {
     KFileItemList fileList;
     KFileItem fileItem(KFileItem::Unknown, KFileItem::Unknown, KUrl(path), true);
     fileList.append(fileItem);
 
     KIO::PreviewJob *job = KIO::filePreview(fileList, size, &m_plugins);
     job->setIgnoreMaximumSize();
     job->setAutoDelete(true);
 
     connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)), SLOT(previewJobResult(const KFileItem&, const QPixmap&)));
     connect(job, SIGNAL(failed(const KFileItem&)), SLOT(previewJobFailed(const KFileItem &)));
 }
 
 void PreviewGenerator::cancel(const QString &path)
 {
     m_previews.remove(path);
 }
 
 PreviewGenerator *PreviewGenerator::instance()
 {
     static PreviewGenerator* previewGenerator = 0;
     if(!previewGenerator) {
         previewGenerator = new PreviewGenerator;
     }
     return previewGenerator;
 }
diff --git a/src/previewprovider.cpp b/src/previewprovider.cpp
index 942d6db..8d79986 100644
--- a/src/previewprovider.cpp
+++ b/src/previewprovider.cpp
@@ -1,53 +1,53 @@
 /* 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 "previewprovider.h"
 #include "previewgenerator.h"
 
 PreviewProvider::PreviewProvider()
-    : QDeclarativeImageProvider(Pixmap)
+    : QQuickImageProvider(Pixmap)
     , m_defaultPreview(":images/pla-empty-box.png")
     , m_previewGenerator(PreviewGenerator::instance())
 {
 }
 
 QPixmap PreviewProvider::requestPixmap(const QString& id, QSize* size, const QSize &requestedSize)
 {
     QString str = id.left(id.lastIndexOf('%'));
     QPixmap pixmap = m_previewGenerator->takePreviewPixmap(str);
 
     if(pixmap.isNull()) {
         QSize size = requestedSize.isValid() ? requestedSize : QSize();
         m_previewGenerator->request(str, size);
         return m_defaultPreview.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     // only scale down
     if (requestedSize.isValid() && (requestedSize.width() < pixmap.width() || requestedSize.height() < pixmap.height())) {
         pixmap = pixmap.scaled(requestedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     if (size) {
         *size = pixmap.size();
     }
 
     return pixmap;
 }
diff --git a/src/previewprovider.h b/src/previewprovider.h
index 44eea1a..c639373 100644
--- a/src/previewprovider.h
+++ b/src/previewprovider.h
@@ -1,40 +1,40 @@
 /* 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 PREVIEWPROVIDER_H
 #define PREVIEWPROVIDER_H
 
-#include <QtDeclarative/QDeclarativeImageProvider>
+#include <QtQuick/QQuickImageProvider>
 
 class PreviewGenerator;
 
-class PreviewProvider : public QDeclarativeImageProvider
+class PreviewProvider : public QQuickImageProvider
 {
 public:
     PreviewProvider();
     QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize);
 
 private:
     QPixmap m_defaultPreview;
     PreviewGenerator *m_previewGenerator;
 };
 
 #endif // PREVIEWPROVIDER_H
diff --git a/src/text.cpp b/src/text.cpp
index a6032d1..1f7892a 100644
--- a/src/text.cpp
+++ b/src/text.cpp
@@ -1,93 +1,93 @@
 /* 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 "text.h"
 
 #include <QtCore/QFile>
 #include <QtCore/QTextCodec>
-#include <QtGui/QPlainTextEdit>
+#include <QtWidgets/QPlainTextEdit>
 
 #include <KEncodingProber>
 #include <KImageCache>
 
 MyText::MyText(QGraphicsItem* parent)
     : QGraphicsProxyWidget(parent)
     , m_isPreview(false)
 {
     m_viewer = new QPlainTextEdit();
     m_viewer->setReadOnly(true);
     m_viewer->viewport()->setCursor(Qt::ArrowCursor);
     m_viewer->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     setWidget(m_viewer);
 }
 
 MyText::~MyText()
 {
 }
 
 QString MyText::source() const
 {
     return m_source;
 }
 
 void MyText::setSource(const QString& source)
 {
     if (m_source == source) {
         return;
     }
     m_source = source;
 
     QFile f(m_source);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         return;
     }
 
     QByteArray data = f.readAll().data();
     KEncodingProber prober(KEncodingProber::Universal);
     prober.feed(data);
 
     QString str;
     if (prober.confidence() > 0.7) {
         str = QTextCodec::codecForName(prober.encoding())->toUnicode(data);
     }
     else {
         str = QString::fromUtf8(data);
     }
 
     m_viewer->setPlainText(str);
 
     emit sourceChanged();
     emit ready();
 }
 
 bool MyText::isPreview() const
 {
     return m_isPreview;
 }
 
 void MyText::setPreview(bool preview)
 {
     m_isPreview = preview;
     Qt::ScrollBarPolicy policy = m_isPreview ? Qt::ScrollBarAlwaysOff : Qt::ScrollBarAsNeeded;
     m_viewer->setVerticalScrollBarPolicy(policy);
     m_viewer->setHorizontalScrollBarPolicy(policy);
 }
diff --git a/src/video.cpp b/src/video.cpp
index 65c8d5e..9179db3 100644
--- a/src/video.cpp
+++ b/src/video.cpp
@@ -1,195 +1,196 @@
 /* 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 "video.h"
 
 
-#include <QtGui/QHBoxLayout>
+#include <QtWidgets/QHBoxLayout>
+#include <QtWidgets/QWidget>
 
-#include <Phonon/AudioOutput>
-#include <Phonon/MediaObject>
-#include <Phonon/VideoWidget>
+#include <KDE/Phonon/AudioOutput>
+#include <KDE/Phonon/MediaObject>
+#include <KDE/Phonon/VideoWidget>
 
 Video::Video(QGraphicsItem* parent)
     : QGraphicsProxyWidget(parent)
     , m_player(0)
     , m_layout(0)
     , m_videoWidth(640)
     , m_videoHeight(480)
     , m_isPreview(false)
     , m_isReady(false)
 {
     m_wid = new QWidget();
 
     m_player = new Phonon::VideoPlayer(Phonon::VideoCategory, m_wid);
     m_player->setAttribute(Qt::WA_NoSystemBackground);
     m_player->mediaObject()->setTickInterval(1000);
 
     m_layout = new QHBoxLayout();
     m_layout->setMargin(0);
     m_layout->addWidget(m_player);
     m_wid->setLayout(m_layout);
     setWidget(m_wid);
 
     connect(m_player->mediaObject(), SIGNAL(tick(qint64)), SLOT(onTicked(qint64)));
     connect(m_player->mediaObject(), SIGNAL(totalTimeChanged(qint64)), SLOT(onTotalTimeChanged(qint64)));
     connect(m_player->mediaObject(), SIGNAL(finished()), SLOT(onFinished()));
     connect(m_player->mediaObject(), SIGNAL(metaDataChanged()), SLOT(onMetaDataChanged()));
     connect(m_player->mediaObject(), SIGNAL(stateChanged(Phonon::State, Phonon::State)),
                       SLOT(stateChanged(Phonon::State,Phonon::State)));
 }
 
 Video::~Video()
 {
 
 }
 
 void Video::setPause()
 {
     if (!isVisible()) {
         pause();
     }
     else {
         play();
     }
 }
 
 bool Video::isReady()
 {
     return m_isReady;
 }
 
 void Video::setReady(bool b)
 {
     m_isReady = b;
     emit ready();
 }
 
 void Video::onFinished()
 {
     emit playFinished();
     setPosition(0);
 }
 
 bool Video::muted() const
 {
     return m_player->audioOutput()->isMuted();
 }
 
 void Video::setMuted(bool m)
 {
     // !!!! Doesnt't work in phonon !!!!!
     m_player->audioOutput()->setMuted(m);
 }
 
 QString Video::source() const
 {
     return m_player->mediaObject()->currentSource().url().toString();
 }
 
 void Video::setSource(const KUrl &source)
 {
     m_player->mediaObject()->setCurrentSource(source);
     emit sourceChanged();
 }
 
 void Video::onMetaDataChanged()
 {
     m_videoWidth = m_player->videoWidget()->sizeHint().width();
     m_videoHeight = m_player->videoWidget()->sizeHint().height();
     QObject::disconnect(m_player->mediaObject(), SIGNAL(metaDataChanged()), this, SLOT(onMetaDataChanged()));
     emit sizeHintReady(m_videoWidth, m_videoHeight);
 }
 
 qlonglong Video::position() const
 {
     return m_player->mediaObject()->currentTime();
 }
 
 void Video::setPosition(qlonglong pos)
 {
     m_player->mediaObject()->seek(pos);
     emit positionChanged();
 }
 
 qlonglong Video::totalTime() const
 {
     return m_player->mediaObject()->totalTime();
 }
 
 void Video::onTotalTimeChanged(qint64 t)
 {
     Q_UNUSED(t)
     emit totalTimeChanged();
 }
 
 void Video::onTicked(qint64 t)
 {
     emit ticked(QVariant(t));
 }
 
 bool Video::playing() const
 {
     return m_player->isPlaying();
 }
 
 bool Video::paused() const
 {
     return m_player->isPaused();
 }
 
 void Video::play()
 {
     m_player->play();
 }
 
 void Video::pause()
 {
     m_player->pause();
 }
 
 void Video::play_or_pause()
 {
     if (m_player->isPlaying()) {
         m_player->pause();
     }
     else {
         m_player->play();
     }
 }
 
 bool Video::isPreview() const
 {
     return m_isPreview;
 }
 
 void Video::setPreview(bool preview)
 {
     m_isPreview = preview;
 }
 
 void Video::stateChanged(Phonon::State newState, Phonon::State oldState)
 {
     Q_UNUSED(newState)
     if ((oldState == Phonon::LoadingState) || (oldState == Phonon::StoppedState)) {
         setReady(true);
     }
 }
diff --git a/src/video.h b/src/video.h
index 8c524aa..5d61807 100644
--- a/src/video.h
+++ b/src/video.h
@@ -1,111 +1,111 @@
 /* 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 VIDEO_H
 #define VIDEO_H
 
 #include <QGraphicsProxyWidget>
-#include <Phonon/VideoPlayer>
+#include <KDE/Phonon/VideoPlayer>
 #include <KUrl>
 
 class QHBoxLayout;
 
 
 class Video : public QGraphicsProxyWidget
 {
     Q_OBJECT
     Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)
     Q_PROPERTY(bool playing READ playing)
     Q_PROPERTY(bool paused READ paused)
     Q_PROPERTY(bool muted READ muted WRITE setMuted)
     Q_PROPERTY(qlonglong totalTime READ totalTime NOTIFY totalTimeChanged)
     Q_PROPERTY(qlonglong position READ position WRITE setPosition NOTIFY positionChanged)
     Q_PROPERTY(int videoWidth READ videoWidth)
     Q_PROPERTY(int videoHeight READ videoHeight)
     Q_PROPERTY(bool preview READ isPreview WRITE setPreview)
     Q_PROPERTY(bool ready READ isReady WRITE setReady NOTIFY ready)
 
 public:
     Video(QGraphicsItem* parent = 0);
     ~Video();
 
 public slots:
     QString source() const;
     void setSource(const KUrl& source);
 
     bool playing() const;
     bool paused() const;
     void setPause();
 
     bool isReady();
     void setReady(bool b);
 
     bool muted() const;
     void setMuted(bool m);
 
     int videoWidth() const { return m_videoWidth; }
     int videoHeight() const { return m_videoHeight; }
 
     qlonglong totalTime() const;
 
     qlonglong position() const;
     void setPosition(qlonglong pos);
 
     void play_or_pause();
     void play();
     void pause();
 
     void onTotalTimeChanged(qint64);
     void onTicked(qint64);
 
     void onFinished();
 
     void onMetaDataChanged();
     void stateChanged(Phonon::State oldState, Phonon::State newState);
 
     bool isPreview() const;
     void setPreview(bool preview);
 
 signals:
     void clicked(bool);
     void sourceChanged();
     void totalTimeChanged();
     void positionChanged();
     void ticked(QVariant tick);
     void playFinished();
     void ready();
     void sizeHintReady(int width, int height);
 
 private:
     Phonon::VideoPlayer* m_player;
 
     QWidget*        m_wid;
     QHBoxLayout*    m_layout;
 
     int m_videoWidth;
     int m_videoHeight;
 
     bool m_isPreview;
     bool m_isReady;
 };
 
 #endif // VIDEO_H