diff --git a/.gitignore b/.gitignore index bf0c94f..9824d93 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ /kdelibs-4.6.5.tar.bz2 -/kdelibs-4.8.2.tar.xz +/kdelibs-4.8.3.tar.xz diff --git a/kdelibs-4.8.0-cmake_cxx_implicit_link_directories.patch b/kdelibs-4.8.0-cmake_cxx_implicit_link_directories.patch deleted file mode 100644 index 0b7f7c3..0000000 --- a/kdelibs-4.8.0-cmake_cxx_implicit_link_directories.patch +++ /dev/null @@ -1,22 +0,0 @@ -diff --git a/cmake/modules/FindKDE4Internal.cmake b/cmake/modules/FindKDE4Internal.cmake -index 6d65e61..700d265 100644 ---- a/cmake/modules/FindKDE4Internal.cmake -+++ b/cmake/modules/FindKDE4Internal.cmake -@@ -1036,12 +1036,13 @@ if (UNIX) - set(CMAKE_INSTALL_NAME_DIR ${LIB_INSTALL_DIR}) - else (APPLE) - # add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the standard system link -- # directories listed in CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling -+ # directories listed in CMAKE_{PLATFORM,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling - -- list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemLibDir) -- if("${_isSystemLibDir}" STREQUAL "-1") -+ list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemPlatformLibDir) -+ list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir) -+ if("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1") - set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}") -- endif("${_isSystemLibDir}" STREQUAL "-1") -+ endif("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1") - - set(CMAKE_SKIP_BUILD_RPATH FALSE) - set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) diff --git a/kdelibs-4.8.2-udisks2_prep.patch b/kdelibs-4.8.2-udisks2_prep.patch new file mode 100644 index 0000000..2962837 --- /dev/null +++ b/kdelibs-4.8.2-udisks2_prep.patch @@ -0,0 +1,65 @@ +diff -up kdelibs-4.8.2/solid/solid/CMakeLists.txt.udisks2_prep kdelibs-4.8.2/solid/solid/CMakeLists.txt +--- kdelibs-4.8.2/solid/solid/CMakeLists.txt.udisks2_prep 2011-07-27 13:34:38.000000000 -0500 ++++ kdelibs-4.8.2/solid/solid/CMakeLists.txt 2012-04-17 16:02:06.153985974 -0500 +@@ -1,6 +1,7 @@ + set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} ) + add_subdirectory( ifaces ) + include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ) ++include_directories( ${QT_QTDBUS_INCLUDE_DIR} ) + + if(WIN32) + include_directories( ${KDEWIN_INCLUDES} ) +diff -up kdelibs-4.8.2/solid/solid/managerbase.cpp.udisks2_prep kdelibs-4.8.2/solid/solid/managerbase.cpp +--- kdelibs-4.8.2/solid/solid/managerbase.cpp.udisks2_prep 2011-07-27 13:34:39.000000000 -0500 ++++ kdelibs-4.8.2/solid/solid/managerbase.cpp 2012-04-17 16:02:06.154985961 -0500 +@@ -21,7 +21,7 @@ + #include "managerbase_p.h" + + #include +-#if !defined (Q_WS_WIN) && !defined (Q_OS_MAC) ++#if !defined (Q_OS_WIN) && !defined (Q_OS_MAC) + #include + #endif + +@@ -44,7 +44,7 @@ + + #include "backends/fstab/fstabmanager.h" + +-#elif defined (Q_WS_WIN) && defined(HAVE_WBEM) && !defined(_WIN32_WCE) ++#elif defined (Q_OS_WIN) && defined(HAVE_WBEM) && !defined(_WIN32_WCE) + #include "backends/wmi/wmimanager.h" + #endif + +@@ -68,7 +68,7 @@ void Solid::ManagerBasePrivate::loadBack + # if defined(Q_OS_MAC) + m_backends << new Solid::Backends::IOKit::IOKitManager(0); + +-# elif defined(Q_WS_WIN) && defined(HAVE_WBEM) && !defined(_WIN32_WCE) ++# elif defined(Q_OS_WIN) && defined(HAVE_WBEM) && !defined(_WIN32_WCE) + m_backends << new Solid::Backends::Wmi::WmiManager(0); + + # elif defined(Q_OS_UNIX) && !defined(Q_OS_LINUX) +diff -up kdelibs-4.8.2/solid/tests/CMakeLists.txt.udisks2_prep kdelibs-4.8.2/solid/tests/CMakeLists.txt +--- kdelibs-4.8.2/solid/tests/CMakeLists.txt.udisks2_prep 2011-10-20 15:52:04.000000000 -0500 ++++ kdelibs-4.8.2/solid/tests/CMakeLists.txt 2012-04-17 16:02:44.584505527 -0500 +@@ -16,20 +16,6 @@ target_link_libraries(fakehardwaretest s + add_definitions(-DTEST_DATA="\\"${CMAKE_CURRENT_SOURCE_DIR}/../solid/backends/fakehw/fakecomputer.xml\\"") + + +-########### halbasictest ############### +- +-if(NOT WIN32 AND NOT APPLE) +-set(halbasictest_SRCS halbasictest.cpp ) +- +-kde4_add_executable(halbasictest ${halbasictest_SRCS}) +- +-if(WIN32) +- set_target_properties(halbasictest PROPERTIES COMPILE_FLAGS -DSOLID_EXPORT=) +-endif(WIN32) +- +-target_link_libraries(halbasictest solid_static ${KDEWIN_LIBRARIES} ${QT_QTCORE_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTTEST_LIBRARY} ) +-endif(NOT WIN32 AND NOT APPLE) +- + ########### solidhwtest ############### + + set(solidhwtest_SRCS diff --git a/kdelibs-4.8.3-kdeclarative-install-location.patch b/kdelibs-4.8.3-kdeclarative-install-location.patch new file mode 100644 index 0000000..ace5462 --- /dev/null +++ b/kdelibs-4.8.3-kdeclarative-install-location.patch @@ -0,0 +1,13 @@ +diff -up kdelibs-4.8.3/experimental/libkdeclarative/CMakeLists.txt.kdeclarative-install-location kdelibs-4.8.3/experimental/libkdeclarative/CMakeLists.txt +--- kdelibs-4.8.3/experimental/libkdeclarative/CMakeLists.txt.kdeclarative-install-location 2012-04-29 22:37:35.777207066 +0200 ++++ kdelibs-4.8.3/experimental/libkdeclarative/CMakeLists.txt 2012-04-30 12:20:40.384393056 +0200 +@@ -6,6 +6,9 @@ endif(KDE_PLATFORM_FEATURE_BINARY_COMPAT + + configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kdeclarative.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kdeclarative.h) + ++set (LIB_SUFFIX "" CACHE STRING "Define suffix of library directory name (eg. '64')") ++set( LIB_INSTALL_DIR lib${LIB_SUFFIX} ) ++ + include_directories( + ${CMAKE_SOURCE_DIR} + ${CMAKE_BINARY_DIR} diff --git a/kdelibs-udisks2-backend.patch b/kdelibs-udisks2-backend.patch new file mode 100644 index 0000000..b7a71f5 --- /dev/null +++ b/kdelibs-udisks2-backend.patch @@ -0,0 +1,3661 @@ +diff --git a/tier1/solid/src/solid/CMakeLists.txt b/tier1/solid/src/solid/CMakeLists.txt +index 5deadcf..40af6bc 100644 +--- a/tier1/solid/src/solid/CMakeLists.txt ++++ b/tier1/solid/src/solid/CMakeLists.txt +@@ -32,7 +32,6 @@ configure_file(config-processor.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-proce + + file(MAKE_DIRECTORY + ${CMAKE_CURRENT_BINARY_DIR}/backends/fakehw +- ${CMAKE_CURRENT_BINARY_DIR}/backends/hal + ${CMAKE_CURRENT_BINARY_DIR}/backends/udev + ${CMAKE_CURRENT_BINARY_DIR}/backends/wmi + ) +@@ -198,33 +197,6 @@ if(NOT WIN32 AND NOT APPLE) + endif( UDEV_FOUND ) + + +- message(STATUS "Building Solid HAL backend." ) +- set(solid_LIB_SRCS ${solid_LIB_SRCS} +- backends/hal/halacadapter.cpp +- backends/hal/halaudiointerface.cpp +- backends/hal/halbattery.cpp +- backends/hal/halblock.cpp +- backends/hal/halbutton.cpp +- backends/hal/halcamera.cpp +- backends/hal/halcdrom.cpp +- backends/hal/haldeviceinterface.cpp +- backends/hal/haldvbinterface.cpp +- backends/hal/halfstabhandling.cpp +- backends/hal/halgenericinterface.cpp +- backends/hal/haldevice.cpp +- backends/hal/halmanager.cpp +- backends/hal/halnetworkinterface.cpp +- backends/hal/halserialinterface.cpp +- backends/hal/halopticaldisc.cpp +- backends/hal/halportablemediaplayer.cpp +- backends/hal/halprocessor.cpp +- backends/hal/halstorageaccess.cpp +- backends/hal/halstorage.cpp +- backends/hal/halvideo.cpp +- backends/hal/halvolume.cpp +- backends/hal/halsmartcardreader.cpp +- ) +- + message(STATUS "Building Solid UPower backend." ) + set(solid_LIB_SRCS ${solid_LIB_SRCS} + backends/upower/upowermanager.cpp +@@ -237,18 +209,19 @@ if(NOT WIN32 AND NOT APPLE) + + # FIXME: this should work on more Unix systems + if (CMAKE_SYSTEM_NAME MATCHES Linux) +- message(STATUS "Building Solid UDisks backend." ) ++ message(STATUS "Building Solid UDisks2 backend." ) + set(solid_LIB_SRCS ${solid_LIB_SRCS} +- backends/udisks/udisksmanager.cpp +- backends/udisks/udisksdevice.cpp +- backends/udisks/udisksblock.cpp +- backends/udisks/udisksstoragevolume.cpp +- backends/udisks/udisksdeviceinterface.cpp +- backends/udisks/udisksopticaldisc.cpp +- backends/udisks/udisksopticaldrive.cpp +- backends/udisks/udisksstoragedrive.cpp +- backends/udisks/udisksstorageaccess.cpp +- backends/udisks/udisksgenericinterface.cpp ++ backends/udisks2/udisksmanager.cpp ++ backends/udisks2/udisksdevice.cpp ++ backends/udisks2/udisksblock.cpp ++ backends/udisks2/udisksstoragevolume.cpp ++ backends/udisks2/udisksdeviceinterface.cpp ++ backends/udisks2/udisksopticaldisc.cpp ++ backends/udisks2/udisksopticaldrive.cpp ++ backends/udisks2/udisksstoragedrive.cpp ++ backends/udisks2/udisksstorageaccess.cpp ++ backends/udisks2/udisksgenericinterface.cpp ++ backends/udisks2/dbus/manager.cpp + ) + endif (CMAKE_SYSTEM_NAME MATCHES Linux) + +diff --git a/tier1/solid/src/solid/managerbase.cpp b/tier1/solid/src/solid/managerbase.cpp +index e228b48..7a7cc7d 100644 +--- a/tier1/solid/src/solid/managerbase.cpp ++++ b/tier1/solid/src/solid/managerbase.cpp +@@ -30,8 +30,7 @@ + #if defined (Q_OS_MAC) + #include "backends/iokit/iokitmanager.h" + #elif defined (Q_OS_UNIX) +-#include "backends/hal/halmanager.h" +-#include "backends/udisks/udisksmanager.h" ++#include "backends/udisks2/udisksmanager.h" + #include "backends/upower/upowermanager.h" + + #if defined (HUPNP_FOUND) +@@ -71,22 +70,13 @@ void Solid::ManagerBasePrivate::loadBackends() + # elif defined(Q_OS_WIN) && defined(HAVE_WBEM) && !defined(_WIN32_WCE) + m_backends << new Solid::Backends::Wmi::WmiManager(0); + +-# elif defined(Q_OS_UNIX) && !defined(Q_OS_LINUX) +- m_backends << new Solid::Backends::Hal::HalManager(0); +- + # elif defined(Q_OS_LINUX) +- bool solidHalLegacyEnabled +- = QString::fromLocal8Bit(qgetenv("SOLID_HAL_LEGACY")).toInt()==1; +- if (solidHalLegacyEnabled) { +- m_backends << new Solid::Backends::Hal::HalManager(0); +- } else { + # if defined(UDEV_FOUND) + m_backends << new Solid::Backends::UDev::UDevManager(0); + # endif +- m_backends << new Solid::Backends::UDisks::UDisksManager(0) ++ m_backends << new Solid::Backends::UDisks2::Manager(0) + << new Solid::Backends::UPower::UPowerManager(0) + << new Solid::Backends::Fstab::FstabManager(0); +- } + # endif + + # if defined (HUPNP_FOUND) +diff --git a/tier1/solid/src/solid/backends/udisks2/dbus/manager.cpp b/tier1/solid/src/solid/backends/udisks2/dbus/manager.cpp +new file mode 100644 +index 0000000..7ea4aa8 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/dbus/manager.cpp +@@ -0,0 +1,26 @@ ++/* ++ * This file was generated by qdbusxml2cpp version 0.7 ++ * Command line was: qdbusxml2cpp -p manager manager.xml ++ * ++ * qdbusxml2cpp is Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ++ * ++ * This is an auto-generated file. ++ * This file may have been hand-edited. Look for HAND-EDIT comments ++ * before re-generating it. ++ */ ++ ++#include "manager.h" ++ ++/* ++ * Implementation of interface class OrgFreedesktopDBusObjectManagerInterface ++ */ ++ ++OrgFreedesktopDBusObjectManagerInterface::OrgFreedesktopDBusObjectManagerInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent) ++ : QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent) ++{ ++} ++ ++OrgFreedesktopDBusObjectManagerInterface::~OrgFreedesktopDBusObjectManagerInterface() ++{ ++} ++ +diff --git a/tier1/solid/src/solid/backends/udisks2/dbus/manager.h b/tier1/solid/src/solid/backends/udisks2/dbus/manager.h +new file mode 100644 +index 0000000..11f0be8 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/dbus/manager.h +@@ -0,0 +1,59 @@ ++/* ++ * This file was generated by qdbusxml2cpp version 0.7 ++ * Command line was: qdbusxml2cpp -p manager manager.xml ++ * ++ * qdbusxml2cpp is Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ++ * ++ * This is an auto-generated file. ++ * Do not edit! All changes made to it will be lost. ++ */ ++ ++#ifndef MANAGER_H_1329493525 ++#define MANAGER_H_1329493525 ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "../udisks2.h" ++ ++/* ++ * Proxy class for interface org.freedesktop.DBus.ObjectManager ++ */ ++class OrgFreedesktopDBusObjectManagerInterface: public QDBusAbstractInterface ++{ ++ Q_OBJECT ++public: ++ static inline const char *staticInterfaceName() ++ { return "org.freedesktop.DBus.ObjectManager"; } ++ ++public: ++ OrgFreedesktopDBusObjectManagerInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0); ++ ++ ~OrgFreedesktopDBusObjectManagerInterface(); ++ ++public Q_SLOTS: // METHODS ++ inline QDBusPendingReply GetManagedObjects() ++ { ++ QList argumentList; ++ return asyncCallWithArgumentList(QLatin1String("GetManagedObjects"), argumentList); ++ } ++ ++Q_SIGNALS: // SIGNALS ++ void InterfacesAdded(const QDBusObjectPath &object_path, const QVariantMapMap &interfaces_and_properties); ++ void InterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); ++}; ++ ++namespace org { ++ namespace freedesktop { ++ namespace DBus { ++ typedef ::OrgFreedesktopDBusObjectManagerInterface ObjectManager; ++ } ++ } ++} ++#endif +diff --git a/tier1/solid/src/solid/backends/udisks2/dbus/manager.xml b/tier1/solid/src/solid/backends/udisks2/dbus/manager.xml +new file mode 100644 +index 0000000..8f25cb6 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/dbus/manager.xml +@@ -0,0 +1,21 @@ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff --git a/tier1/solid/src/solid/backends/udisks2/udisks2.h b/tier1/solid/src/solid/backends/udisks2/udisks2.h +new file mode 100644 +index 0000000..25a1dc0 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisks2.h +@@ -0,0 +1,77 @@ ++/* ++ Copyright 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef SOLID_BACKENDS_UDISKS2_H ++#define SOLID_BACKENDS_UDISKS2_H ++ ++#include ++#include ++#include ++#include ++#include ++ ++typedef QList QByteArrayList; ++Q_DECLARE_METATYPE(QByteArrayList) ++ ++typedef QMap QVariantMapMap; ++Q_DECLARE_METATYPE(QVariantMapMap) ++ ++typedef QMap DBUSManagerStruct; ++Q_DECLARE_METATYPE(DBUSManagerStruct) ++ ++/* UDisks2 */ ++#define UD2_DBUS_SERVICE "org.freedesktop.UDisks2" ++#define UD2_DBUS_PATH "/org/freedesktop/UDisks2" ++#define UD2_UDI_DISKS_PREFIX "/org/freedesktop/UDisks2" ++#define UD2_DBUS_PATH_MANAGER "/org/freedesktop/UDisks2/Manager" ++#define UD2_DBUS_PATH_DRIVES "/org/freedesktop/UDisks2/drives/" ++#define UD2_DBUS_PATH_JOBS "/org/freedesktop/UDisks2/jobs/" ++#define DBUS_INTERFACE_PROPS "org.freedesktop.DBus.Properties" ++#define DBUS_INTERFACE_INTROSPECT "org.freedesktop.DBus.Introspectable" ++#define DBUS_INTERFACE_MANAGER "org.freedesktop.DBus.ObjectManager" ++#define UD2_DBUS_INTERFACE_BLOCK "org.freedesktop.UDisks2.Block" ++#define UD2_DBUS_INTERFACE_DRIVE "org.freedesktop.UDisks2.Drive" ++#define UD2_DBUS_INTERFACE_PARTITION "org.freedesktop.UDisks2.Partition" ++#define UD2_DBUS_INTERFACE_PARTITIONTABLE "org.freedesktop.UDisks2.PartitionTable" ++#define UD2_DBUS_INTERFACE_FILESYSTEM "org.freedesktop.UDisks2.Filesystem" ++#define UD2_DBUS_INTERFACE_ENCRYPTED "org.freedesktop.UDisks2.Encrypted" ++#define UD2_DBUS_INTERFACE_SWAP "org.freedesktop.UDisks2.Swapspace" ++ ++/* errors */ ++#define UD2_ERROR_UNAUTHORIZED "org.freedesktop.PolicyKit.Error.NotAuthorized" ++#define UD2_ERROR_BUSY "org.freedesktop.UDisks2.Error.DeviceBusy" ++#define UD2_ERROR_FAILED "org.freedesktop.UDisks2.Error.Failed" ++#define UD2_ERROR_CANCELED "org.freedesktop.UDisks2.Error.Cancelled" ++#define UD2_ERROR_INVALID_OPTION "org.freedesktop.UDisks2.Error.OptionNotPermitted" ++#define UD2_ERROR_MISSING_DRIVER "org.freedesktop.UDisks2.Error.NotSupported" ++ ++#define UD2_ERROR_ALREADY_MOUNTED "org.freedesktop.UDisks2.Error.AlreadyMounted" ++#define UD2_ERROR_NOT_MOUNTED "org.freedesktop.UDisks2.Error.NotMounted" ++#define UD2_ERROR_MOUNTED_BY_OTHER_USER "org.freedesktop.UDisks2.Error.MountedByOtherUser" ++#define UD2_ERROR_ALREADY_UNMOUNTING "org.freedesktop.UDisks2.Error.AlreadyUnmounting" ++#define UD2_ERROR_TIMED_OUT "org.freedesktop.UDisks2.Error.Timedout" ++#define UD2_ERROR_WOULD_WAKEUP "org.freedesktop.UDisks2.Error.WouldWakeup" ++#define UD2_ERROR_ALREADY_CANCELLED "org.freedesktop.UDisks2.Error.AlreadyCancelled" ++ ++#define UD2_ERROR_NOT_AUTHORIZED "org.freedesktop.UDisks2.Error.NotAuthorized" ++#define UD2_ERROR_NOT_AUTHORIZED_CAN_OBTAIN "org.freedesktop.UDisks2.Error.NotAuthorizedCanObtain" ++#define UD2_ERROR_NOT_AUTHORIZED_DISMISSED "org.freedesktop.UDisks2.Error.NotAuthorizedDismissed" ++ ++#endif // SOLID_BACKENDS_UDISKS2_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksblock.cpp b/tier1/solid/src/solid/backends/udisks2/udisksblock.cpp +new file mode 100644 +index 0000000..8a7a0b5 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksblock.cpp +@@ -0,0 +1,52 @@ ++/* ++ Copyright 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include ++ ++#include ++ ++#include "udisksblock.h" ++ ++using namespace Solid::Backends::UDisks2; ++ ++Block::Block(Device *device) ++ : DeviceInterface(device) ++{ ++ m_devNum = m_device->prop("DeviceNumber").toULongLong(); ++} ++ ++Block::~Block() ++{ ++} ++ ++QString Block::device() const ++{ ++ return QFile::decodeName(m_device->prop("Device").toByteArray()); ++} ++ ++int Block::deviceMinor() const ++{ ++ return MINOR(m_devNum); ++} ++ ++int Block::deviceMajor() const ++{ ++ return MAJOR(m_devNum); ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksblock.h b/tier1/solid/src/solid/backends/udisks2/udisksblock.h +new file mode 100644 +index 0000000..804d712 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksblock.h +@@ -0,0 +1,55 @@ ++/* ++ Copyright 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2BLOCK_H ++#define UDISKS2BLOCK_H ++ ++#include ++#include "udisksdeviceinterface.h" ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class Block: public DeviceInterface, virtual public Solid::Ifaces::Block ++{ ++ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::Block) ++ ++public: ++ Block(Device *device); ++ virtual ~Block(); ++ ++ virtual QString device() const; ++ virtual int deviceMinor() const; ++ virtual int deviceMajor() const; ++private: ++ dev_t m_devNum; ++}; ++ ++} ++} ++} ++ ++#endif // UDISKS2BLOCK_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksdevice.cpp b/tier1/solid/src/solid/backends/udisks2/udisksdevice.cpp +new file mode 100644 +index 0000000..628c0b0 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksdevice.cpp +@@ -0,0 +1,906 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksdevice.h" ++#include "udisksblock.h" ++#include "udisksdeviceinterface.h" ++#include "udisksstoragevolume.h" ++#include "udisksopticaldisc.h" ++#include "udisksopticaldrive.h" ++#include "udisksstorageaccess.h" ++#include "udisksgenericinterface.h" ++ ++#include ++#include ++#include ++ ++#include ++ ++#include ++#include ++#include ++#include ++ ++#include ++ ++using namespace Solid::Backends::UDisks2; ++ ++// Adapted from KLocale as Solid needs to be Qt-only ++static QString formatByteSize(double size) ++{ ++ // Per IEC 60027-2 ++ ++ // Binary prefixes ++ //Tebi-byte TiB 2^40 1,099,511,627,776 bytes ++ //Gibi-byte GiB 2^30 1,073,741,824 bytes ++ //Mebi-byte MiB 2^20 1,048,576 bytes ++ //Kibi-byte KiB 2^10 1,024 bytes ++ ++ QString s; ++ // Gibi-byte ++ if ( size >= 1073741824.0 ) ++ { ++ size /= 1073741824.0; ++ if ( size > 1024 ) // Tebi-byte ++ s = QObject::tr("%1 TiB").arg(QLocale().toString(size / 1024.0, 'f', 1)); ++ else ++ s = QObject::tr("%1 GiB").arg(QLocale().toString(size, 'f', 1)); ++ } ++ // Mebi-byte ++ else if ( size >= 1048576.0 ) ++ { ++ size /= 1048576.0; ++ s = QObject::tr("%1 MiB").arg(QLocale().toString(size, 'f', 1)); ++ } ++ // Kibi-byte ++ else if ( size >= 1024.0 ) ++ { ++ size /= 1024.0; ++ s = QObject::tr("%1 KiB").arg(QLocale().toString(size, 'f', 1)); ++ } ++ // Just byte ++ else if ( size > 0 ) ++ { ++ s = QObject::tr("%1 B").arg(QLocale().toString(size, 'f', 1)); ++ } ++ // Nothing ++ else ++ { ++ s = QObject::tr("0 B"); ++ } ++ return s; ++} ++ ++Device::Device(const QString &udi) ++ : Solid::Ifaces::Device() ++ , m_udi(udi) ++{ ++ m_device = new QDBusInterface(UD2_DBUS_SERVICE, m_udi, ++ QString(), // no interface, we aggregate them ++ QDBusConnection::systemBus()); ++ ++ if (m_device->isValid()) { ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, m_udi, DBUS_INTERFACE_PROPS, "PropertiesChanged", this, ++ SLOT(slotPropertiesChanged(QString,QVariantMap,QStringList))); ++ ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, UD2_DBUS_PATH, DBUS_INTERFACE_MANAGER, "InterfacesAdded", ++ this, SLOT(slotInterfacesAdded(QDBusObjectPath,QVariantMapMap))); ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, UD2_DBUS_PATH, DBUS_INTERFACE_MANAGER, "InterfacesRemoved", ++ this, SLOT(slotInterfacesRemoved(QDBusObjectPath,QStringList))); ++ ++ initInterfaces(); ++ } ++} ++ ++Device::~Device() ++{ ++ delete m_device; ++} ++ ++QObject* Device::createDeviceInterface(const Solid::DeviceInterface::Type& type) ++{ ++ if (!queryDeviceInterface(type)) { ++ return 0; ++ } ++ ++ DeviceInterface *iface = 0; ++ switch (type) ++ { ++ case Solid::DeviceInterface::GenericInterface: ++ iface = new GenericInterface(this); ++ break; ++ case Solid::DeviceInterface::Block: ++ iface = new Block(this); ++ break; ++ case Solid::DeviceInterface::StorageAccess: ++ iface = new StorageAccess(this); ++ break; ++ case Solid::DeviceInterface::StorageDrive: ++ iface = new StorageDrive(this); ++ break; ++ case Solid::DeviceInterface::OpticalDrive: ++ iface = new OpticalDrive(this); ++ break; ++ case Solid::DeviceInterface::StorageVolume: ++ iface = new StorageVolume(this); ++ break; ++ case Solid::DeviceInterface::OpticalDisc: ++ iface = new OpticalDisc(this); ++ break; ++ default: ++ break; ++ } ++ return iface; ++} ++ ++bool Device::queryDeviceInterface(const Solid::DeviceInterface::Type& type) const ++{ ++ switch (type) { ++ case Solid::DeviceInterface::GenericInterface: ++ return true; ++ case Solid::DeviceInterface::Block: ++ return isBlock(); ++ case Solid::DeviceInterface::StorageVolume: ++ return isStorageVolume(); ++ case Solid::DeviceInterface::StorageAccess: ++ return isStorageAccess(); ++ case Solid::DeviceInterface::StorageDrive: ++ return isDrive(); ++ case Solid::DeviceInterface::OpticalDrive: ++ return isOpticalDrive(); ++ case Solid::DeviceInterface::OpticalDisc: ++ return isOpticalDisc(); ++ default: ++ return false; ++ } ++} ++ ++QStringList Device::emblems() const ++{ ++ QStringList res; ++ ++ if (queryDeviceInterface(Solid::DeviceInterface::StorageAccess)) ++ { ++ const UDisks2::StorageAccess accessIface(const_cast(this)); ++ if (accessIface.isAccessible()) ++ { ++ if (isEncryptedContainer()) ++ res << "emblem-encrypted-unlocked"; ++ else ++ res << "emblem-mounted"; ++ } ++ else ++ { ++ if (isEncryptedContainer()) ++ res << "emblem-encrypted-locked"; ++ else ++ res << "emblem-unmounted"; ++ } ++ } ++ ++ return res; ++} ++ ++QString Device::description() const ++{ ++ const QString hintName = prop("HintName").toString(); ++ if (!hintName.isEmpty()) ++ return hintName; ++ ++ if (queryDeviceInterface(Solid::DeviceInterface::StorageDrive)) ++ return storageDescription(); ++ else if (queryDeviceInterface(Solid::DeviceInterface::StorageVolume)) ++ return volumeDescription(); ++ else ++ return product(); ++} ++ ++QString Device::storageDescription() const ++{ ++ QString description; ++ const UDisks2::StorageDrive storageDrive(const_cast(this)); ++ Solid::StorageDrive::DriveType drive_type = storageDrive.driveType(); ++ bool drive_is_hotpluggable = storageDrive.isHotpluggable(); ++ ++ if (drive_type == Solid::StorageDrive::CdromDrive) ++ { ++ const UDisks2::OpticalDrive opticalDrive(const_cast(this)); ++ Solid::OpticalDrive::MediumTypes mediumTypes = opticalDrive.supportedMedia(); ++ QString first; ++ QString second; ++ ++ first = QObject::tr("CD-ROM", "First item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Cdr) ++ first = QObject::tr("CD-R", "First item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Cdrw) ++ first = QObject::tr("CD-RW", "First item of %1%2 Drive sentence"); ++ ++ if (mediumTypes & Solid::OpticalDrive::Dvd) ++ second = QObject::tr("/DVD-ROM", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Dvdplusr) ++ second = QObject::tr("/DVD+R", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Dvdplusrw) ++ second = QObject::tr("/DVD+RW", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Dvdr) ++ second = QObject::tr("/DVD-R", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Dvdrw) ++ second = QObject::tr("/DVD-RW", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Dvdram) ++ second = QObject::tr("/DVD-RAM", "Second item of %1%2 Drive sentence"); ++ if ((mediumTypes & Solid::OpticalDrive::Dvdr) && (mediumTypes & Solid::OpticalDrive::Dvdplusr)) ++ { ++ if(mediumTypes & Solid::OpticalDrive::Dvdplusdl) ++ second = QObject::trUtf8("/DVD±R DL", "Second item of %1%2 Drive sentence"); ++ else ++ second = QObject::trUtf8("/DVD±R", "Second item of %1%2 Drive sentence"); ++ } ++ if ((mediumTypes & Solid::OpticalDrive::Dvdrw) && (mediumTypes & Solid::OpticalDrive::Dvdplusrw)) ++ { ++ if((mediumTypes & Solid::OpticalDrive::Dvdplusdl) || (mediumTypes & Solid::OpticalDrive::Dvdplusdlrw)) ++ second = QObject::trUtf8("/DVD±RW DL", "Second item of %1%2 Drive sentence"); ++ else ++ second = QObject::trUtf8("/DVD±RW", "Second item of %1%2 Drive sentence"); ++ } ++ if (mediumTypes & Solid::OpticalDrive::Bd) ++ second = QObject::tr("/BD-ROM", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Bdr) ++ second = QObject::tr("/BD-R", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::Bdre) ++ second = QObject::tr("/BD-RE", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::HdDvd) ++ second = QObject::tr("/HD DVD-ROM", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::HdDvdr) ++ second = QObject::tr("/HD DVD-R", "Second item of %1%2 Drive sentence"); ++ if (mediumTypes & Solid::OpticalDrive::HdDvdrw) ++ second = QObject::tr("/HD DVD-RW", "Second item of %1%2 Drive sentence"); ++ ++ if (drive_is_hotpluggable) ++ description = QObject::tr("External %1%2 Drive", "%1 is CD-ROM/CD-R/etc; %2 is '/DVD-ROM'/'/DVD-R'/etc (with leading slash)").arg(first).arg(second); ++ else ++ description = QObject::tr("%1%2 Drive", "%1 is CD-ROM/CD-R/etc; %2 is '/DVD-ROM'/'/DVD-R'/etc (with leading slash)").arg(first).arg(second); ++ ++ return description; ++ } ++ ++ if (drive_type == Solid::StorageDrive::Floppy) ++ { ++ if (drive_is_hotpluggable) ++ description = QObject::tr("External Floppy Drive"); ++ else ++ description = QObject::tr("Floppy Drive"); ++ ++ return description; ++ } ++ ++ bool drive_is_removable = storageDrive.isRemovable(); ++ ++ if (drive_type == Solid::StorageDrive::HardDisk && !drive_is_removable) ++ { ++ QString size_str = formatByteSize(storageDrive.size()); ++ if (!size_str.isEmpty()) ++ { ++ if (drive_is_hotpluggable) ++ description = QObject::tr("%1 External Hard Drive", "%1 is the size").arg(size_str); ++ else ++ description = QObject::tr("%1 Hard Drive", "%1 is the size").arg(size_str); ++ } else { ++ if (drive_is_hotpluggable) ++ description = QObject::tr("External Hard Drive"); ++ else ++ description = QObject::tr("Hard Drive"); ++ } ++ ++ return description; ++ } ++ ++ QString vendormodel_str; ++ QString model = product(); ++ QString vendor_str = vendor(); ++ ++ if (vendor_str.isEmpty()) ++ { ++ if (!model.isEmpty()) ++ vendormodel_str = model; ++ } ++ else ++ { ++ if (model.isEmpty()) ++ vendormodel_str = vendor_str; ++ else ++ { ++ if (model.startsWith(vendor_str)) ++ { ++ // e.g. vendor is "Nokia" and model is "Nokia N950" we do not want "Nokia Nokia N950" as description ++ vendormodel_str = model; ++ } ++ else ++ { ++ vendormodel_str = QObject::tr("%1 %2", "%1 is the vendor, %2 is the model of the device").arg(vendor_str).arg(model); ++ } ++ } ++ } ++ ++ if (vendormodel_str.isEmpty()) ++ description = QObject::tr("Drive"); ++ else ++ description = vendormodel_str; ++ ++ return description; ++} ++ ++QString Device::volumeDescription() const ++{ ++ QString description; ++ const UDisks2::StorageVolume storageVolume(const_cast(this)); ++ QString volume_label = prop("IdLabel").toString(); ++ if (volume_label.isEmpty()) ++ volume_label = prop("Name").toString(); ++ if (!volume_label.isEmpty()) ++ return volume_label; ++ ++ const QString drivePath = prop("Drive").value().path(); ++ UDisks2::Device storageDevice(drivePath); ++ const UDisks2::StorageDrive storageDrive(&storageDevice); ++ Solid::StorageDrive::DriveType drive_type = storageDrive.driveType(); ++ ++ // Handle media in optical drives ++ if (drive_type == Solid::StorageDrive::CdromDrive) ++ { ++ const UDisks2::OpticalDisc disc(const_cast(this)); ++ switch (disc.discType()) ++ { ++ case Solid::OpticalDisc::UnknownDiscType: ++ case Solid::OpticalDisc::CdRom: ++ description = QObject::tr("CD-ROM"); ++ break; ++ ++ case Solid::OpticalDisc::CdRecordable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank CD-R"); ++ else ++ description = QObject::tr("CD-R"); ++ break; ++ ++ case Solid::OpticalDisc::CdRewritable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank CD-RW"); ++ else ++ description = QObject::tr("CD-RW"); ++ break; ++ ++ case Solid::OpticalDisc::DvdRom: ++ description = QObject::tr("DVD-ROM"); ++ break; ++ ++ case Solid::OpticalDisc::DvdRam: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD-RAM"); ++ else ++ description = QObject::tr("DVD-RAM"); ++ break; ++ ++ case Solid::OpticalDisc::DvdRecordable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD-R"); ++ else ++ description = QObject::tr("DVD-R"); ++ break; ++ ++ case Solid::OpticalDisc::DvdPlusRecordableDuallayer: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD+R Dual-Layer"); ++ else ++ description = QObject::tr("DVD+R Dual-Layer"); ++ break; ++ ++ case Solid::OpticalDisc::DvdRewritable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD-RW"); ++ else ++ description = QObject::tr("DVD-RW"); ++ break; ++ ++ case Solid::OpticalDisc::DvdPlusRecordable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD+R"); ++ else ++ description = QObject::tr("DVD+R"); ++ break; ++ ++ case Solid::OpticalDisc::DvdPlusRewritable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD+RW"); ++ else ++ description = QObject::tr("DVD+RW"); ++ break; ++ ++ case Solid::OpticalDisc::DvdPlusRewritableDuallayer: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank DVD+RW Dual-Layer"); ++ else ++ description = QObject::tr("DVD+RW Dual-Layer"); ++ break; ++ ++ case Solid::OpticalDisc::BluRayRom: ++ description = QObject::tr("BD-ROM"); ++ break; ++ ++ case Solid::OpticalDisc::BluRayRecordable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank BD-R"); ++ else ++ description = QObject::tr("BD-R"); ++ break; ++ ++ case Solid::OpticalDisc::BluRayRewritable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank BD-RE"); ++ else ++ description = QObject::tr("BD-RE"); ++ break; ++ ++ case Solid::OpticalDisc::HdDvdRom: ++ description = QObject::tr("HD DVD-ROM"); ++ break; ++ ++ case Solid::OpticalDisc::HdDvdRecordable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank HD DVD-R"); ++ else ++ description = QObject::tr("HD DVD-R"); ++ break; ++ ++ case Solid::OpticalDisc::HdDvdRewritable: ++ if (disc.isBlank()) ++ description = QObject::tr("Blank HD DVD-RW"); ++ else ++ description = QObject::tr("HD DVD-RW"); ++ break; ++ } ++ ++ // Special case for pure audio disc ++ if (disc.availableContent() == Solid::OpticalDisc::Audio) ++ description = QObject::tr("Audio CD"); ++ ++ return description; ++ } ++ ++ const bool drive_is_removable = storageDrive.isRemovable(); ++ const bool drive_is_hotpluggable = storageDrive.isHotpluggable(); ++ ++ QString size_str = formatByteSize(storageVolume.size()); ++ if (isEncryptedContainer()) ++ { ++ if (!size_str.isEmpty()) ++ description = QObject::tr("%1 Encrypted Container", "%1 is the size").arg(size_str); ++ else ++ description = QObject::tr("Encrypted Container"); ++ } ++ else if (drive_type == Solid::StorageDrive::HardDisk && !drive_is_removable) ++ { ++ if (!size_str.isEmpty()) ++ { ++ if (drive_is_hotpluggable) ++ description = QObject::tr("%1 External Hard Drive", "%1 is the size").arg(size_str); ++ else ++ description = QObject::tr("%1 Hard Drive", "%1 is the size").arg(size_str); ++ } ++ else ++ { ++ if (drive_is_hotpluggable) ++ description = QObject::tr("External Hard Drive"); ++ else ++ description = QObject::tr("Hard Drive"); ++ } ++ } ++ else ++ { ++ if (drive_is_removable) ++ description = QObject::tr("%1 Removable Media", "%1 is the size").arg(size_str); ++ else ++ description = QObject::tr("%1 Media", "%1 is the size").arg(size_str); ++ } ++ ++ return description; ++} ++ ++QString Device::icon() const ++{ ++ QString iconName = prop( "HintIconName" ).toString(); ++ ++ if ( !iconName.isEmpty() ) ++ { ++ return iconName; ++ } ++ else if (isDrive()) { ++ const bool isRemovable = prop("Removable").toBool(); ++ const QString conn = prop("ConnectionBus").toString(); ++ ++ if (isOpticalDrive()) ++ return "drive-optical"; ++ else if (isRemovable && !isOpticalDisc()) { ++ if (conn == "usb") ++ return "drive-removable-media-usb"; ++ else ++ return "drive-removable-media"; ++ } ++ } ++ else if (isBlock()) { ++ const QString drivePath = prop("Drive").value().path(); ++ Device drive(drivePath); ++ ++ // handle media ++ const QString media = drive.prop("Media").toString(); ++ ++ if ( !media.isEmpty() ) ++ { ++ if ( isOpticalDisc() ) // optical stuff ++ { ++ bool isWritable = drive.prop("OpticalBlank").toBool(); ++ ++ const UDisks2::OpticalDisc disc(const_cast(this)); ++ Solid::OpticalDisc::ContentTypes availContent = disc.availableContent(); ++ ++ if (availContent & Solid::OpticalDisc::VideoDvd) // Video DVD ++ return "media-optical-dvd-video"; ++ else if ((availContent & Solid::OpticalDisc::VideoCd) || (availContent & Solid::OpticalDisc::SuperVideoCd)) // Video CD ++ return "media-optical-video"; ++ else if ((availContent & Solid::OpticalDisc::Data) && (availContent & Solid::OpticalDisc::Audio)) // Mixed CD ++ return "media-optical-mixed-cd"; ++ else if (availContent & Solid::OpticalDisc::Audio) // Audio CD ++ return "media-optical-audio"; ++ else if (availContent & Solid::OpticalDisc::Data) // Data CD ++ return "media-optical-data"; ++ else if ( isWritable ) ++ return "media-optical-recordable"; ++ else ++ { ++ if ( media.startsWith( "optical_dvd" ) || media.startsWith( "optical_hddvd" ) ) // DVD ++ return "media-optical-dvd"; ++ else if ( media.startsWith( "optical_bd" ) ) // BluRay ++ return "media-optical-blu-ray"; ++ } ++ ++ // fallback for every other optical disc ++ return "media-optical"; ++ } ++ ++ if ( media == "flash_ms" ) // Flash & Co. ++ return "media-flash-memory-stick"; ++ else if ( media == "flash_sd" || media == "flash_sdhc" || media == "flash_sdxc" || media == "flash_mmc" ) ++ return "media-flash-sd-mmc"; ++ else if ( media == "flash_sm" ) ++ return "media-flash-smart-media"; ++ else if ( media == "thumb" ) ++ return "drive-removable-media-usb-pendrive"; ++ else if ( media.startsWith( "flash" ) ) ++ return "media-flash"; ++ else if ( media == "floppy" ) // the good ol' floppy ++ return "media-floppy"; ++ } ++ ++ if (drive.prop("ConnectionBus").toString() == "sdio") // hack for SD cards connected thru sdio bus ++ return "media-flash-sd-mmc"; ++ ++ return drive.icon(); ++ } ++ ++ return "drive-harddisk"; // general fallback ++} ++ ++QString Device::product() const ++{ ++ QString product = prop("Model").toString(); ++ ++ if (!isDrive()) { ++ QString label = prop("IdLabel").toString(); ++ if (!label.isEmpty()) { ++ product = label; ++ } ++ } ++ ++ return product; ++} ++ ++QString Device::vendor() const ++{ ++ return prop("Vendor").toString(); ++} ++ ++QString Device::udi() const ++{ ++ return m_udi; ++} ++ ++QString Device::parentUdi() const ++{ ++ QString parent; ++ ++ if (isEncryptedContainer()) ++ parent = prop("CryptoBackingDevice").value().path(); ++ else if (propertyExists("Drive")) // block ++ parent = prop("Drive").value().path(); ++ else if (propertyExists("Table")) // partition ++ parent = prop("Table").value().path(); ++ else if (parent.isEmpty() || parent=="/") { ++ parent = UD2_UDI_DISKS_PREFIX; ++ } ++ return parent; ++} ++ ++void Device::checkCache(const QString &key) const ++{ ++ if (m_cache.isEmpty()) // recreate the cache ++ allProperties(); ++ ++ if (m_cache.contains(key)) ++ return; ++ ++ QVariant reply = m_device->property(key.toUtf8()); ++ ++ if (reply.isValid()) { ++ m_cache.insert(key, reply); ++ } else { ++ //qDebug() << "got invalid reply for cache:" << key; ++ //m_cache.insert(key, QVariant()); ++ } ++} ++ ++QString Device::introspect() const ++{ ++ QDBusMessage call = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, m_udi, ++ DBUS_INTERFACE_INTROSPECT, "Introspect"); ++ QDBusPendingReply reply = QDBusConnection::systemBus().asyncCall(call); ++ reply.waitForFinished(); ++ ++ if (reply.isValid()) ++ return reply.value(); ++ else { ++ return QString(); ++ } ++} ++ ++QVariant Device::prop(const QString &key) const ++{ ++ checkCache(key); ++ return m_cache.value(key); ++} ++ ++bool Device::propertyExists(const QString &key) const ++{ ++ checkCache(key); ++ return m_cache.contains(key); ++} ++ ++QVariantMap Device::allProperties() const ++{ ++ Q_FOREACH (const QString & iface, m_interfaces) { ++ if (iface.startsWith("org.freedesktop.DBus")) ++ continue; ++ QDBusMessage call = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, m_udi, DBUS_INTERFACE_PROPS, "GetAll"); ++ call.setArguments(QList() << iface); ++ QDBusPendingReply reply = QDBusConnection::systemBus().asyncCall(call); ++ reply.waitForFinished(); ++ ++ if (reply.isValid()) ++ m_cache.unite(reply.value()); ++ else ++ qWarning() << "Error getting props:" << reply.error().name() << reply.error().message(); ++ //qDebug() << "After iface" << iface << ", cache now contains" << m_cache.size() << "items"; ++ } ++ ++ return m_cache; ++} ++ ++bool Device::hasInterface(const QString &name) const ++{ ++ return m_interfaces.contains(name); ++} ++ ++QStringList Device::interfaces() const ++{ ++ return m_interfaces; ++} ++ ++void Device::initInterfaces() ++{ ++ m_interfaces.clear(); ++ const QString xmlData = introspect(); ++ QDomDocument dom; ++ dom.setContent(xmlData); ++ QDomNodeList ifaceNodeList = dom.elementsByTagName("interface"); ++ for (int i = 0; i < ifaceNodeList.count(); i++) { ++ QDomElement ifaceElem = ifaceNodeList.item(i).toElement(); ++ if (!ifaceElem.isNull()) ++ m_interfaces.append(ifaceElem.attribute("name")); ++ } ++ //qDebug() << "Device" << m_udi << "has interfaces:" << m_interfaces; ++} ++ ++void Device::slotPropertiesChanged(const QString &ifaceName, const QVariantMap &changedProps, const QStringList &invalidatedProps) ++{ ++ //Q_UNUSED(ifaceName); ++ ++ qDebug() << m_udi << "'s interface" << ifaceName << "changed props:"; ++ ++ QMap changeMap; ++ ++ Q_FOREACH(const QString & key, invalidatedProps) { ++ m_cache.remove(key); ++ changeMap.insert(key, Solid::GenericInterface::PropertyRemoved); ++ qDebug() << "\t invalidated:" << key; ++ } ++ ++ QMapIterator i(changedProps); ++ while (i.hasNext()) { ++ i.next(); ++ m_cache.insert(i.key(), i.value()); // replace the value ++ changeMap.insert(i.key(), Solid::GenericInterface::PropertyModified); ++ qDebug() << "\t modified:" << i.key() << ":" << m_cache.value(i.key()); ++ } ++ ++ Q_EMIT propertyChanged(changeMap); ++ Q_EMIT changed(); ++} ++ ++void Device::slotInterfacesAdded(const QDBusObjectPath &object_path, const QVariantMapMap &interfaces_and_properties) ++{ ++ if (object_path.path() == m_udi) { ++ m_interfaces.append(interfaces_and_properties.keys()); ++ } ++} ++ ++void Device::slotInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces) ++{ ++ if (object_path.path() == m_udi) { ++ Q_FOREACH(const QString & iface, interfaces) { ++ m_interfaces.removeAll(iface); ++ } ++ } ++} ++ ++ ++QString Device::errorToString(const QString & error) const ++{ ++ if (error == UD2_ERROR_UNAUTHORIZED || error == UD2_ERROR_NOT_AUTHORIZED) ++ return QObject::tr("You are not authorized to perform this operation"); ++ else if (error == UD2_ERROR_BUSY) ++ return QObject::tr("The device is currently busy"); ++ else if (error == UD2_ERROR_FAILED) ++ return QObject::tr("The requested operation has failed"); ++ else if (error == UD2_ERROR_CANCELED) ++ return QObject::tr("The requested operation has been canceled"); ++ else if (error == UD2_ERROR_INVALID_OPTION) ++ return QObject::tr("An invalid or malformed option has been given"); ++ else if (error == UD2_ERROR_MISSING_DRIVER) ++ return QObject::tr("The kernel driver for this filesystem type is not available"); ++ else if (error == UD2_ERROR_ALREADY_MOUNTED) ++ return QObject::tr("The device is already mounted"); ++ else if (error == UD2_ERROR_NOT_MOUNTED) ++ return QObject::tr("The device is not mounted"); ++ else if (error == UD2_ERROR_MOUNTED_BY_OTHER_USER) ++ return QObject::tr("The device is mounted by another user"); ++ else if (error == UD2_ERROR_ALREADY_UNMOUNTING) ++ return QObject::tr("The device is already unmounting"); ++ else if (error == UD2_ERROR_TIMED_OUT) ++ return QObject::tr("The operation timed out"); ++ else if (error == UD2_ERROR_WOULD_WAKEUP) ++ return QObject::tr("The operation would wake up a disk that is in a deep-sleep state"); ++ else if (error == UD2_ERROR_ALREADY_CANCELLED) ++ return QObject::tr("The operation has already been canceled"); ++ else ++ return QObject::tr("An unspecified error has occurred"); ++} ++ ++Solid::ErrorType Device::errorToSolidError(const QString & error) const ++{ ++ if (error == UD2_ERROR_BUSY) ++ return Solid::DeviceBusy; ++ else if (error == UD2_ERROR_FAILED) ++ return Solid::OperationFailed; ++ else if (error == UD2_ERROR_CANCELED) ++ return Solid::UserCanceled; ++ else if (error == UD2_ERROR_INVALID_OPTION) ++ return Solid::InvalidOption; ++ else if (error == UD2_ERROR_MISSING_DRIVER) ++ return Solid::MissingDriver; ++ else ++ return Solid::UnauthorizedOperation; ++} ++ ++bool Device::isBlock() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_BLOCK); ++} ++ ++bool Device::isPartition() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_PARTITION); ++} ++ ++bool Device::isPartitionTable() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_PARTITIONTABLE); ++} ++ ++bool Device::isStorageVolume() const ++{ ++ return isPartition() || isPartitionTable() || isStorageAccess() || isOpticalDisc(); ++} ++ ++bool Device::isStorageAccess() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_FILESYSTEM) || isEncryptedContainer(); ++} ++ ++bool Device::isDrive() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_DRIVE); ++} ++ ++bool Device::isOpticalDrive() const ++{ ++ return isDrive() && !prop("MediaCompatibility").toStringList().filter("optical_").isEmpty(); ++} ++ ++bool Device::isOpticalDisc() const ++{ ++ QString drivePath = prop("Drive").value().path(); ++ if (drivePath.isEmpty() || drivePath == "/") ++ return false; ++ ++ Device drive(drivePath); ++ return drive.prop("Optical").toBool(); ++} ++ ++bool Device::mightBeOpticalDisc() const ++{ ++ QString drivePath = prop("Drive").value().path(); ++ if (drivePath.isEmpty() || drivePath == "/") ++ return false; ++ ++ Device drive(drivePath); ++ return drive.isOpticalDrive(); ++} ++ ++bool Device::isMounted() const ++{ ++ return propertyExists("MountPoints") && !qdbus_cast(prop("MountPoints")).isEmpty(); ++} ++ ++bool Device::isEncryptedContainer() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_ENCRYPTED); ++} ++ ++bool Device::isEncryptedCleartext() const ++{ ++ const QString holderDevice = prop("CryptoBackingDevice").toString(); ++ if (holderDevice.isEmpty() || holderDevice == "/") ++ return false; ++ else ++ return true; ++} ++ ++bool Device::isSwap() const ++{ ++ return hasInterface(UD2_DBUS_INTERFACE_SWAP); ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksdevice.h b/tier1/solid/src/solid/backends/udisks2/udisksdevice.h +new file mode 100644 +index 0000000..6f8056b +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksdevice.h +@@ -0,0 +1,110 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2DEVICE_H ++#define UDISKS2DEVICE_H ++ ++#include "udisks2.h" ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class Device: public Solid::Ifaces::Device ++{ ++ Q_OBJECT ++public: ++ Device(const QString &udi); ++ virtual ~Device(); ++ ++ virtual QObject* createDeviceInterface(const Solid::DeviceInterface::Type& type); ++ virtual bool queryDeviceInterface(const Solid::DeviceInterface::Type& type) const; ++ virtual QString description() const; ++ virtual QStringList emblems() const; ++ virtual QString icon() const; ++ virtual QString product() const; ++ virtual QString vendor() const; ++ virtual QString udi() const; ++ virtual QString parentUdi() const; ++ ++ QVariant prop(const QString &key) const; ++ bool propertyExists(const QString &key) const; ++ QVariantMap allProperties() const; ++ ++ bool hasInterface(const QString & name) const; ++ QStringList interfaces() const; ++ ++ QString errorToString(const QString & error) const; ++ Solid::ErrorType errorToSolidError(const QString & error) const; ++ ++ bool isBlock() const; ++ bool isPartition() const; ++ bool isPartitionTable() const; ++ bool isStorageVolume() const; ++ bool isStorageAccess() const; ++ bool isDrive() const; ++ bool isOpticalDrive() const; ++ bool isOpticalDisc() const; ++ bool mightBeOpticalDisc() const; ++ bool isMounted() const; ++ bool isEncryptedContainer() const; ++ bool isEncryptedCleartext() const; ++ bool isSwap() const; ++ ++Q_SIGNALS: ++ void changed(); ++ void propertyChanged(const QMap &changes); ++ ++private Q_SLOTS: ++ void slotPropertiesChanged(const QString & ifaceName, const QVariantMap & changedProps, const QStringList & invalidatedProps); ++ void slotInterfacesAdded(const QDBusObjectPath &object_path, const QVariantMapMap &interfaces_and_properties); ++ void slotInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); ++ ++private: ++ QString storageDescription() const; ++ QString volumeDescription() const; ++ mutable QDBusInterface *m_device; ++ QString m_udi; ++ mutable QVariantMap m_cache; ++ ++ void initInterfaces(); ++ QStringList m_interfaces; ++ ++ void checkCache(const QString &key) const; ++ QString introspect() const; ++}; ++ ++} ++} ++} ++ ++#endif // UDISKS2DEVICE_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.cpp b/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.cpp +new file mode 100644 +index 0000000..9fa60e5 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.cpp +@@ -0,0 +1,33 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksdeviceinterface.h" ++ ++using namespace Solid::Backends::UDisks2; ++ ++DeviceInterface::DeviceInterface(Device *device) ++ : QObject(device), m_device(device) ++{ ++ ++} ++ ++DeviceInterface::~DeviceInterface() ++{ ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.h b/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.h +new file mode 100644 +index 0000000..43a1b6f +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksdeviceinterface.h +@@ -0,0 +1,148 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2DEVICEINTERFACE_H ++#define UDISKS2DEVICEINTERFACE_H ++ ++#include ++#include "udisksdevice.h" ++ ++#include ++#include ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class DeviceInterface : public QObject, virtual public Solid::Ifaces::DeviceInterface ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::DeviceInterface) ++public: ++ DeviceInterface(Device *device); ++ virtual ~DeviceInterface(); ++ ++protected: ++ Device *m_device; ++ ++public: ++ inline static QStringList toStringList(Solid::DeviceInterface::Type type) ++ { ++ QStringList list; ++ ++ switch(type) ++ { ++ case Solid::DeviceInterface::GenericInterface: ++ list << "generic"; ++ break; ++ case Solid::DeviceInterface::Processor: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::Block: ++ list << "block"; ++ break; ++ case Solid::DeviceInterface::StorageAccess: ++ list << "volume"; ++ break; ++ case Solid::DeviceInterface::StorageDrive: ++ list << "storage"; ++ break; ++ case Solid::DeviceInterface::OpticalDrive: ++ list << "storage.cdrom"; ++ break; ++ case Solid::DeviceInterface::StorageVolume: ++ list << "volume"; ++ break; ++ case Solid::DeviceInterface::OpticalDisc: ++ list << "volume.disc"; ++ break; ++ case Solid::DeviceInterface::Camera: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::PortableMediaPlayer: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::NetworkInterface: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::AcAdapter: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::Battery: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::Button: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::AudioInterface: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::DvbInterface: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::Video: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::SerialInterface: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::InternetGateway: ++ break; ++ case Solid::DeviceInterface::SmartCardReader: ++ // Doesn't exist with UDisks ++ case Solid::DeviceInterface::NetworkShare: ++ // Doesn't exist with UDisks ++ break; ++ case Solid::DeviceInterface::Unknown: ++ break; ++ case Solid::DeviceInterface::Last: ++ break; ++ } ++ ++ return list; ++ } ++ ++ inline static Solid::DeviceInterface::Type fromString(const QString &capability) ++ { ++ if (capability == "generic") ++ return Solid::DeviceInterface::GenericInterface; ++ else if (capability == "block") ++ return Solid::DeviceInterface::Block; ++ else if (capability == "storage") ++ return Solid::DeviceInterface::StorageDrive; ++ else if (capability == "storage.cdrom") ++ return Solid::DeviceInterface::OpticalDrive; ++ else if (capability == "volume") ++ return Solid::DeviceInterface::StorageVolume; ++ else if (capability == "volume.disc") ++ return Solid::DeviceInterface::OpticalDisc; ++ else ++ return Solid::DeviceInterface::Unknown; ++ } ++}; ++ ++} ++} ++} ++ ++#endif // UDISKS2DEVICEINTERFACE_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.cpp b/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.cpp +new file mode 100644 +index 0000000..2d8cea2 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.cpp +@@ -0,0 +1,53 @@ ++/* ++ Copyright 2009 Pino Toscano ++ Copyright 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksgenericinterface.h" ++ ++#include "udisksdevice.h" ++ ++using namespace Solid::Backends::UDisks2; ++ ++GenericInterface::GenericInterface(Device *device) ++ : DeviceInterface(device) ++{ ++ connect(device, SIGNAL(propertyChanged(QMap)), ++ this, SIGNAL(propertyChanged(QMap))); ++} ++ ++GenericInterface::~GenericInterface() ++{ ++} ++ ++QVariant GenericInterface::property(const QString &key) const ++{ ++ return m_device->prop(key); ++} ++ ++QVariantMap GenericInterface::allProperties() const ++{ ++ return m_device->allProperties(); ++} ++ ++bool GenericInterface::propertyExists(const QString &key) const ++{ ++ return m_device->propertyExists(key); ++} ++ +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.h b/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.h +new file mode 100644 +index 0000000..d225f32 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksgenericinterface.h +@@ -0,0 +1,57 @@ ++/* ++ Copyright 2009 Pino Toscano ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef SOLID_BACKENDS_UDISKS2_GENERICINTERFACE_H ++#define SOLID_BACKENDS_UDISKS2_GENERICINTERFACE_H ++ ++#include ++#include ++#include "udisksdeviceinterface.h" ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++class Device; ++ ++class GenericInterface : public DeviceInterface, virtual public Solid::Ifaces::GenericInterface ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::GenericInterface) ++ ++public: ++ GenericInterface(Device *device); ++ virtual ~GenericInterface(); ++ ++ virtual QVariant property(const QString &key) const; ++ virtual QVariantMap allProperties() const; ++ virtual bool propertyExists(const QString &key) const; ++ ++Q_SIGNALS: ++ void propertyChanged(const QMap &changes); ++ void conditionRaised(const QString &condition, const QString &reason); ++}; ++} ++} ++} ++ ++#endif // SOLID_BACKENDS_UDISKS2_GENERICINTERFACE_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksmanager.cpp b/tier1/solid/src/solid/backends/udisks2/udisksmanager.cpp +new file mode 100644 +index 0000000..2e6f8c6 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksmanager.cpp +@@ -0,0 +1,294 @@ ++/* ++ Copyright 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksmanager.h" ++ ++#include ++#include ++ ++#include "../shared/rootdevice.h" ++ ++using namespace Solid::Backends::UDisks2; ++using namespace Solid::Backends::Shared; ++ ++Manager::Manager(QObject *parent) ++ : Solid::Ifaces::DeviceManager(parent), ++ m_manager(UD2_DBUS_SERVICE, ++ UD2_DBUS_PATH, ++ QDBusConnection::systemBus()) ++{ ++ m_supportedInterfaces ++ << Solid::DeviceInterface::GenericInterface ++ << Solid::DeviceInterface::Block ++ << Solid::DeviceInterface::StorageAccess ++ << Solid::DeviceInterface::StorageDrive ++ << Solid::DeviceInterface::OpticalDrive ++ << Solid::DeviceInterface::OpticalDisc ++ << Solid::DeviceInterface::StorageVolume; ++ ++ qDBusRegisterMetaType >(); ++ qDBusRegisterMetaType(); ++ qDBusRegisterMetaType(); ++ qDBusRegisterMetaType(); ++ qDBusRegisterMetaType(); ++ ++ bool serviceFound = m_manager.isValid(); ++ if (!serviceFound) { ++ // find out whether it will be activated automatically ++ QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.DBus", ++ "/org/freedesktop/DBus", ++ "org.freedesktop.DBus", ++ "ListActivatableNames"); ++ ++ QDBusReply reply = QDBusConnection::systemBus().call(message); ++ if (reply.isValid() && reply.value().contains(UD2_DBUS_SERVICE)) { ++ QDBusConnection::systemBus().interface()->startService(UD2_DBUS_SERVICE); ++ serviceFound = true; ++ } ++ } ++ ++ if (serviceFound) { ++ connect(&m_manager, SIGNAL(InterfacesAdded(QDBusObjectPath, QVariantMapMap)), ++ this, SLOT(slotInterfacesAdded(QDBusObjectPath,QVariantMapMap))); ++ connect(&m_manager, SIGNAL(InterfacesRemoved(QDBusObjectPath,QStringList)), ++ this, SLOT(slotInterfacesRemoved(QDBusObjectPath,QStringList))); ++ } ++} ++ ++Manager::~Manager() ++{ ++} ++ ++QObject* Manager::createDevice(const QString& udi) ++{ ++ if (udi==udiPrefix()) { ++ RootDevice *root = new RootDevice(udi); ++ ++ root->setProduct(tr("Storage")); ++ root->setDescription(tr("Storage devices")); ++ root->setIcon("server-database"); // Obviously wasn't meant for that, but maps nicely in oxygen icon set :-p ++ ++ return root; ++ } else if (deviceCache().contains(udi)) { ++ return new Device(udi); ++ } else { ++ return 0; ++ } ++} ++ ++QStringList Manager::devicesFromQuery(const QString& parentUdi, Solid::DeviceInterface::Type type) ++{ ++ QStringList result; ++ ++ if (!parentUdi.isEmpty()) ++ { ++ Q_FOREACH (const QString &udi, deviceCache()) ++ { ++ Device device(udi); ++ if (device.queryDeviceInterface(type) && device.parentUdi() == parentUdi) ++ result << udi; ++ } ++ ++ return result; ++ } ++ else if (type != Solid::DeviceInterface::Unknown) ++ { ++ Q_FOREACH (const QString &udi, deviceCache()) ++ { ++ Device device(udi); ++ if (device.queryDeviceInterface(type)) ++ result << udi; ++ } ++ ++ return result; ++ } ++ ++ return deviceCache(); ++} ++ ++QStringList Manager::allDevices() ++{ ++ m_deviceCache.clear(); ++ ++ QDBusPendingReply reply = m_manager.GetManagedObjects(); ++ reply.waitForFinished(); ++ if (!reply.isError()) { // enum devices ++ m_deviceCache << udiPrefix(); ++ ++ Q_FOREACH(const QDBusObjectPath &path, reply.value().keys()) { ++ const QString udi = path.path(); ++ qDebug() << "Adding device" << udi; ++ ++ if (udi == UD2_DBUS_PATH_MANAGER || udi == UD2_UDI_DISKS_PREFIX || udi.startsWith(UD2_DBUS_PATH_JOBS)) ++ continue; ++ ++ Device device(udi); ++ if (device.mightBeOpticalDisc()) { ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, udi, DBUS_INTERFACE_PROPS, "PropertiesChanged", this, ++ SLOT(slotMediaChanged(QDBusMessage))); ++ if (!device.isOpticalDisc()) // skip empty CD disc ++ continue; ++ } ++ ++ m_deviceCache.append(udi); ++ } ++ } ++ else // show error ++ { ++ qWarning() << "Failed enumerating UDisks2 objects:" << reply.error().name() << "\n" << reply.error().message(); ++ } ++ ++ return m_deviceCache; ++} ++ ++ ++QSet< Solid::DeviceInterface::Type > Manager::supportedInterfaces() const ++{ ++ return m_supportedInterfaces; ++} ++ ++QString Manager::udiPrefix() const ++{ ++ return UD2_UDI_DISKS_PREFIX; ++} ++ ++#if 0 ++void Manager::slotDeviceAdded(const QDBusObjectPath &opath) ++{ ++ const QString udi = opath.path(); ++ ++ if (!m_deviceCache.contains(udi)) { ++ m_deviceCache.append(udi); ++ } ++ ++ Device device(udi); ++ if (device.queryDeviceInterface(Solid::DeviceInterface::StorageDrive) ++ && !device.prop("DeviceIsMediaAvailable").toBool() ++ && !m_dirtyDevices.contains(udi)) ++ m_dirtyDevices.append(udi); ++ ++ Q_EMIT deviceAdded(udi); ++ slotDeviceChanged(opath); // case: hotswap event (optical drive with media inside) ++} ++ ++void Manager::slotDeviceRemoved(const QDBusObjectPath &opath) ++{ ++ const QString udi = opath.path(); ++ ++ // case: hotswap event (optical drive with media inside) ++ if (m_knownDrivesWithMedia.contains(udi)) { ++ m_knownDrivesWithMedia.removeAll(udi); ++ m_deviceCache.removeAll(udi + ":media"); ++ Q_EMIT deviceRemoved(udi + ":media"); ++ } ++ ++ if (m_dirtyDevices.contains(udi)) ++ m_dirtyDevices.removeAll(udi); ++ ++ Q_EMIT deviceRemoved(udi); ++ m_deviceCache.removeAll(udi); ++} ++ ++void Manager::slotDeviceChanged(const QDBusObjectPath &opath) ++{ ++ const QString udi = opath.path(); ++ Device device(udi); ++ ++ if (device.queryDeviceInterface(Solid::DeviceInterface::OpticalDrive)) ++ { ++ if (!m_knownDrivesWithMedia.contains(udi) && device.prop("DeviceIsOpticalDisc").toBool()) ++ { ++ m_knownDrivesWithMedia.append(udi); ++ if (!m_deviceCache.isEmpty()) { ++ m_deviceCache.append(udi + ":media"); ++ } ++ Q_EMIT deviceAdded(udi + ":media"); ++ } ++ ++ if (m_knownDrivesWithMedia.contains(udi) && !device.prop("DeviceIsOpticalDisc").toBool()) ++ { ++ m_knownDrivesWithMedia.removeAll(udi); ++ m_deviceCache.removeAll(udi + ":media"); ++ Q_EMIT deviceRemoved(udi + ":media"); ++ } ++ } ++ ++ if (device.queryDeviceInterface(Solid::DeviceInterface::StorageDrive) && device.prop("MediaAvailable").toBool() && m_dirtyDevices.contains(udi)) ++ { ++ qDebug() << "dirty device added:" << udi; ++ Q_EMIT deviceAdded(udi); ++ m_dirtyDevices.removeAll(udi); ++ } ++} ++#endif ++ ++ ++void Manager::slotInterfacesAdded(const QDBusObjectPath &object_path, const QVariantMapMap &interfaces_and_properties) ++{ ++ const QString udi = object_path.path(); ++ ++ qDebug() << udi << "has new interfaces:" << interfaces_and_properties.keys(); ++ ++ // new device, we don't know it yet ++ if (!m_deviceCache.contains(udi)) { ++ m_deviceCache.append(udi); ++ Q_EMIT deviceAdded(udi); ++ } ++} ++ ++void Manager::slotInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces) ++{ ++ const QString udi = object_path.path(); ++ ++ qDebug() << udi << "lost interfaces:" << interfaces; ++ ++ Device device(udi); ++ ++ if (!udi.isEmpty() && (interfaces.isEmpty() || device.interfaces().isEmpty() || device.interfaces().contains(UD2_DBUS_INTERFACE_FILESYSTEM))) { ++ Q_EMIT deviceRemoved(udi); ++ m_deviceCache.removeAll(udi); ++ } ++} ++ ++void Manager::slotMediaChanged(const QDBusMessage & msg) ++{ ++ const QVariantMap properties = qdbus_cast(msg.arguments().at(1)); ++ const QString udi = msg.path(); ++ qulonglong size = properties.value("Size").toULongLong(); ++ qDebug() << "MEDIA CHANGED in" << udi << "; size is:" << size; ++ ++ if (!m_deviceCache.contains(udi) && size > 0) { // we don't know the optdisc, got inserted ++ m_deviceCache.append(udi); ++ Q_EMIT deviceAdded(udi); ++ } ++ ++ if (m_deviceCache.contains(udi) && size == 0) { // we know the optdisc, got removed ++ Q_EMIT deviceRemoved(udi); ++ m_deviceCache.removeAll(udi); ++ } ++} ++ ++const QStringList & Manager::deviceCache() ++{ ++ if (m_deviceCache.isEmpty()) ++ allDevices(); ++ ++ return m_deviceCache; ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksmanager.h b/tier1/solid/src/solid/backends/udisks2/udisksmanager.h +new file mode 100644 +index 0000000..7cf0a72 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksmanager.h +@@ -0,0 +1,69 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2MANAGER_H ++#define UDISKS2MANAGER_H ++ ++#include "udisks2.h" ++#include "udisksdevice.h" ++#include "dbus/manager.h" ++ ++#include "solid/ifaces/devicemanager.h" ++ ++#include ++#include ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class Manager: public Solid::Ifaces::DeviceManager ++{ ++ Q_OBJECT ++ ++public: ++ Manager(QObject *parent); ++ virtual QObject* createDevice(const QString& udi); ++ virtual QStringList devicesFromQuery(const QString& parentUdi, Solid::DeviceInterface::Type type); ++ virtual QStringList allDevices(); ++ virtual QSet< Solid::DeviceInterface::Type > supportedInterfaces() const; ++ virtual QString udiPrefix() const; ++ virtual ~Manager(); ++ ++private Q_SLOTS: ++ void slotInterfacesAdded(const QDBusObjectPath &object_path, const QVariantMapMap &interfaces_and_properties); ++ void slotInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces); ++ void slotMediaChanged(const QDBusMessage &msg); ++ ++private: ++ const QStringList &deviceCache(); ++ QSet m_supportedInterfaces; ++ org::freedesktop::DBus::ObjectManager m_manager; ++ QStringList m_deviceCache; ++}; ++ ++} ++} ++} ++#endif // UDISKS2MANAGER_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.cpp b/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.cpp +new file mode 100644 +index 0000000..bceb277 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.cpp +@@ -0,0 +1,274 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010 - 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include "../shared/udevqt.h" ++ ++#include "udisks2.h" ++#include "udisksopticaldisc.h" ++ ++// inspired by http://cgit.freedesktop.org/hal/tree/hald/linux/probing/probe-volume.c ++static Solid::OpticalDisc::ContentType advancedDiscDetect(const QByteArray & device_file) ++{ ++ /* the discs block size */ ++ unsigned short bs; ++ /* the path table size */ ++ unsigned short ts; ++ /* the path table location (in blocks) */ ++ unsigned int tl; ++ /* length of the directory name in current path table entry */ ++ unsigned char len_di = 0; ++ /* the number of the parent directory's path table entry */ ++ unsigned int parent = 0; ++ /* filename for the current path table entry */ ++ char dirname[256]; ++ /* our position into the path table */ ++ int pos = 0; ++ /* the path table record we're on */ ++ int curr_record = 1; ++ ++ Solid::OpticalDisc::ContentType result = Solid::OpticalDisc::NoContent; ++ ++ int fd = open(device_file.constData(), O_RDONLY); ++ ++ /* read the block size */ ++ lseek (fd, 0x8080, SEEK_CUR); ++ if (read (fd, &bs, 2) != 2) ++ { ++ qDebug("Advanced probing on %s failed while reading block size", qPrintable(device_file)); ++ goto out; ++ } ++ ++ /* read in size of path table */ ++ lseek (fd, 2, SEEK_CUR); ++ if (read (fd, &ts, 2) != 2) ++ { ++ qDebug("Advanced probing on %s failed while reading path table size", qPrintable(device_file)); ++ goto out; ++ } ++ ++ /* read in which block path table is in */ ++ lseek (fd, 6, SEEK_CUR); ++ if (read (fd, &tl, 4) != 4) ++ { ++ qDebug("Advanced probing on %s failed while reading path table block", qPrintable(device_file)); ++ goto out; ++ } ++ ++ /* seek to the path table */ ++ lseek (fd, bs * tl, SEEK_SET); ++ ++ /* loop through the path table entries */ ++ while (pos < ts) ++ { ++ /* get the length of the filename of the current entry */ ++ if (read (fd, &len_di, 1) != 1) ++ { ++ qDebug("Advanced probing on %s failed, cannot read more entries", qPrintable(device_file)); ++ break; ++ } ++ ++ /* get the record number of this entry's parent ++ i'm pretty sure that the 1st entry is always the top directory */ ++ lseek (fd, 5, SEEK_CUR); ++ if (read (fd, &parent, 2) != 2) ++ { ++ qDebug("Advanced probing on %s failed, couldn't read parent entry", qPrintable(device_file)); ++ break; ++ } ++ ++ /* read the name */ ++ if (read (fd, dirname, len_di) != len_di) ++ { ++ qDebug("Advanced probing on %s failed, couldn't read the entry name", qPrintable(device_file)); ++ break; ++ } ++ dirname[len_di] = 0; ++ ++ /* if we found a folder that has the root as a parent, and the directory name matches ++ one of the special directories then set the properties accordingly */ ++ if (parent == 1) ++ { ++ if (!strcasecmp (dirname, "VIDEO_TS")) ++ { ++ qDebug("Disc in %s is a Video DVD", qPrintable(device_file)); ++ result = Solid::OpticalDisc::VideoDvd; ++ break; ++ } ++ else if (!strcasecmp (dirname, "BDMV")) ++ { ++ qDebug("Disc in %s is a Blu-ray video disc", qPrintable(device_file)); ++ result = Solid::OpticalDisc::VideoBluRay; ++ break; ++ } ++ else if (!strcasecmp (dirname, "VCD")) ++ { ++ qDebug("Disc in %s is a Video CD", qPrintable(device_file)); ++ result = Solid::OpticalDisc::VideoCd; ++ break; ++ } ++ else if (!strcasecmp (dirname, "SVCD")) ++ { ++ qDebug("Disc in %s is a Super Video CD", qPrintable(device_file)); ++ result = Solid::OpticalDisc::SuperVideoCd; ++ break; ++ } ++ } ++ ++ /* all path table entries are padded to be even, ++ so if this is an odd-length table, seek a byte to fix it */ ++ if (len_di%2 == 1) ++ { ++ lseek (fd, 1, SEEK_CUR); ++ pos++; ++ } ++ ++ /* update our position */ ++ pos += 8 + len_di; ++ curr_record++; ++ } ++ ++ close(fd); ++ return result; ++ ++out: ++ /* go back to the start of the file */ ++ lseek (fd, 0, SEEK_SET); ++ close(fd); ++ return result; ++} ++ ++using namespace Solid::Backends::UDisks2; ++ ++OpticalDisc::OpticalDisc(Device *device) ++ : StorageVolume(device), m_needsReprobe(true), m_cachedContent(Solid::OpticalDisc::NoContent) ++{ ++ UdevQt::Client client(this); ++ m_udevDevice = client.deviceByDeviceFile(QFile::decodeName(m_device->prop("Device").toByteArray())); ++ ++ m_drive = new Device(m_device->prop("Drive").value().path()); ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, m_drive->udi(), DBUS_INTERFACE_PROPS, "PropertiesChanged", this, ++ SLOT(slotDrivePropertiesChanged(QString,QVariantMap,QStringList))); ++} ++ ++OpticalDisc::~OpticalDisc() ++{ ++ delete m_drive; ++} ++ ++qulonglong OpticalDisc::capacity() const ++{ ++ return m_device->prop("Size").toULongLong(); ++} ++ ++bool OpticalDisc::isRewritable() const ++{ ++ // the hard way, udisks has no notion of a disc "rewritability" ++ const QString mediaType = media(); ++ return mediaType == "optical_cd_rw" || mediaType == "optical_dvd_rw" || mediaType == "optical_dvd_ram" || ++ mediaType == "optical_dvd_plus_rw" || mediaType == "optical_dvd_plus_rw_dl" || ++ mediaType == "optical_bd_re" || mediaType == "optical_hddvd_rw"; ++} ++ ++bool OpticalDisc::isBlank() const ++{ ++ return m_drive->prop("OpticalBlank").toBool(); ++} ++ ++bool OpticalDisc::isAppendable() const ++{ ++ return m_udevDevice.deviceProperty("ID_CDROM_MEDIA_STATE").toString() == QLatin1String("appendable"); ++} ++ ++Solid::OpticalDisc::DiscType OpticalDisc::discType() const ++{ ++ QMap map; ++ map[Solid::OpticalDisc::CdRom] = "optical_cd"; ++ map[Solid::OpticalDisc::CdRecordable] = "optical_cd_r"; ++ map[Solid::OpticalDisc::CdRewritable] = "optical_cd_rw"; ++ map[Solid::OpticalDisc::DvdRom] = "optical_dvd"; ++ map[Solid::OpticalDisc::DvdRecordable] = "optical_dvd_r"; ++ map[Solid::OpticalDisc::DvdRewritable] ="optical_dvd_rw"; ++ map[Solid::OpticalDisc::DvdRam] ="optical_dvd_ram"; ++ map[Solid::OpticalDisc::DvdPlusRecordable] ="optical_dvd_plus_r"; ++ map[Solid::OpticalDisc::DvdPlusRewritable] ="optical_dvd_plus_rw"; ++ map[Solid::OpticalDisc::DvdPlusRecordableDuallayer] ="optical_dvd_plus_r_dl"; ++ map[Solid::OpticalDisc::DvdPlusRewritableDuallayer] ="optical_dvd_plus_rw_dl"; ++ map[Solid::OpticalDisc::BluRayRom] ="optical_bd"; ++ map[Solid::OpticalDisc::BluRayRecordable] ="optical_bd_r"; ++ map[Solid::OpticalDisc::BluRayRewritable] ="optical_bd_re"; ++ map[Solid::OpticalDisc::HdDvdRom] ="optical_hddvd"; ++ map[Solid::OpticalDisc::HdDvdRecordable] ="optical_hddvd_r"; ++ map[Solid::OpticalDisc::HdDvdRewritable] ="optical_hddvd_rw"; ++ // TODO add these to Solid ++ //map[Solid::OpticalDisc::MagnetoOptical] ="optical_mo"; ++ //map[Solid::OpticalDisc::MountRainer] ="optical_mrw"; ++ //map[Solid::OpticalDisc::MountRainerWritable] ="optical_mrw_w"; ++ ++ return map.key(media(), Solid::OpticalDisc::UnknownDiscType); // FIXME optimize, lookup by value, not key ++} ++ ++Solid::OpticalDisc::ContentTypes OpticalDisc::availableContent() const ++{ ++ if (isBlank()) { ++ m_needsReprobe = false; ++ return Solid::OpticalDisc::NoContent; ++ } ++ ++ if (m_needsReprobe) { ++ m_cachedContent = Solid::OpticalDisc::NoContent; ++ const bool hasData = m_drive->prop("OpticalNumDataTracks").toUInt() > 0; ++ const bool hasAudio = m_drive->prop("OpticalNumAudioTracks").toUInt() > 0; ++ ++ if ( hasData ) { ++ m_cachedContent |= Solid::OpticalDisc::Data; ++ m_cachedContent |= advancedDiscDetect(m_device->prop("Device").toByteArray()); ++ } ++ if ( hasAudio ) ++ m_cachedContent |= Solid::OpticalDisc::Audio; ++ ++ m_needsReprobe = false; ++ } ++ ++ return m_cachedContent; ++} ++ ++void OpticalDisc::slotDrivePropertiesChanged(const QString &ifaceName, const QVariantMap &changedProps, const QStringList &invalidatedProps) ++{ ++ Q_UNUSED(ifaceName); ++ ++ if (changedProps.keys().contains("Media") || invalidatedProps.contains("Media")) { ++ m_needsReprobe = true; ++ m_cachedContent = Solid::OpticalDisc::NoContent; ++ } ++} ++ ++QString OpticalDisc::media() const ++{ ++ return m_drive->prop("Media").toString(); ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.h b/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.h +new file mode 100644 +index 0000000..1e2f030 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksopticaldisc.h +@@ -0,0 +1,69 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010 - 2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2OPTICALDISC_H ++#define UDISKS2OPTICALDISC_H ++ ++#include ++ ++#include "../shared/udevqt.h" ++ ++#include "udisksstoragevolume.h" ++#include "udisksdevice.h" ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class OpticalDisc: public StorageVolume, virtual public Solid::Ifaces::OpticalDisc ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::OpticalDisc) ++ ++public: ++ OpticalDisc(Device *device); ++ virtual ~OpticalDisc(); ++ ++ virtual qulonglong capacity() const; ++ virtual bool isRewritable() const; ++ virtual bool isBlank() const; ++ virtual bool isAppendable() const; ++ virtual Solid::OpticalDisc::DiscType discType() const; ++ virtual Solid::OpticalDisc::ContentTypes availableContent() const; ++ ++private Q_SLOTS: ++ void slotDrivePropertiesChanged(const QString & ifaceName, const QVariantMap & changedProps, const QStringList & invalidatedProps); ++ ++private: ++ QString media() const; ++ mutable bool m_needsReprobe; ++ mutable Solid::OpticalDisc::ContentTypes m_cachedContent; ++ Device * m_drive; ++ UdevQt::Device m_udevDevice; ++}; ++ ++} ++} ++} ++#endif // UDISKS2OPTICALDISC_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.cpp b/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.cpp +new file mode 100644 +index 0000000..0eb4685 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.cpp +@@ -0,0 +1,188 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include "udisksopticaldrive.h" ++#include "udisks2.h" ++#include "udisksdevice.h" ++ ++using namespace Solid::Backends::UDisks2; ++ ++OpticalDrive::OpticalDrive(Device *device) ++ : StorageDrive(device), m_ejectInProgress(false), m_readSpeed(0), m_writeSpeed(0), m_speedsInit(false) ++{ ++ m_device->registerAction("eject", this, ++ SLOT(slotEjectRequested()), ++ SLOT(slotEjectDone(int, const QString&))); ++ ++ connect(m_device, SIGNAL(changed()), this, SLOT(slotChanged())); ++} ++ ++OpticalDrive::~OpticalDrive() ++{ ++} ++ ++bool OpticalDrive::eject() ++{ ++ if (m_ejectInProgress) ++ return false; ++ m_ejectInProgress = true; ++ m_device->broadcastActionRequested("eject"); ++ ++ QDBusConnection c = QDBusConnection::systemBus(); ++ ++ QString path = m_device->udi(); ++ ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, path, UD2_DBUS_INTERFACE_DRIVE, "Eject"); ++ msg << QVariantMap(); ++ return c.callWithCallback(msg, this, SLOT(slotDBusReply(const QDBusMessage &)), SLOT(slotDBusError(const QDBusError &))); ++} ++ ++void OpticalDrive::slotDBusReply(const QDBusMessage &/*reply*/) ++{ ++ m_ejectInProgress = false; ++ m_device->broadcastActionDone("eject"); ++} ++ ++void OpticalDrive::slotDBusError(const QDBusError &error) ++{ ++ m_ejectInProgress = false; ++ m_device->broadcastActionDone("eject", m_device->errorToSolidError(error.name()), ++ m_device->errorToString(error.name()) + ": " +error.message()); ++} ++ ++void OpticalDrive::slotEjectRequested() ++{ ++ m_ejectInProgress = true; ++ Q_EMIT ejectRequested(m_device->udi()); ++} ++ ++void OpticalDrive::slotEjectDone(int error, const QString &errorString) ++{ ++ m_ejectInProgress = false; ++ Q_EMIT ejectDone(static_cast(error), errorString, m_device->udi()); ++} ++ ++void OpticalDrive::initReadWriteSpeeds() const ++{ ++#if 0 ++ int read_speed, write_speed; ++ char *write_speeds = 0; ++ QByteArray device_file = QFile::encodeName(m_device->property("Device").toString()); ++ ++ //qDebug("Doing open (\"%s\", O_RDONLY | O_NONBLOCK)", device_file.constData()); ++ int fd = open(device_file, O_RDONLY | O_NONBLOCK); ++ if (fd < 0) { ++ qWarning("Cannot open %s: %s", device_file.constData(), strerror (errno)); ++ return; ++ } ++ ++ if (get_read_write_speed(fd, &read_speed, &write_speed, &write_speeds) >= 0) { ++ m_readSpeed = read_speed; ++ m_writeSpeed = write_speed; ++ ++ QStringList list = QString::fromLatin1(write_speeds).split(',', QString::SkipEmptyParts); ++ Q_FOREACH (const QString & speed, list) ++ m_writeSpeeds.append(speed.toInt()); ++ ++ free(write_speeds); ++ ++ m_speedsInit = true; ++ } ++ ++ close(fd); ++#endif ++} ++ ++QList OpticalDrive::writeSpeeds() const ++{ ++ if (!m_speedsInit) ++ initReadWriteSpeeds(); ++ //qDebug() << "solid write speeds:" << m_writeSpeeds; ++ return m_writeSpeeds; ++} ++ ++int OpticalDrive::writeSpeed() const ++{ ++ if (!m_speedsInit) ++ initReadWriteSpeeds(); ++ return m_writeSpeed; ++} ++ ++int OpticalDrive::readSpeed() const ++{ ++ if (!m_speedsInit) ++ initReadWriteSpeeds(); ++ return m_readSpeed; ++} ++ ++Solid::OpticalDrive::MediumTypes OpticalDrive::supportedMedia() const ++{ ++ const QStringList mediaTypes = m_device->prop("MediaCompatibility").toStringList(); ++ Solid::OpticalDrive::MediumTypes supported; ++ ++ QMap map; ++ map[Solid::OpticalDrive::Cdr] = "optical_cd_r"; ++ map[Solid::OpticalDrive::Cdrw] = "optical_cd_rw"; ++ map[Solid::OpticalDrive::Dvd] = "optical_dvd"; ++ map[Solid::OpticalDrive::Dvdr] = "optical_dvd_r"; ++ map[Solid::OpticalDrive::Dvdrw] ="optical_dvd_rw"; ++ map[Solid::OpticalDrive::Dvdram] ="optical_dvd_ram"; ++ map[Solid::OpticalDrive::Dvdplusr] ="optical_dvd_plus_r"; ++ map[Solid::OpticalDrive::Dvdplusrw] ="optical_dvd_plus_rw"; ++ map[Solid::OpticalDrive::Dvdplusdl] ="optical_dvd_plus_r_dl"; ++ map[Solid::OpticalDrive::Dvdplusdlrw] ="optical_dvd_plus_rw_dl"; ++ map[Solid::OpticalDrive::Bd] ="optical_bd"; ++ map[Solid::OpticalDrive::Bdr] ="optical_bd_r"; ++ map[Solid::OpticalDrive::Bdre] ="optical_bd_re"; ++ map[Solid::OpticalDrive::HdDvd] ="optical_hddvd"; ++ map[Solid::OpticalDrive::HdDvdr] ="optical_hddvd_r"; ++ map[Solid::OpticalDrive::HdDvdrw] ="optical_hddvd_rw"; ++ // TODO add these to Solid ++ //map[Solid::OpticalDrive::Mo] ="optical_mo"; ++ //map[Solid::OpticalDrive::Mr] ="optical_mrw"; ++ //map[Solid::OpticalDrive::Mrw] ="optical_mrw_w"; ++ ++ Q_FOREACH ( const Solid::OpticalDrive::MediumType & type, map.keys() ) ++ { ++ if ( mediaTypes.contains( map[type] ) ) ++ { ++ supported |= type; ++ } ++ } ++ ++ return supported; ++} ++ ++void OpticalDrive::slotChanged() ++{ ++ m_speedsInit = false; // reset the read/write speeds, changes eg. with an inserted media ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.h b/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.h +new file mode 100644 +index 0000000..4c98ef5 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksopticaldrive.h +@@ -0,0 +1,81 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2OPTICALDRIVE_H ++#define UDISKS2OPTICALDRIVE_H ++ ++#include ++#include "udisksstoragedrive.h" ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class OpticalDrive: public StorageDrive, virtual public Solid::Ifaces::OpticalDrive ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::OpticalDrive) ++ ++public: ++ OpticalDrive(Device *device); ++ virtual ~OpticalDrive(); ++ ++Q_SIGNALS: ++ void ejectPressed(const QString &udi); ++ void ejectDone(Solid::ErrorType error, QVariant errorData, const QString &udi); ++ void ejectRequested(const QString &udi); ++ ++public: ++ virtual bool eject(); ++ virtual QList writeSpeeds() const; ++ virtual int writeSpeed() const; ++ virtual int readSpeed() const; ++ virtual Solid::OpticalDrive::MediumTypes supportedMedia() const; ++ ++private Q_SLOTS: ++ void slotDBusReply(const QDBusMessage &reply); ++ void slotDBusError(const QDBusError &error); ++ ++ void slotEjectRequested(); ++ void slotEjectDone(int error, const QString &errorString); ++ ++ void slotChanged(); ++ ++private: ++ void initReadWriteSpeeds() const; ++ ++ bool m_ejectInProgress; ++ ++ // read/write speeds ++ mutable int m_readSpeed; ++ mutable int m_writeSpeed; ++ mutable QList m_writeSpeeds; ++ mutable bool m_speedsInit; ++}; ++ ++} ++} ++} ++ ++#endif // UDISKS2OPTICALDRIVE_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.cpp b/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.cpp +new file mode 100644 +index 0000000..9239bcb +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.cpp +@@ -0,0 +1,359 @@ ++/* ++ Copyright 2009 Pino Toscano ++ Copyright 2009-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksstorageaccess.h" ++#include "udisks2.h" ++ ++#include ++#include ++#include ++#include ++ ++using namespace Solid::Backends::UDisks2; ++ ++StorageAccess::StorageAccess(Device *device) ++ : DeviceInterface(device), m_setupInProgress(false), m_teardownInProgress(false), m_passphraseRequested(false) ++{ ++ updateCache(); ++ QDBusConnection::systemBus().connect(UD2_DBUS_SERVICE, m_device->udi(), DBUS_INTERFACE_PROPS, "PropertiesChanged", this, ++ SLOT(slotPropertiesChanged(QString,QVariantMap,QStringList))); ++ ++ // Delay connecting to DBus signals to avoid the related time penalty ++ // in hot paths such as predicate matching ++ QTimer::singleShot(0, this, SLOT(connectDBusSignals())); ++} ++ ++StorageAccess::~StorageAccess() ++{ ++} ++ ++void StorageAccess::connectDBusSignals() ++{ ++ m_device->registerAction("setup", this, ++ SLOT(slotSetupRequested()), ++ SLOT(slotSetupDone(int, const QString&))); ++ ++ m_device->registerAction("teardown", this, ++ SLOT(slotTeardownRequested()), ++ SLOT(slotTeardownDone(int, const QString&))); ++} ++ ++bool StorageAccess::isLuksDevice() const ++{ ++ return m_device->isEncryptedContainer(); // encrypted (and unlocked) device ++} ++ ++bool StorageAccess::isAccessible() const ++{ ++ if (isLuksDevice()) { // check if the cleartext slave is mounted ++ if (m_clearTextPath.isEmpty() || m_clearTextPath == "/") ++ return false; ++ Device holderDevice(m_clearTextPath); ++ return holderDevice.isMounted(); ++ } ++ ++ return m_device->isMounted(); ++} ++ ++QString StorageAccess::filePath() const ++{ ++ if (!isAccessible()) ++ return QString(); ++ ++ QByteArrayList mntPoints; ++ ++ if (isLuksDevice()) { // encrypted (and unlocked) device ++ if (m_clearTextPath.isEmpty() || m_clearTextPath == "/") ++ return QString(); ++ Device holderDevice(m_clearTextPath); ++ mntPoints = qdbus_cast(holderDevice.prop("MountPoints")); ++ if (!mntPoints.isEmpty()) ++ return QFile::decodeName(mntPoints.first()); // FIXME Solid doesn't support multiple mount points ++ else ++ return QString(); ++ } ++ ++ mntPoints = qdbus_cast(m_device->prop("MountPoints")); ++ ++ if (!mntPoints.isEmpty()) ++ return QFile::decodeName(mntPoints.first()); // FIXME Solid doesn't support multiple mount points ++ else ++ return QString(); ++} ++ ++bool StorageAccess::isIgnored() const ++{ ++ return m_device->prop("HintIgnore").toBool(); // FIXME tune ++} ++ ++bool StorageAccess::setup() ++{ ++ if ( m_teardownInProgress || m_setupInProgress ) ++ return false; ++ m_setupInProgress = true; ++ m_device->broadcastActionRequested("setup"); ++ ++ if (m_device->isEncryptedContainer()) ++ return requestPassphrase(); ++ else ++ return mount(); ++} ++ ++bool StorageAccess::teardown() ++{ ++ if ( m_teardownInProgress || m_setupInProgress ) ++ return false; ++ m_teardownInProgress = true; ++ m_device->broadcastActionRequested("teardown"); ++ ++ return unmount(); ++} ++ ++void StorageAccess::slotPropertiesChanged(const QString &ifaceName, const QVariantMap &changedProps, const QStringList &invalidatedProps) ++{ ++ Q_UNUSED(ifaceName); ++ ++ if (changedProps.keys().contains("MountPoints") || invalidatedProps.contains("MountPoints")) { ++ Q_EMIT accessibilityChanged(isAccessible(), isLuksDevice() ? m_clearTextPath : m_device->udi()); ++ } ++} ++ ++void StorageAccess::updateCache() ++{ ++ m_isAccessible = isAccessible(); ++} ++ ++void StorageAccess::checkAccessibility() ++{ ++ const bool old_isAccessible = m_isAccessible; ++ updateCache(); ++ ++ if (old_isAccessible != m_isAccessible) { ++ Q_EMIT accessibilityChanged(m_isAccessible, isLuksDevice() ? m_clearTextPath : m_device->udi()); ++ } ++} ++ ++void StorageAccess::slotDBusReply( const QDBusMessage & reply ) ++{ ++ if (m_setupInProgress) ++ { ++ if (isLuksDevice() && !isAccessible()) { // unlocked device, now mount it ++ if (reply.type() == QDBusMessage::ReplyMessage) ++ m_clearTextPath = reply.arguments().value(0).value().path(); ++ mount(); ++ } ++ else // Don't broadcast setupDone unless the setup is really done. (Fix kde#271156) ++ { ++ m_setupInProgress = false; ++ m_device->broadcastActionDone("setup"); ++ ++ checkAccessibility(); ++ } ++ } ++ else if (m_teardownInProgress) // FIXME ++ { ++ if (isLuksDevice() && !m_clearTextPath.isEmpty() && m_clearTextPath != "/") // unlocked device, lock it ++ { ++ callCryptoTeardown(); ++ } ++ else if (!m_clearTextPath.isEmpty() && m_clearTextPath != "/") { ++ callCryptoTeardown(true); // Lock crypted parent ++ } ++ else ++ { ++ if (m_device->prop("Ejectable").toBool() && !m_device->isOpticalDisc()) // optical drives have their Eject method ++ { ++ // try to "eject" (aka safely remove) from the (parent) drive, e.g. SD card from a reader ++ QString drivePath = m_device->prop("Drive").value().path(); ++ if (!drivePath.isEmpty() || drivePath != "/") ++ { ++ QDBusConnection c = QDBusConnection::systemBus(); ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, drivePath, UD2_DBUS_INTERFACE_DRIVE, "Eject"); ++ msg << QVariantMap(); // options, unused now ++ c.call(msg, QDBus::NoBlock); ++ } ++ } ++ ++ m_teardownInProgress = false; ++ m_device->broadcastActionDone("teardown"); ++ ++ checkAccessibility(); ++ } ++ } ++} ++ ++void StorageAccess::slotDBusError( const QDBusError & error ) ++{ ++ if (m_setupInProgress) ++ { ++ m_setupInProgress = false; ++ m_device->broadcastActionDone("setup", m_device->errorToSolidError(error.name()), ++ m_device->errorToString(error.name()) + ": " +error.message()); ++ ++ checkAccessibility(); ++ } ++ else if (m_teardownInProgress) ++ { ++ m_teardownInProgress = false; ++ m_clearTextPath.clear(); ++ m_device->broadcastActionDone("teardown", m_device->errorToSolidError(error.name()), ++ m_device->errorToString(error.name()) + ": " + error.message()); ++ checkAccessibility(); ++ } ++} ++ ++void StorageAccess::slotSetupRequested() ++{ ++ m_setupInProgress = true; ++ Q_EMIT setupRequested(m_device->udi()); ++} ++ ++void StorageAccess::slotSetupDone(int error, const QString &errorString) ++{ ++ m_setupInProgress = false; ++ Q_EMIT setupDone(static_cast(error), errorString, m_device->udi()); ++} ++ ++void StorageAccess::slotTeardownRequested() ++{ ++ m_teardownInProgress = true; ++ Q_EMIT teardownRequested(m_device->udi()); ++} ++ ++void StorageAccess::slotTeardownDone(int error, const QString &errorString) ++{ ++ m_teardownInProgress = false; ++ m_clearTextPath.clear(); ++ Q_EMIT teardownDone(static_cast(error), errorString, m_device->udi()); ++} ++ ++bool StorageAccess::mount() ++{ ++ QString path = m_device->udi(); ++ ++ if (isLuksDevice()) { // mount options for the cleartext volume ++ path = m_clearTextPath; ++ } ++ ++ QDBusConnection c = QDBusConnection::systemBus(); ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, path, UD2_DBUS_INTERFACE_FILESYSTEM, "Mount"); ++ ++ msg << QVariantMap(); // options, unused now ++ ++ return c.callWithCallback(msg, this, ++ SLOT(slotDBusReply(const QDBusMessage &)), ++ SLOT(slotDBusError(const QDBusError &))); ++} ++ ++bool StorageAccess::unmount() ++{ ++ QString path = m_device->udi(); ++ ++ if (isLuksDevice()) { // unmount options for the cleartext volume ++ path = m_clearTextPath; ++ } ++ ++ QDBusConnection c = QDBusConnection::systemBus(); ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, path, UD2_DBUS_INTERFACE_FILESYSTEM, "Unmount"); ++ ++ msg << QVariantMap(); // options, unused now ++ ++ return c.callWithCallback(msg, this, ++ SLOT(slotDBusReply(const QDBusMessage &)), ++ SLOT(slotDBusError(const QDBusError &)), ++ s_unmountTimeout); ++} ++ ++QString StorageAccess::generateReturnObjectPath() ++{ ++ static int number = 1; ++ ++ return "/org/kde/solid/UDisks2StorageAccess_"+QString::number(number++); ++} ++ ++bool StorageAccess::requestPassphrase() ++{ ++ QString udi = m_device->udi(); ++ QString returnService = QDBusConnection::sessionBus().baseService(); ++ m_lastReturnObject = generateReturnObjectPath(); ++ ++ QDBusConnection::sessionBus().registerObject(m_lastReturnObject, this, QDBusConnection::ExportScriptableSlots); ++ ++ QWidget *activeWindow = QApplication::activeWindow(); ++ uint wId = 0; ++ if (activeWindow!=0) ++ wId = (uint)activeWindow->winId(); ++ ++ QString appId = QCoreApplication::applicationName(); ++ ++ QDBusInterface soliduiserver("org.kde.kded", "/modules/soliduiserver", "org.kde.SolidUiServer"); ++ QDBusReply reply = soliduiserver.call("showPassphraseDialog", udi, returnService, ++ m_lastReturnObject, wId, appId); ++ m_passphraseRequested = reply.isValid(); ++ if (!m_passphraseRequested) ++ qWarning() << "Failed to call the SolidUiServer, D-Bus said:" << reply.error(); ++ ++ return m_passphraseRequested; ++} ++ ++void StorageAccess::passphraseReply(const QString & passphrase) ++{ ++ if (m_passphraseRequested) ++ { ++ QDBusConnection::sessionBus().unregisterObject(m_lastReturnObject); ++ m_passphraseRequested = false; ++ if (!passphrase.isEmpty()) ++ callCryptoSetup(passphrase); ++ else ++ { ++ m_setupInProgress = false; ++ m_device->broadcastActionDone("setup"); ++ } ++ } ++} ++ ++void StorageAccess::callCryptoSetup(const QString & passphrase) ++{ ++ QDBusConnection c = QDBusConnection::systemBus(); ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, m_device->udi(), UD2_DBUS_INTERFACE_ENCRYPTED, "Unlock"); ++ ++ msg << passphrase.toUtf8(); // QByteArray ++ msg << QVariantMap(); // options, unused now ++ ++ c.callWithCallback(msg, this, ++ SLOT(slotDBusReply(const QDBusMessage &)), ++ SLOT(slotDBusError(const QDBusError &))); ++} ++ ++bool StorageAccess::callCryptoTeardown(bool actOnParent) ++{ ++ QDBusConnection c = QDBusConnection::systemBus(); ++ QDBusMessage msg = QDBusMessage::createMethodCall(UD2_DBUS_SERVICE, ++ actOnParent ? (m_device->prop("CryptoBackingDevice").value().path()) : m_device->udi(), ++ UD2_DBUS_INTERFACE_ENCRYPTED, "Lock"); ++ msg << QVariantMap(); // options, unused now ++ ++ m_clearTextPath.clear(); ++ ++ return c.callWithCallback(msg, this, ++ SLOT(slotDBusReply(const QDBusMessage &)), ++ SLOT(slotDBusError(const QDBusError &))); ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.h b/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.h +new file mode 100644 +index 0000000..36f2102 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstorageaccess.h +@@ -0,0 +1,104 @@ ++/* ++ Copyright 2009 Pino Toscano ++ Copyright 2009-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2STORAGEACCESS_H ++#define UDISKS2STORAGEACCESS_H ++ ++#include ++#include "udisksdeviceinterface.h" ++ ++#include ++#include ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++class StorageAccess : public DeviceInterface, virtual public Solid::Ifaces::StorageAccess ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::StorageAccess) ++ ++public: ++ StorageAccess(Device *device); ++ virtual ~StorageAccess(); ++ ++ virtual bool isAccessible() const; ++ virtual QString filePath() const; ++ virtual bool isIgnored() const; ++ virtual bool setup(); ++ virtual bool teardown(); ++ ++Q_SIGNALS: ++ void accessibilityChanged(bool accessible, const QString &udi); ++ void setupDone(Solid::ErrorType error, QVariant errorData, const QString &udi); ++ void teardownDone(Solid::ErrorType error, QVariant errorData, const QString &udi); ++ void setupRequested(const QString &udi); ++ void teardownRequested(const QString &udi); ++ ++public Q_SLOTS: ++ Q_SCRIPTABLE Q_NOREPLY void passphraseReply(const QString & passphrase); ++ ++private Q_SLOTS: ++ void slotPropertiesChanged(const QString & ifaceName, const QVariantMap & changedProps, const QStringList & invalidatedProps); ++ void slotDBusReply(const QDBusMessage & reply); ++ void slotDBusError(const QDBusError & error); ++ ++ void connectDBusSignals(); ++ ++ void slotSetupRequested(); ++ void slotSetupDone(int error, const QString &errorString); ++ void slotTeardownRequested(); ++ void slotTeardownDone(int error, const QString &errorString); ++ ++private: ++ /// @return true if this device is luks and unlocked ++ bool isLuksDevice() const; ++ ++ void updateCache(); ++ void checkAccessibility(); ++ ++ bool mount(); ++ bool unmount(); ++ ++ bool requestPassphrase(); ++ void callCryptoSetup( const QString & passphrase ); ++ bool callCryptoTeardown( bool actOnParent=false ); ++ ++ QString generateReturnObjectPath(); ++ ++private: ++ bool m_isAccessible; ++ bool m_setupInProgress; ++ bool m_teardownInProgress; ++ bool m_passphraseRequested; ++ QString m_lastReturnObject; ++ QString m_clearTextPath; // path to the unlocked cleartext device ++ ++ static const int s_unmountTimeout = 0x7fffffff; ++}; ++} ++} ++} ++ ++#endif // UDISKS2STORAGEACCESS_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.cpp b/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.cpp +new file mode 100644 +index 0000000..3a62857 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.cpp +@@ -0,0 +1,144 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksstoragedrive.h" ++ ++#include "../shared/udevqt.h" ++ ++#include ++#include ++ ++using namespace Solid::Backends::UDisks2; ++ ++StorageDrive::StorageDrive(Device *device) ++ : Block(device) ++{ ++ UdevQt::Client client(this); ++ m_udevDevice = client.deviceByDeviceFile(QFile::decodeName(m_device->prop("Device").toByteArray())); ++} ++ ++StorageDrive::~StorageDrive() ++{ ++} ++ ++qulonglong StorageDrive::size() const ++{ ++ return m_device->prop("Size").toULongLong(); ++} ++ ++bool StorageDrive::isHotpluggable() const ++{ ++ const Solid::StorageDrive::Bus _bus = bus(); ++ return _bus == Solid::StorageDrive::Usb || _bus == Solid::StorageDrive::Ieee1394; ++} ++ ++bool StorageDrive::isRemovable() const ++{ ++ return m_device->prop("MediaRemovable").toBool() || m_device->prop("Removable").toBool(); ++} ++ ++Solid::StorageDrive::DriveType StorageDrive::driveType() const ++{ ++ const QStringList mediaTypes = m_device->prop("MediaCompatibility").toStringList(); ++ ++ if ( m_device->isOpticalDrive() ) // optical disks ++ { ++ return Solid::StorageDrive::CdromDrive; ++ } ++ else if ( mediaTypes.contains( "floppy" ) ) ++ { ++ return Solid::StorageDrive::Floppy; ++ } ++#if 0 // TODO add to Solid ++ else if ( mediaTypes.contains( "floppy_jaz" ) ) ++ { ++ return Solid::StorageDrive::Jaz; ++ } ++ else if ( mediaTypes.contains( "floppy_zip" ) ) ++ { ++ return Solid::StorageDrive::Zip; ++ } ++ else if ( mediaTypes.contains( "flash" ) ) ++ { ++ return Solid::StorageDrive::Flash; ++ } ++#endif ++ else if ( mediaTypes.contains( "flash_cf" ) ) ++ { ++ return Solid::StorageDrive::CompactFlash; ++ } ++ else if ( mediaTypes.contains( "flash_ms" ) ) ++ { ++ return Solid::StorageDrive::MemoryStick; ++ } ++ else if ( mediaTypes.contains( "flash_sm" ) ) ++ { ++ return Solid::StorageDrive::SmartMedia; ++ } ++ else if ( mediaTypes.contains( "flash_sd" ) || mediaTypes.contains( "flash_sdhc" ) ++ || mediaTypes.contains( "flash_mmc" ) || mediaTypes.contains("flash_sdxc") ) ++ { ++ return Solid::StorageDrive::SdMmc; ++ } ++ // FIXME: udisks2 doesn't know about xD cards ++ else ++ { ++ return Solid::StorageDrive::HardDisk; ++ } ++} ++ ++Solid::StorageDrive::Bus StorageDrive::bus() const ++{ ++ const QString bus = m_device->prop("ConnectionBus").toString(); ++ const QString udevBus = m_udevDevice.deviceProperty("ID_BUS").toString(); ++ ++ if (udevBus == "ata") ++ { ++ if (m_udevDevice.deviceProperty("ID_ATA_SATA").toInt() == 1) // serial ATA ++ return Solid::StorageDrive::Sata; ++ else // parallel (classical) ATA ++ return Solid::StorageDrive::Ide; ++ } ++ else if (bus == "usb") ++ { ++ return Solid::StorageDrive::Usb; ++ } ++ else if (bus == "ieee1394") ++ { ++ return Solid::StorageDrive::Ieee1394; ++ } ++ else if (udevBus == "scsi") ++ { ++ return Solid::StorageDrive::Scsi; ++ } ++#if 0 // TODO add these to Solid ++ else if ( bus == "sdio" ) ++ { ++ return Solid::StorageDrive::SDIO; ++ } ++ else if ( bus == "virtual" ) ++ { ++ return Solid::StorageDrive::Virtual; ++ } ++#endif ++ else ++ return Solid::StorageDrive::Platform; ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.h b/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.h +new file mode 100644 +index 0000000..97007b3 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstoragedrive.h +@@ -0,0 +1,61 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2STORAGEDRIVE_H ++#define UDISKS2STORAGEDRIVE_H ++ ++#include ++ ++#include "../shared/udevqt.h" ++ ++#include "udisksblock.h" ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class StorageDrive: public Block, virtual public Solid::Ifaces::StorageDrive ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::StorageDrive) ++ ++public: ++ StorageDrive(Device *device); ++ virtual ~StorageDrive(); ++ ++ virtual qulonglong size() const; ++ virtual bool isHotpluggable() const; ++ virtual bool isRemovable() const; ++ virtual Solid::StorageDrive::DriveType driveType() const; ++ virtual Solid::StorageDrive::Bus bus() const; ++ ++private: ++ UdevQt::Device m_udevDevice; ++}; ++ ++} ++} ++} ++ ++#endif // UDISK2SSTORAGEDRIVE_H +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.cpp b/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.cpp +new file mode 100644 +index 0000000..a7d8fad +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.cpp +@@ -0,0 +1,105 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ Copyright 2010-2012 Lukáš Tinkl ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#include "udisksstoragevolume.h" ++#include "udisks2.h" ++ ++using namespace Solid::Backends::UDisks2; ++ ++StorageVolume::StorageVolume(Device *device) ++ : Block(device) ++{ ++} ++ ++StorageVolume::~StorageVolume() ++{ ++} ++ ++QString StorageVolume::encryptedContainerUdi() const ++{ ++ const QString path = m_device->prop("CryptoBackingDevice").value().path(); ++ if ( path.isEmpty() || path == "/") ++ return QString(); ++ else ++ return path; ++} ++ ++qulonglong StorageVolume::size() const ++{ ++ return m_device->prop("Size").toULongLong(); ++} ++ ++QString StorageVolume::uuid() const ++{ ++ return m_device->prop("IdUUID").toString(); ++} ++ ++QString StorageVolume::label() const ++{ ++ QString label = m_device->prop("HintName").toString(); ++ if (label.isEmpty()) ++ label = m_device->prop("IdLabel").toString(); ++ if (label.isEmpty()) ++ label = m_device->prop("Name").toString(); ++ return label; ++} ++ ++QString StorageVolume::fsType() const ++{ ++ return m_device->prop("IdType").toString(); ++} ++ ++Solid::StorageVolume::UsageType StorageVolume::usage() const ++{ ++ const QString usage = m_device->prop("IdUsage").toString(); ++ ++ if (m_device->hasInterface(UD2_DBUS_INTERFACE_FILESYSTEM)) ++ { ++ return Solid::StorageVolume::FileSystem; ++ } ++ else if (m_device->isPartitionTable()) ++ { ++ return Solid::StorageVolume::PartitionTable; ++ } ++ else if (usage == "raid") ++ { ++ return Solid::StorageVolume::Raid; ++ } ++ else if (m_device->isEncryptedContainer()) ++ { ++ return Solid::StorageVolume::Encrypted; ++ } ++ else if (usage == "unused" || usage.isEmpty()) ++ { ++ return Solid::StorageVolume::Unused; ++ } ++ else ++ { ++ return Solid::StorageVolume::Other; ++ } ++} ++ ++bool StorageVolume::isIgnored() const ++{ ++ const Solid::StorageVolume::UsageType usg = usage(); ++ return m_device->prop("HintIgnore").toBool() || m_device->isSwap() || ++ ((usg == Solid::StorageVolume::Unused || usg == Solid::StorageVolume::Other || usg == Solid::StorageVolume::PartitionTable) && !m_device->isOpticalDisc()); ++} +diff --git a/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.h b/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.h +new file mode 100644 +index 0000000..2ca04d2 +--- /dev/null ++++ b/tier1/solid/src/solid/backends/udisks2/udisksstoragevolume.h +@@ -0,0 +1,57 @@ ++/* ++ Copyright 2010 Michael Zanetti ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) version 3, or any ++ later version accepted by the membership of KDE e.V. (or its ++ successor approved by the membership of KDE e.V.), which shall ++ act as a proxy defined in Section 6 of version 3 of the license. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library. If not, see . ++*/ ++ ++#ifndef UDISKS2STORAGEVOLUME_H ++#define UDISKS2STORAGEVOLUME_H ++ ++#include ++#include "udisksblock.h" ++ ++ ++namespace Solid ++{ ++namespace Backends ++{ ++namespace UDisks2 ++{ ++ ++class StorageVolume: public Block, virtual public Solid::Ifaces::StorageVolume ++{ ++ Q_OBJECT ++ Q_INTERFACES(Solid::Ifaces::StorageVolume) ++ ++public: ++ StorageVolume(Device *device); ++ virtual ~StorageVolume(); ++ ++ virtual QString encryptedContainerUdi() const; ++ virtual qulonglong size() const; ++ virtual QString uuid() const; ++ virtual QString label() const; ++ virtual QString fsType() const; ++ virtual Solid::StorageVolume::UsageType usage() const; ++ virtual bool isIgnored() const; ++}; ++ ++} ++} ++} ++ ++#endif // UDISKS2STORAGEVOLUME_H diff --git a/kdelibs.spec b/kdelibs.spec index ea7f852..141939d 100644 --- a/kdelibs.spec +++ b/kdelibs.spec @@ -11,6 +11,11 @@ %if 0%{?fedora} && 0%{?fedora} > 16 %define libplasma_pk 1 %endif +%if 0%{?rhel} > 6 || 0%{?fedora} > 17 +%define udisks udisks2 +%else +%define udisks udisks +%endif %global phonon_version %(pkg-config --modversion phonon 2>/dev/null || echo %{phonon_ver}) %global shared_desktop_ontologies_version %(pkg-config --modversion shared-desktop-ontologies 2>/dev/null || echo %{shared_desktop_ontologies_ver}) @@ -19,7 +24,7 @@ %global dbusmenu_qt_version %(pkg-config --modversion dbusmenu-qt 2>/dev/null || echo %{dbusmenu_qt_ver}) Summary: KDE Libraries -Version: 4.8.2 +Version: 4.8.3 Release: 1%{?dist} Name: kdelibs @@ -114,6 +119,13 @@ Patch41: 0002-Trigger-installation-of-missing-components-when-inst.patch # https://git.reviewboard.kde.org/r/102350/ Patch42: 0003-Implement-automatic-scanning-of-source-code-for-requ.patch +# make forcefully hal-free build +Patch45: kdelibs-4.7.3-halectomy.patch + +# udisks2 Solid backend, halectomy +Patch46: kdelibs-4.8.2-udisks2_prep.patch +Patch47: kdelibs-udisks2-backend.patch + ## upstreamable # knewstuff2 variant of: # https://git.reviewboard.kde.org/r/102439/ @@ -129,18 +141,14 @@ Patch52: kdelibs-4.7.4-SOLID_UPNP.patch # add s390/s390x support in kjs Patch53: kdelibs-4.7.2-kjs-s390.patch -## upstream -# don't set rpath on multiarch dirs, https://git.reviewboard.kde.org/r/103422 -Patch101: kdelibs-4.8.0-cmake_cxx_implicit_link_directories.patch +## upstream +# fix kdeclarative install location (by wstephenson as found in kde-packager list) +Patch100: kdelibs-4.8.3-kdeclarative-install-location.patch ## security fix # Not Upstreamed? why not ? -- Rex Patch200: kdelibs-4.3.1-CVE-2009-2702.patch -## Fedora specific patches -# make forcefully hal-free build -Patch300: kdelibs-4.7.3-halectomy.patch - # force upgrade of apps using the discontinued KatePart Smart* interfaces to # versions using the new Moving* interfaces instead # conditionize these? how long to carry them? -- rex @@ -198,7 +206,7 @@ BuildRequires: zlib-devel %define x_deps pkgconfig(sm) pkgconfig(xcomposite) pkgconfig(xdamage) pkgconfig(xkbfile) pkgconfig(xpm) pkgconfig(xscrnsaver) pkgconfig(xtst) pkgconfig(xv) pkgconfig(xxf86misc) %{?x_deps:BuildRequires: %{x_deps}} -Requires: udisks upower +Requires: %{?udisks} upower %if 0%{?apidocs} BuildRequires: docbook-dtds @@ -314,6 +322,15 @@ sed -i -e "s|@@VERSION_RELEASE@@|%{version}-%{release}|" kio/kio/kprotocolmanage %patch42 -p1 -b .libplasma-pk-0003 %endif +%if "%{?udisks}" == "udisks2" +pushd solid +%patch46 -p2 -b .udisks2_prep +%patch47 -p4 -b .udisks2backend +popd +%else +%patch45 -p1 -b .halectomy +%endif + # upstreamable patches %patch50 -p1 -b .knewstuff2_gpg2 %patch51 -p1 -b .uri_mimetypes @@ -321,13 +338,10 @@ sed -i -e "s|@@VERSION_RELEASE@@|%{version}-%{release}|" kio/kio/kprotocolmanage %patch53 -p1 -b .kjs-s390 # upstream patches -%patch101 -p1 -b .cmake_cxx_implicit_link_directories # security fixes %patch200 -p1 -b .CVE-2009-2702 -# Fedora patches -%patch300 -p1 -b .halectomy %build @@ -559,6 +573,7 @@ rm -rf %{buildroot} %{_kde4_bindir}/kde4-doxygen.sh %{_kde4_appsdir}/cmake/ %{_kde4_includedir}/* +%{_kde4_libdir}/cmake/KDeclarative/ %{_kde4_libdir}/kde4/devel/ %if 0%{?apidocs} @@ -575,6 +590,21 @@ rm -rf %{buildroot} %changelog +* Mon Apr 30 2012 Jaroslav Reznik - 6:4.8.3-1 +- 4.8.3 +- remove cmake implicit link directories patch +- remove adblock filter patch +- add kdeclarative install location patch + +* Mon Apr 16 2012 Rex Dieter 6:4.8.2-4 +- enable udisks2, +Requires: udisks2 on f18+ too + +* Mon Apr 16 2012 Lukas Tinkl - 6:4.8.2-3 +- add udisks2 Solid backend plus RHEL conditional + +* Thu Apr 12 2012 Than Ngo - 6:4.8.2-2 +- Load/Update filter lists only when AdBlock is enabled + * Fri Mar 30 2012 Jaroslav Reznik - 6:4.8.2-1 - 4.8.2 diff --git a/sources b/sources index 8d77428..8cc8f31 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -e9dc9a76a785045642fb3098692618d2 kdelibs-4.8.2.tar.xz +c4987c838164bd9ee2787e77243fe4a9 kdelibs-4.8.3.tar.xz